16_反射

Java用于描述一类事物的共性，该类事物有什么属性，没有什么属性，至于这个属性的值是什么，则是有这个类的实例对象来确定的，不同的实例对象有不同的属性值。Java程序中各个Java类，他们是否属于同一类事物，是不是可以用一个类来描述这类事物呢？这个类的名字就是Class.Class描述了那些方面的信息呢？类的名字，类的访问属性，类所属的包名，字段名称的列表。方法名称的列表，等等。学习反射，首先就要明白Class这个类。

获得某个类的字节码：

• 类名.class--->Person.class
  
• 对象名.getClass--->new Person().getClass()
  
• Class.forName("类名")----->Class.forName("java.lang.String");//反射主要用这种
  

九个预定义Class对象
boolean,byte,char,short,int,long,float,double,void

Boolean.TYPE(表示基本类型 boolean 的 Class 对象。), 

Character.TYPE(表示基本类型 char 的 Class 实例。), 

Byte.TYPE(表示基本类型 byte 的 Class 实例。), 

Short.TYPE(表示基本类型 short 的 Class 实例。), 

Integer.TYPE(表示基本类型 int 的 Class 实例。),

 Long.TYPE(表示基本类型 long 的 Class 实例。),

 Float.TYPE(表示 float 基本类型的 Class 实例。), 

Double.TYPE(表示基本类型 double 的 Class 实例。), 

Void.TYPE(表示对应于关键字 void 的伪类型的 Class 对象。)

Class.isPrimitive(); 判定指定的 Class 对象是否表示一个基本类型

判断数组类型的Class实例对象用的方法是：Class.isArray();

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

String str1="abac";
		Class cls1=str1.getClass();
		Class cls2=String.class;
		Class cls3=Class.forName("java.lang.String");
		
		System.out.println(cls1==cls2);
		System.out.println(cls1==cls3);
		
		//这个字节码是否是原始类型
		System.out.println(cls1.isPrimitive());
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class==Integer.class);
		System.out.println(int.class==Integer.TYPE);//Integer.type表示基本类型 int 的 Class 实例
		System.out.println(int[].class.isArray());

反射
反射就是把Java类中的各种成分映射成相应的Java类。例如：一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个类。表示Java类的Class类显然要提供一系列方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应的实例对象来表示，他们是Field、Method、Constructor、Package等等。
ConStructor类

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

得到某个类所有的构造方法

例子：Constructor[] constructors=Class.forName("java.lang.String").getConstructors();

得到某一个构造方法

ConStructor constructor=Class.forName("java.lang.String").getConstructor(StringBuffer.class);//参数表示获得方法是要用的类型

创建实例对象：

通常的方法：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();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。

import java.lang.reflect.Constructor;

public class Test {

	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		//获得其带有参数StringBuffer的构造方法
		Constructor<String> constructors=String.class.getConstructor(StringBuffer.class);
		//使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例。
		String str=constructors.newInstance(new StringBuffer("abc"));
		System.out.println(str);
	}

}

本篇中所用的ReflectPoint类均为此类：

public class ReflectPoint {

	private int x;
	public int y;
	public String str1="ball";
	public String str2="basketball";
	public String str3="itcast";
	
	public ReflectPoint(int x, int y) {
		this.x = x;
		this.y = y;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "str1："+str1+" str2："+str2+" str3："+str3;
	}

	@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;
	}

	

	
}

Field类

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

import java.lang.reflect.Field;

public class Test {

	public static void main(String[] args) throws Exception{
		//创建一个对象的实例
		ReflectPoint rfp=new ReflectPoint(3, 5);
		//获取这个对象的一个成员
		Field field=rfp.getClass().getField("y");
		//得到这个成员的值
		System.out.println(field.getInt(rfp));
	
		//返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
		Field field2=rfp.getClass().getDeclaredField("x");
		//因为x成员为私有的，所以要设置其可访问性
		field2.setAccessible(true);
		System.out.println(field2.getInt(rfp));
	}

}

练习：将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的b改为a

import java.lang.reflect.Field;

public class Test {

	public static void main(String[] args) throws Exception{
		ReflectPoint rfp=new ReflectPoint(3, 5);
		changeStringValue(rfp);
		System.out.println(rfp);

		
	}
	
	public static void changeStringValue(Object obj) throws Exception{
		Field [] fields=obj.getClass().getFields();
		for(Field field:fields)
		{
			//同一份字节码，用等号比较好一些
			if(field.getType()==String.class)
			{
				String str=(String)field.get(obj);
				String str1=str.replace('b', 'a');
				field.set(obj, str1);
			}
		}
	}
}

Method类

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

得到类中的某一个方法：

例如：Method  charAt=Class.forName("java.lang.String").getMethod("charAt",int.class);

调用方法：

通常方法：System.out.println(str.charAt(1));

反射方法：System.out.println(charAt.invoke(str,1));

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

import java.lang.reflect.Method;

public class Test {

	public static void main(String[] args) throws Exception{
		String str="abc";
		Method method=Class.forName("java.lang.String").getMethod("charAt", int.class);
		System.out.println(method.invoke(str, 1));
	}
}

练习：写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main()方法。

package again.reflect;


import java.lang.reflect.Method;

public class Test {

	public static void main(String[] args) throws Exception{
		String testClassName=args[0];//这个类要传入的参数是要测试的那个类名：again.reflect.TestArgument
		Method method=TestArgument.class.getMethod("main", String[].class);
		method.invoke(null, (Object)new String[]{"111","222","333"});
		//或者下面这种写法
		method.invoke(null, new Object[]{new String[]{"111","222","333"}});	
	}
}

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

数组的反射

具有相同维数和元素类型的数组属于同一个类型。即具有相同的Class实例对象。

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

基本数据类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型那个的一维数组，既可以当作Object类型使用，又可以当作Object[]类型使用。

Arrays.asList()方法处理int[]和String[]时是有差异的。

int [] a1=new int[]{1,2,3};
		int [] a2=new int[4];
		int [][] a3=new int[2][3];
		String [] a4=new String[]{"a","b","c"};
		System.out.println(a1.getClass()==a2.getClass());
//		System.out.println(a1.getClass()==a4.getClass());错误的
//		System.out.println(a1.getClass()==a3.getClass());错误的
		System.out.println(a1.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		
		Object aobj1=a1;
		Object aobj2=a4;
//		Object[] aobj3=a1;错误的
		Object[] aobj4=a3;
		Object[] aobj5=a4;
		
		System.out.println(Arrays.toString(a1));
		System.out.println(Arrays.toString(a4));
		System.out.println(Arrays.asList(a1));

用反射模拟一个小框架：

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;

public class ReflectTest2 {

	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		/*
		HashSet将集合分成若个区域，每个对象可以计算出一个哈希码，可以将哈希码分组，
		每组分别对应某个存储区域，根据一个对象的哈希码就可以确定该对象应该存储在那个区域。
		*/
		//配置文件要放到工程的目录下
//		InputStream ips=new FileInputStream("config.properties");
		
		//配置文件需要放到src目录下
		InputStream ips=ReflectTest2.class.getClassLoader().getResourceAsStream("config.properties");
		Properties props=new Properties();
		props.load(ips);
		ips.close();
		
		String className=props.getProperty("className");
		Collection collections=(Collection)Class.forName(className).newInstance();
//		Collection collections=new HashSet();
		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;当这里改变值后，下面的移除将失败，这就会发生内存溢出
//		System.out.println(collections.remove(pt1));
		System.out.println(collections.size());
	}

}

config.properties的内容如下：