反射：Class类、反射概念、类中各成员的反射、反射的应用、数组的反射、框架

1  反射的基础Class类

      Person类代表人，它的实例对象就是张三，李四这样一个个具体的人。

      在Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。

 

      Class类代表Java类，它的各个实例对象又分别对应什么呢？
      对应各个类在内存中的字节码。例如，Person类的字节码，ArrayList类的字节码等等。

 

      一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class。

      Class类描述了哪些方面的信息呢：类的名字，类的访问属性，类所属于的包名，字段名称的列表、方法名称的列表，等等。

      学习反射，首先就要明白Class这个类。

 

如何得到各个字节码对应的实例对象（Class类型）：
      1，类名.class，例如，System.class。
      2，对象.getClass()，例如，new Date().getClass()。
      3，Class.forName("类名")，例如，Class.forName("java.util.Date");。

九个预定义Class实例对象（八大基本类型+void）：

      Byte.TYPE，Integer.TYPE，Short.TYPE，Long.TYPE，Float.TYPE，Double.TYPE，Character.TYPE，Boolean.TYPE，Void.TYPE。（返回对应的基本数据类型的字节码Class对象）

      这些对象通过基本数据类型调用，被public static final修饰。

      这些对象仅能通过下列声明为public static final的变量访问。

 

注意：

      1、Int.class == Integer.TYPE。

      2、数组类型的Class实例对象Class.isArray()为true。

总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void…

 

示例：

public class ReflectDemo{
    public static void main(String[] args) throws Exception {
		String str = "abc";
		
		//三种获取字节码对象的方式：
		Class clazz1 = String.class;
		Class clazz2 = str.getClass();
		Class clazz3 = Class.forName("java.lang.String" );
		
		System. out.println(clazz1 == clazz2);//true
		System. out.println(clazz2 == clazz3);//true
		
		System. out.println(clazz1.isPrimitive());//false
		System. out.println(int.class.isPrimitive()); //true
		
		//这里注意，基本类型int和包装类Integer的Class对象(字节码)不同。
		System. out.println(int.class == Integer.class);//false
		
		//Integer.TYPE，表示基本类型int的Class对象。
		System. out.println(int.class == Integer.TYPE);//true
		
		System. out.println(int[].class.isPrimitive());//false
		System. out.println(int[].class.isArray());//true
	}
}

2  反射的概念

      反射就是把Java类中的各种成分映射成相应的java类。

      例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示。就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。

      表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。

     一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象。

3  构造方法的反射Constructor类

Constructor类代表某个类中的一个构造方法。

Constructor对象代表一个构造方法，Constructor对象上会有的方法有：得到方法名字，得到所属于的类，产生实例对象。

 

得到某个类所有的构造方法：
      例子：Constructor[] constructors= Class.forName("java.lang.String").getConstructors();

得到某一个构造方法：
        例子：Constructor constructor = Class.forName("java.lang.String").getConstructor(StringBuffer.class);  //获得方法时要用到类型

注意：

      一个类有多个构造方法，根据getConstructors() 中参数的个数和类型，区分清楚想得到其中的哪个方法

      例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。

重点：getConstructors() 中参数类型用什么方式表示？用Class实例对象。

重点：getConstructors()只能获得被public修饰的构造函数。没有public修饰的可以通过getDeclaredConstructor()获得。

 

创建实例对象：

      通常方式：String str = new String(new StringBuffer("abc"));

      反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));

                           //调用获得的方法时要用到上面相同类型的实例对象

Class.newInstance()方法：
      例子：String obj = (String)Class.forName("java.lang.String").newInstance(); //该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

 

代码示例：

public class ContructroReflect {
	public static void main(String[] args) throws Exception {
		
		//根据参数列表中传递的Class对象，获取相应的构造函数。
		Constructor constructor = String.class.getConstructor(StringBuffer.class);
		
		//使用此Constructor对象表示的构造方法来创建该构造方法的声明类的新实例，
		//并用指定的初始化参数初始化该实例。
		String str = (String)constructor.newInstance( new StringBuffer("abc" ));
		
		System. out.println(str.charAt(2));
		//结果：c
    }
}

4  成员变量的反射（暴力反射）

Field类代表某个类中的一个成员变量。

问题：

得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？

类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？

所以字段field X 代表的是X的定义，而不是具体的X变量。

 

getField()：获取公有字段的Class实例。

getDeclaredField()：获取私有字段的Class实例。

fieldX.setAccessible( true)：可以使对象rp中的私有成员变量X，可以从外部被访问，即fieldX.get( rp)，这称为暴力反射。

 

代码示例：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

class ReflectPoint {
	private int x;
	public int y ;
    
	public ReflectPoint(int x, int y) {
		 super();
		 this.x = x;
		 this.y = y;
	}
}

public class FieldReflect{
	public static void main(String[] args) throws Exception {
		ReflectPoint rp = new ReflectPoint(3, 5);
		
		Field fieldY = rp.getClass().getField( "y");//获取字段Y的Class实例
		/* 	fieldY值是多少？是5？错！
			fieldY不是对象身上的变量，而是类上的定义，
			要用它去取某个对象上对应的值。 */
		
		System. out.println(fieldY.get(rp));//用fieldY对象获取rp上相应的值
		//结果：5
		
		Field fieldX = rp.getClass().getDeclaredField("x");//获取私有字段
		
		fieldX.setAccessible(true); //使private类型的成员变量也可以被获取值，称为暴力反射
		
		System. out.println(fieldX.get(rp));//暴力反射后，私有的成员变量也可以被取值
		
		/* 	getField方法只能获取公有字段的Class实例。
			getDeclaredField方法可以获取私有字段的Class实例。
			
			然后通过setAccessible(true)方法使私有的成员变量也可以被访问到。 
			这称为暴力反射（private修饰的成员变量只能在本类内访问）。*/
	}
}

暴力反射：

通过调用字段fieldX的setAccessible( true) 方法，可以使对象rp中的私有成员变量X，可以从外部被访问，即fieldX.get( rp)，这称为暴力反射。

5  成员方法的反射

Method类代表某个类中的一个成员方法。

得到类中的某一个方法：
      例子：Method charAt = Class.forName("java.lang.String").getMethod("charAt", int.class);
调用方法：
      通常方式：char x = str.charAt(1));
      反射方式：char x = charAt.invoke(str, 1));  //调用charAt实例代表的方法，调用者是str字符串，传递参数1。

注意：

      如果传递给Method对象的invoke()方法的第一个参数为null，说明该Method对象对应的是一个静态方法！

jdk1.4和jdk1.5的invoke方法的区别：

      Jdk1.4：public Object invoke(Object obj,Object[] args)
      Jdk1.5：public Object invoke(Object obj,Object... args)  //可变参数

代码示例：

import java.lang.reflect.Method;
public class MethodReflect{
	public static void main(String[] args) throws Exception {
		String str = "abc";
		
		//获取charAt(int)方法的Class实例。
		Method methodCharAt = String.class.getMethod("charAt", int.class );
		
		// invoke(str, 1)：调用str中的当前方法，参数是1.
		System. out.println(methodCharAt.invoke(str, 1));//结果：b
		System. out.println(methodCharAt.invoke(str, new Object[]{2}));//结果：c
	}
}

6  用反射方式执行某个类中的main方法

写一个程序A，该程序能根据用户提供的类名B，去执行B类中的main方法。

通过给A的main方法设置传入的参数，来指定B类的类名。

 

命令行下给main方法传递参数：B类的类名(包括包路径)在java运行命令之后。

Eclipse中给main方法传递参数：右击Run As-->点击Run Configurations-->点击Arguments选项卡。

 

问题：

      启动Java程序的main方法的参数是一个字符串数组，

      即public static void main(String[] args)，

      通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？

      按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac按jdk1.4的语法进行处理，即把数组拆开成若干个单独的参数。

      所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})；javac只把它当作jdk1.4的语法进行理解，即把数组拆开成若干个单独的参数，而不把它当作jdk1.5的语法解释(整个数组是一个参数)，因此会出现参数类型不对的问题。

 

解决该问题的方法：

方法一：mainMethod.invoke(null, new Object[]{new String[]{"xxx"}});  //多加一个数组。

方法二：mainMethod.invoke(null, (Object)new String[]{"xxx"});  //(Object) 是告诉编译器，传递的是一个对象不是一个数组，就不会把数组拆开成若干个单独的参数了。

 

代码示例：

package mypkg;
import java.lang.reflect.Method;

public class MainReflect{
	public static void main(String[] args) throws Exception {
		String startingClassName = args[0];
		
		Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);
		
	  //mainMethod.invoke(null, new Object[]{new String[]{"111","222","333"}}); //方法一
		mainMethod.invoke(null, (Object)new String[]{"111","222","333"}); //方法二
	}
}

class TestArguments{
	public static void main(String[] args) {
		for(String arg : args){
			System. out.println(arg);
		}
	}
}

命令行下编译、运行结果：

7  数组的反射

7.1 数组的反射特点

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。

代表数组的Class实例对象的getSuperClass()方法，返回的父类为Object类对应的Class。

 

基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；

非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。

 

代码及注释：

public class ArrayReflect {
	public static void main(String[] args) throws Exception {
		int [] a1 = new int[3];
		int [] a2 = new int[4];
		int [][] a3 = new int[2][3];
		String[] a4 = new String[3];

	 	System.out.println(a1.getClass() == a2.getClass());//结果：true
		System.out.println(a1.getClass() == a4.getClass());//结果：false
		System.out.println(a1.getClass() == a3.getClass());//结果：false
		
		
		System. out .println(a1.getClass().getName());//结果：[I
	    /* Class类的getName方法返回值中[表示数组的深度，
		[表示一维数组，[[表示二维数组。剩下的内容则表示数组类型，例如I表示int类型. */
		
		System. out .println(a1.getClass().getSuperclass().getName());//结果：java.lang.Object
		System. out .println(a4.getClass().getSuperclass().getName());//结果：java.lang.Object
		
		
		Object aObj1 = a1; //int[]数组是Object，int不是Object。
		Object aObj2 = a4;
	 	
		//Object[] aObj3 = a1; //a1是int类型的数组，int不是Object，因此编译就会报错
		
		//a3是数组的数组，元素也是一维数组，父类是Object，因此不会报错
		Object[] aObj4 = a3;
		
		//a4是String的数组，String父类是Object，因此不会报错
		Object[] aObj5 = a4;
	}
}

7.2  Arrays类的asList()方法处理int[]和String[]时的差异

JDK1.4中为 Arrays.asList(Object[] a);

JDK1.5中为 Arrays.asList(T... a);

所以 as.List( new int[]{1,2,3}) 中，数组元素的类型是int，而int不是Object，所以不能打印出数组内容。

代码及注释：

import java.util.Arrays;

public class ArrayReflect2 {
    public static void main(String[] args) throws Exception {
		int [] a5 = new int[]{1,2,3};
		String[] a6 = new String[]{"a" ,"b" ,"c" };
		
		//直接使用System.out.println无法打印出数组的内容
		System. out .println(a5); //结果：[I@18a992f
		System. out .println(a6); //结果：[Ljava.lang.String;@4f1d0d
	   
		//通过Arrays.asList方法打印出数组的内容
		System. out .println(Arrays.asList(a5));
		/* 结果：[[I@18a992f]
		原因是因为JDK1.4中为Arrays.asList(Object[] a)，JDK1.5中为Arrays.asList(T... a)。
		a5是int[]类型，元素类型int不是Object，JDK1.4中的asList方法处理不了，JDK1.5可以处理。
		但是JDK1.5将 int数组整体作为一个参数进行处理。
		因此最终结果就是将 int[]进行了封装，结果类型也就成了[[I。 */
		
		System. out .println(Arrays.asList(a6));
		//结果：[a, b, c]
    }
}

注意：Class类的getName方法返回值中[表示数组的深度，[表示一维数组，[[表示二维数组。剩下的内容则表示数组类型，例如I表示int类型。

 

7.3  Array类用于完成对数组的反射操作

反射中，Array类表示数组，位于java.lang.reflect 包中。

 

Array类对数组的反射操作：

import java.lang.reflect.Array;

public class ArrayReflect3 {
    public static void main(String[] args) throws Exception {
		String[] a1 = new String[]{"a","b","c"};
		String a2 = "xyz";
	   
		printObject(a1);
		printObject(a2);
    }
  
    public static void printObject(Object obj){
		Class clazz = obj.getClass(); //获取Class实例对象
		
		if(clazz.isArray()){ //如果是数组
			int len = Array.getLength(obj); //获取数组长度
			for(int i = 0; i < len; i++){
				System. out.println(Array.get(obj, i)); //打印 obj[i]
		    }
		}else{
		   System. out.println(obj);
		}
   }
}

8  反射的作用：实现框架功能

框架：
我做房子卖给用户住，由用户自己安装门窗和空调，我做的房子就是框架，用户需要使用我的框架，把门窗插入进我提供的框架中。

框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。

 

框架要解决的核心问题：

我在写框架（房子）时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类（门窗）呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。

 

下面的代码中实现一个简单的框架，使用时，我们只需更改配置文件中的值，配置文件config.properties存放在当前目录。

Config.properties文件中内容：

className1=java.util.HashSet

className2=java.util.ArrayList

 

代码及注释：

package mypkg;
import java.io.*;
import java.util.*;

public class FrameReflect{
	public static void main(String[] args) throws Exception {
		InputStream is = new FileInputStream("config.properties");
		Properties props = new Properties();
		props.load(is);  //加载配置文件中的内容到Properties集合(键值对)
		is.close();
		
		//config.properties配置文件中内容“className1=java.util.HashSet”
		String className = (String)props.get("className1");
		Collection collections = (Collection)Class.forName(className).newInstance();
		
		ReflectPoint pt1 = new ReflectPoint(3, 3);
		ReflectPoint pt2 = new ReflectPoint(5, 5);
		ReflectPoint pt3 = new ReflectPoint(3, 3);
		
		collections.add(pt1);
		collections.add(pt2);
		collections.add(pt3);
		collections.add(pt1);
		
		//pt1.y = 7;  
		//collections.remove(pt1); //哈希值改变，无法删除
		
		System. out.println(collections.size()); //结果为2
		
	/* 当集合为HashSet时，需要通过比较hashcode值以及equals方法是否返回true决定是否放入。
	如果hashcode值相等并且equals方法返回true，那么就不会放入。因此，集合size为3。
	如果想让size为2，也就是pt1与pt3作为同一个元素存入HashSet集合，
	那就需要覆盖ReflectPoint类的hashCode方法以及equals方法。 */
	}
}
/* 
注意：
当一个对象被存储进HashSet集合中以后，就不能修改这个对象中的那些参与计算哈希值的字段了，
否则，对象修改后的哈希值与最初存储进HashSet集合中时的哈希值就不同了，
在这种情况下，即使在contains方法使用该对象的当前引用作为的参数去HashSet集合中检索对象，
也将返回找不到对象的结果，这也会导致无法从HashSet集合中单独删除当前对象，
从而造成内存泄露。
 */
class ReflectPoint {
	private int x ;
	public int y ;
    
	public ReflectPoint(int x, int y) {
		 super();
		 this.x = x;
		 this.y = y;
	}
	@Override
	public int hashCode() {
		 final int prime = 31;
		 int result = 1;
		result = prime * result + x;
		result = prime * result + y;
		 return result;
    }
	@Override
	public boolean equals(Object obj) {
		 if (this == obj)
			   return true ;
		 if (obj == null)
			   return false ;
		 if (getClass() != obj.getClass())
			   return false ;
		ReflectPoint other = (ReflectPoint) obj;
		 if (x != other.x)
			   return false ;
		 if (y != other.y)
			   return false ;
		 return true ;
    }
}

运行结果：