java反射与多态（父类调用子类）的代码演示

package Test0817;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Base{
int a;

Base(){
a=1;
System.out.println("Base Construct");
}
public void f(){
System.out.println("Base");
}
}

class Sub extends Base{
int a;
int b;
Sub(){
a=2;
b=2;
System.out.println("Sub Construct");
}

Sub(int i){
a=i;
b=i;
System.out.println("Sub Construct.this have one param");
}
public void f(){
System.out.println("Sub");
}
public void f(int m){
System.out.println("Sub,the m = "+m);
}
}

public class TestFanshe {

public static void main(String[] args) throws InstantiationException, IllegalAccessException, SecurityException {
Class<?> c;
try {
c = Class.forName("Test0817.Sub"); //需要有完整的包名.类名
Sub s = (Sub) c.newInstance();//实例化
//得到构造函数
c.getConstructors();
//得到方法
Method method = c.getMethod("f");
System.out.println("the method is "+method.toString());

Class[] paramerClass = new Class[1];
paramerClass[0] = int.class; //这个地方要写int,与形参的参数类型一致，写Integer就会报方法找不到
Method method1 = c.getMethod("f", paramerClass);
System.out.println("the method is "+method1.toString());
//通过反射，调用s对象的方法
method.invoke(s); //无参数的

int a=10;
method1.invoke(s, a); //一个参数的
method1.invoke(s, 20);

//实例化，将父类引用指向
Base b = (Base) c.newInstance();
Base bs = (Sub) c.newInstance();
//Sub sb = (Base) c.newInstance(); 报错
s.f(); //输出 sub
b.f(); //输出 sub
//b.f(10);//报错，无法调用父类中没有的子类方法
bs.f(); //输出 sub
//bs.f(10);//报错，无法调用父类中没有的子类方法
} catch (ClassNotFoundException e) {
System.out.println("发生无该类异常");
e.printStackTrace();
}catch(NoSuchMethodException e){
System.out.println("发生无该方法异常");
e.printStackTrace();
}catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}

输出结果：

Base Construct
Sub Construct
the method is public void Test0817.Sub.f()
the method is public void Test0817.Sub.f(int)
Sub
Sub,the m = 10
Sub,the m = 20
Base Construct
Sub Construct
Base Construct
Sub Construct

package Test0817;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Base{
    int a;

    Base(){
        a=1;
        System.out.println("Base Construct");
    }
    public void f(){
        System.out.println("Base");
    }
}

class Sub extends Base{
    int a;
    int b;
    Sub(){
        a=2;
        b=2;
        System.out.println("Sub Construct");
    }

    Sub(int i){
        a=i;
        b=i;
        System.out.println("Sub Construct.this have one param");
    }
    public void f(){
        System.out.println("Sub");
    }
    public void f(int m){
        System.out.println("Sub,the m = "+m);
    }
}

public class TestFanshe {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException, SecurityException {
        Class<?> c;
        try {
            c = Class.forName("Test0817.Sub"); //需要有完整的包名.类名
            Sub s = (Sub) c.newInstance();//实例化
            //得到构造函数
            c.getConstructors();
            //得到方法
            Method method = c.getMethod("f");
            System.out.println("the method is "+method.toString());

            Class[] paramerClass = new Class[1];
            paramerClass[0] = int.class; //这个地方要写int,与形参的参数类型一致，写Integer就会报方法找不到
            Method method1 = c.getMethod("f", paramerClass);
            System.out.println("the method is "+method1.toString());
            //通过反射，调用s对象的方法
            method.invoke(s); //无参数的

            int a=10;
            method1.invoke(s, a); //一个参数的
            method1.invoke(s, 20);

            //实例化，将父类引用指向
            Base b = (Base) c.newInstance();
            Base bs = (Sub) c.newInstance();
            //Sub sb = (Base) c.newInstance(); 报错
            s.f(); //输出 sub
            b.f(); //输出 sub
            //b.f(10);//报错，无法调用父类中没有的子类方法
            bs.f(); //输出 sub
            //bs.f(10);//报错，无法调用父类中没有的子类方法
        } catch (ClassNotFoundException e) {
            System.out.println("发生无该类异常");
            e.printStackTrace();
        }catch(NoSuchMethodException e){
            System.out.println("发生无该方法异常");
            e.printStackTrace();
        }catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

时间： 2024-11-08 23:07:01

java反射与多态（父类调用子类）的代码演示的相关文章

多态&amp;&amp;父类调用子类特有的方法

/* 多态 1.没有继承就没有多态 2.代码的体现:父类类型的指针指向子类对象 3.好处:如果函数\方法参数使用的是父类对象,可以传入父类.子类对象 4.局限性: 1>父类类型的变量,不能直接调用子类特有的方法,必须强转为子类类型变量后,才能直接调用子类特有的方法 Animal *aa = [Cat new]; // Animal是父类 Cat是子类 Cat *dd = (Cat *)aa;  // 强制转换为子类 [dd run]; // run是子类Cat特有的方法 */

Java 多态 父类和子类方法的访问控制权限

Java 多态 父类和子类方法的访问控制权限 @author ixenos 父类和子类方法的访问控制权限 继承是为了扩展类的功能,而这种扩展显然就是对一个原始类的扩展,目的还是向上转型来调用,所以这就是一个对象多态的问题. 既然多态,那么访问控制权限就要让父类也能访问. 也就是说,子类重写方法时不能使该方法拥有比父类更严格的访问控制权限. 否则违背了多态,导致向上类型转换后,使用父类变量无法调用该子类私有方法.

java反射系列六之调用属性与方法

调用指定属性 package reflect; import java.lang.reflect.Field; import java.lang.reflect.Modifier; public class TestFiled { public static void main(String[] args) throws Exception { TestFiled t = new TestFiled(); t.test3(); } //调用运行时类中的指定的属性 public void test

Java反射支持通过invoke调用得到的方法

我们应用会用到反射这个知识点,肯定是想要在运行时得到类的信息,根据类的那些信息去做一些特定的操作.那么,首先无疑就是得到类的信息,在JDK中提供了Class对象来保存类的信息.所以,反射的第一步就是得到Class对象.在JDK中提供了两种方式得到Class对象. 我们能收发数据的一个重要原因是redis服务器的实现是单线程的,为此,twemproxy的实现也是单线程的. 倘若user中的name.age属性变化,如何知道它们变化了呢? 今儿 http://www.cnblogs.com/egb3

java反射机制基础

1.首先创建一个抽象父类: package classes; public abstract class BasePrint { public abstract void print(); } 2.创建两个打印类继承抽象父类: package classes; public class print1 extends BasePrint{ @Override public void print() { System.out.println("print1方法执行了"); } } pack

Java面向对象之多态

多态(Polymorphism): 我们说子类就是父类,因此多态的意思就是:父类型的引用可以指向子类的对象 public class PolyTest { public static void main(String[] args) { // TODO 自动生成的方法存根 Flower rose = new Rose();//多态,  子类就是父类,父类型的引用可以指向子类的实例,或者对象 rose.sing(); } } class Flower { public void sing(){ S

java反射基础知识（五）反射应用实践

详解Java反射各种应用 Java除了给我们提供在编译期得到类的各种信息之外,还通过反射让我们可以在运行期间得到类的各种信息.通过反射获取类的信息,得到类的信息之后,就可以获取以下相关内容: Class对象 构造器 变量 方法 私有变量与私有方法 注解 泛型 数组 本文也将从上面几个方面来介绍Java反射.本文涉及的所有代码均在反射代码首先放出一个Java类作为反射的研究对象,类的内容如下: public abstract class FatherObject implements Runnab

JAVA模板方法设计模式（从现实生活角度理解代码原理）

概述: 定义一个功能的框架(骨架),一部分功能是确定的,一部分功能是不确定的,先把确定的部分实现,把不确定的部分延迟到子类中实现. 实现该模式的关键步骤: 第一步:抽象类,实现模板方法,定义功能(确定的以及不确定的)的框架. 第二步:具体类,实现抽象类中的抽象方法,已完成完整的功能. 老规矩,最近想整一台BMW1系,去了趟4S店,店里恰好有一台现车,但颜色我不太喜欢,这时服务顾问上来解释说:"先生,您看中的这台车就这一个型号,外观,发动机,内饰等配置都是一样的,但颜色是可以个性化定制的,所以这个

Java父类对象调用子类实体：方法重写与动态调用

众所周知Java的handle和C++的ponter而不是object对应,我们很熟悉C++的父类pointer调用子类实体的例子,那么对于Java的handle是不是也可以这样呢? 这里我先给一个例子 class Father{ public void announce(){ System.out.println("Father"); } } class Child extends Father{ @Override public void announce(){ System.ou