java反射机制初解

Reflect就是Java为了弥补不能动态改变程序结构、变量类型而搞出来的一个伪动态机制，可以在运行的时候才去获取一个类，而这个类在编译的时候并不知道其名字或结构。怎么理解呢？咱们来看例子

 

【案例1】通过一个对象获得完整的包名和类名

 

package Reflect;
 
/**
 * 通过一个对象获得完整的包名和类名
 * */

class Demo{
    //other codes...
}
 
class hello{
    public static void main(String[] args) {
        Demo demo=new Demo();
        System.out.println(demo.getClass().getName());
    }
}

 【运行结果】：Reflect.Demo

 

【案例2】实例化Class类对象

 

package Reflect;
class Demo{
    //other codes...
}
 
class hello{
    public static void main(String[] args) {
        Class<?> demo1=null;
        Class<?> demo2=null;
        Class<?> demo3=null;
        try{
            //一般尽量采用这种形式
            demo1=Class.forName("Reflect.Demo");
        }catch(Exception e){
            e.printStackTrace();
        }
        demo2=new Demo().getClass();
        demo3=Demo.class;
         
        System.out.println("类名称   "+demo1.getName());
        System.out.println("类名称   "+demo2.getName());
        System.out.println("类名称   "+demo3.getName());
         
    }
}

 【运行结果】：

 

类名称   Reflect.Demo

类名称   Reflect.Demo

类名称   Reflect.Demo

 

这样我们就得到了Class对象。接下来看看我们可以用这个Class做什么

【案例3】通过Class实例化其他类对象

这里我们先构造一个Person类，之后都会用到这个类作演示，就不再贴它的代码了。

 

package Reflect;
 
import java.lang.reflect.Constructor;
 
class Person{
     
    public Person() {
         
    }
    public Person(String name){
        this.name=name;
    }
    public Person(int age){
        this.age=age;
    }
    public Person(String name, int age) {
        this.age=age;
        this.name=name;
    }

    @Override
    public String toString(){
        return "["+this.name+"  "+this.age+"]";
    }
    public String name;
    public int age;
}

 紧接着主函数无参实例化Person类

 

 

class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per=null;
        try {
            //无参实例化
            per=(Person)demo.newInstance();
        } catch (InstantiationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        per.name="Jack";
        per.age=20;
        System.out.println(per);
    }
}

 【运行结果】：

 

[Jack  20]

 

到这里大家应该有所感觉了。没错，这里是无参实例化，当Person这个类本身只有带参数的构造函数的时候，这样做会抛出异常，那么我们当然会猜测，newInstance（）可不可以带参实例化？答案是肯定的，我们能想到，Sun的天才们肯定也能想到。唯一的问题是，事先我们可能并不知道Class有什么构造函数。代码奉上：

 

class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        Person per1=null;
        Person per2=null;
        Person per3=null;
        Person per4=null;
        //取得全部的构造函数
        Constructor<?> cons[]=demo.getConstructors();
        //这里硬编码了，不可取
        try{
            per1=(Person)cons[3].newInstance();
            per2=(Person)cons[2].newInstance("Jack");
            per3=(Person)cons[1].newInstance(20);
            per4=(Person)cons[0].newInstance("Jack",20);
        }catch(Exception e){
            e.printStackTrace();
        }
        System.out.println(per1);
        System.out.println(per2);
        System.out.println(per3);
        System.out.println(per4);
    }
}

 

 

 【运行结果】：

[Jack  20]

[null  20]

[Jack  0]

[null  0]

需要注意的是，获取的构造函数数组是倒序的，第一个构造函数在最后。

那么如果我们对构造函数一无所知，怎么办？也有办法，Java提供了获取特定构造函数及其参数类型的方法。

try {
//无对应构造函数会抛出NoSuchMethodException异常
				Constructor cot1 = demo.getConstructor(String.class);
				Constructor cot2 = demo.getConstructor(new Class[]{String.class});
				Constructor cot3 = demo.getConstructor(int.class);
				Constructor cot4 = demo.getConstructor(String.class,int.class);
				Class[] parameterTypes = cot2.getParameterTypes();
				per1 = (Person)cot1.newInstance("Jacky Chen");
				per2 = (Person)cot2.newInstance("Jacky");
				per3 = (Person)cot3.newInstance(20);
				per4 = (Person)cot4.newInstance("Jacky", 20);
} catch (NoSuchMethodException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}
                System.out.println(per1);
	        System.out.println(per2);
	        System.out.println(per3);
	        System.out.println(per4);

  【运行结果】：

[Jacky Chen  0]

[Jacky  0]

[null  20]

 

[Jacky  20]

 

好了，我们现在已经可以动态实例化一个类。我们还可以做什么，比如，能不能获取类实现的接口？

【案例4】获取类实现的接口

首先定义一个接口China如下

interface China{
    public static final String name="Jack";
    public static  int age=20;
    public void sayChina();
    public void sayHello(String name, int age);
}

 然后让Person实现这个接口

class Person implements China{
    ...
    @Override
    public void sayChina(){
        System.out.println("hello ,China");
    }
    @Override
    public void sayHello(String name, int age){
        System.out.println(name+"  "+age);
    }
}

 主函数咱们这样写

class hello{
    public static void main(String[] args) {
        Class<?> demo=null;
        try{
            demo=Class.forName("Reflect.Person");
        }catch (Exception e) {
            e.printStackTrace();
        }
        //保存所有的接口
        Class<?> intes[]=demo.getInterfaces();
        for (int i = 0; i < intes.length; i++) {
            System.out.println("实现的接口   "+intes[i].getName());
        }
    }
}

  【运行结果】：

实现的接口   Reflect.China

 

接下来咱们还要讲如何获取父类、获取构造函数的修饰符、获取全部属性和方法，反射的应用（结合工厂模式，配合属性文件），相信大家会逐渐感受到反射的魅力。

【未完待续】