java 反射详解

反射

为什么需要反射？

背景知识： Java引用变量有两种类型，一种编译时类型，一种运行时类型。编译时类型由声明变量使用的类型决定。运行时类型由实际赋给他的变量决定。两个类型不一致的话，就可能出现“多态”的情况。

 

package Test01;
class Base{
	final static int book=6;
	public void base(){
		System.out.println("老爸有的函数.......");
	} 
	public void test() {
		System.out.println("普通有的函数.......");
	}
}
public class SubClass extends Base{
	final static String book="哈哈，我修改了book";
	public void test() {
		System.out.println("子类重写的函数.......");
	}
	public void sub(){
		System.out.println("子类才有的函数.......");
	}
	public static void main(String[] args) {
		
		Base base =new Base();
		base.base();
		base.test();
		System.out.println("base里的book是"+base.book); 
		SubClass sub =new SubClass();
		sub.base();
		sub.test();
		System.out.println("sub里的book是"+sub.book);
		//编译和引用类型不一样的
		Base b =new SubClass();
		b.base();
		b.test();
		System.out.println("b里的book是"+b.book);
		//b编译时是Base类型，没提供sub()方法
	/*	b.sub();*/
		
	}
}

 

　　以上代码说明：

1.对象的方法具有多态性。最后一行注释的代码不能通过编译，虽然b的引用变量确实包含了sub方法，但是编译时它仍是Base类型，不能执行 SubClass里的方法（提示：可使用反射来执行该方法）。

2.对象的实例变量不具有多态性。b里的book不是输出子类的book,而是父类的。

运行结果如下：

 

 

       总结下可能出现的问题：程序运行会出现编译和运行的类型不一致的情况，比如Person p =new Student(); 该行代码产生一个p变量，编译时 是Person类型，运行时是Student类型。更不好的例子是程序如果接收外部的一个对象，这个对象编译时是Object,但是运行时却调用对象运行类型时的方法。

解决 程序需要知道 运行时对象和类的信息 情况  这个问题的办法有：

1.假设 运行和编译就完全已经知道对象和类的信息，则强制类型转换，将编译时类型强转为运行时类型。强转时注意：基本数据类型只能在数值类型之间转换（整型，字符型，浮点型），数值型不能喝布尔型转。存在继承关系才父子类之间才能进行强转，否则会CastClassException。因此，在引用强转时候加上instanceof（instanceof用法不清楚的可以搜一下）判断下再转，能增加代码的健壮性。

2假设 只能运行 才能发现对象和类的信息，就得靠 反射解决问题。

下面进入重点啦：

如何获得Class对象呢？

使用Class类的静态方法foreName(String clazzName)方法传入的字符串必须是类的全限定名，包括包名。

1   Class a= Class.forName("Test01.Classloader");
2    System.out.println(a);

 

类的class属性。Person.class.

1  Class a= Base.class;

 

调用某对象的getClass（）方法。该方法是java.lang.object类里的方法，所以所有的对象都能使用。

Base b =new Base();
Class a= b.getClass();

 

对比下，前两种方法都是根据类取得类指定Class对象，但是第二个更好，因为不需要调用方法，而且代码更安全，编译阶段就检查了要访问的该Class对象是否存在。

获得Class对象了还没结束，还需要调用里面的方法来获得Class对象和该类的详细信息。

　　获得Class对象里的构造器，Constructor （在获得类里必须有对应的构造器）

   Class a= Class.forName("Test01.Classloader");
   //无参数
   Constructor  c = a.getConstructor(null);
   //有参数
   Constructor  m = a.getConstructor(String.class,int.class); //数据类型在前，class后面，具体看构造参数
   System.out.println(m);

    　获得Class对象里的方法，Method

Class a= Class.forName("Test01.Classloader");
Method  m = a.getMethod("test", String.class); //第一个是方法名字，后面的是参数类型
   System.out.println(m);

 

      获得Class对象里的实例变量，Field（注：如果同一个包下的两个类，一个被访问类里的成员变量省略修饰符，会报找不到成员变量的错）

 Class a= Class.forName("Test01.Classloader");
  
   Field  m = a.getField("name"); //第一个是方法名字，后面的是参数的类型
   System.out.println(m);

拿到了Class对象里的方法，如果不想到去调用它，拿到了也没用啊。所以，Method对象里有invoke方法。该例子适用适用于默认的构造器。 如果是有参数的构造器，则应该先拿到Constructor 对象再调用这个对象的newInstance（）（注意：此方法带参数）构造该Class对象的实例。

package Test01; 
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
 
public class SubClass{
 
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, NoSuchFieldException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
        Class a= Class.forName("Test01.Classloader");
  
       Object object    = a.newInstance(); //一个实例
       Method test =a.getMethod("test", String.class);
       test.invoke(object, "zyz");
 	}
}

　修改公共的成员变量，引用举例

  Class a= Class.forName("Test01.Classloader");
	   Object object    = a.newInstance(); //一个实例
	   Field f =a.getField("name");
	   f.set(object, "zyz");

　修改公共的成员变量，基本类型 setXxx（Object obj,Xxx val）,getXxx(Object obj) Xxx是基本类型。举例

 Class a= Class.forName("Test01.Classloader");
       Object object    = a.newInstance(); //一个实例
       Field f =a.getField("name");
       f.setXxx(object, "zyz");

 

小注意：上述讨论的都是和公共的构造器，方法，成员变量。私有的(private)就不能同样处理。

原理是通过setAccessible方法，避开了对类的加载器对类的检查。

反例：

 正确的：（对比运行结果）

Classloader类 长这样

package Test01;
public class Classloader{
    public String name;
    public int i;
     private   Classloader(String name) {
         this.name =name;
        System.out.println(name);
    }

}

 

以上讨论了引用类型，基本类型，没涉及，如果想反射创建数组怎么办呢？

对于数组java.lang.reflect包里有个Array类，它能代表所有的数组，利用该类能动态创建数组，操作数组元素。

Array类里有

静态方法 Object newInstance（Class.class,int length）创建有指定实例的数组

静态方法 void setXxx(Object arr,int index,int val)  为arr 数组的第index设值

静态方法 xxx getXxx(Object arr,int index) 返回array数组的第Index个元素

下面代码举例说明

package Test01;


import java.lang.reflect.Array;


public class ArrayTest {
 public static void main(String[] args) {
     //创建一个有指定元素的数组(有点疑问为嘛数组也 是Object，某个返回元素类型元素Object)
    Object object = Array.newInstance(String.class, 3);
    Array.set(object, 2, "小张");
    Object name =Array.get(object, 2);
    System.out.println(name);
}
}

 

 

下面是对反射的一个实际应用举例

准备 1.txt 文件，里面是 

 

a= java.util.Date
b=javax.swing.JFrame

 

package Test01;
//实现了从txt文件中读取key-value,并根据value创建对象，放入hashmap里，即一个简单的对象池功能

import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Properties;


public class ObjectPoolFactory {
     HashMap<String, Object> objectPool =new HashMap<>();
     //创建对象
     public  Object createObject(String className) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
        Class<?> object = Class.forName(className);
         return object.newInstance();
    }
     public void initPool(String fileName) throws IOException, InstantiationException, IllegalAccessException, ClassNotFoundException {
         FileInputStream inputStream =new FileInputStream(fileName);
        Properties properties =new Properties();
        properties.load(inputStream);
        for(String name:properties.stringPropertyNames()) {
            objectPool.put(name,createObject(properties.getProperty(name)));
        }
    }
     //从对象池里读取对象
     public Object getObject(String name) {
        return objectPool.get(name);
    }
     public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException {
         ObjectPoolFactory factory =new ObjectPoolFactory();
         factory.initPool("D://1.txt");
         System.out.println(factory.getObject("a"));
         System.out.println(factory.getObject("b"));
    }
}

 注意 1.txt是这样的 

 

不要画蛇添足 ，变成这样，否则会找不到文件的。(低级错误)

可得到如下 的运行结果输出两个对象。

上面的例子就是Spring框架采用的方式，简化Javaee的开发。但是不同的是从属性文件读的信息太少，spring 是读xml格式的文件。

给之前的对象池工厂增加 配置对象的成员变量 的值 （待续.....）

准备1.txt 文件，里面是 

a= java.util.Date
b=javax.swing.JFrame
#set the title of a
a%title=Test Title