黑马程序员-高新技术（反射）

-----------android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、反射的基石--Class类

1、定义：

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

2、对比提问1：

众多的人用一个什么类表示？众多的java类用一个什么类表示？
    人类---Person
    java类--Class
    注意这里Class是大写的，不是关键字class。

3、对比提问2：

（1）Person类代表人，它的实例对象就是张三，李四这样一个个具体的人，
（2）Class类代表java类，它的各个实现对象又分别对应什么呢？
答：对应各个类在内存中的字节码，例如Person类的字节码，ArrayList类的字节码，等等。
一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？就是Class类。

4、如何得到各个字节码对应的实例对象（Class类型）

（1）类名.class，例如System.class
（2）对象.getClass()，例如new Date().getClass()
（3）Class.forName("类名")，例如 Class.forName("java.util.Data");

获取这个Class对象，有三种方式：
1：通过每个对象都具备的方法getClass来获取。弊端：必须要创建该类对象，才可以调用getClass方法。
2：每一个数据类型(基本数据类型和引用数据类型)都有一个静态的属性class。弊端：必须要先明确该类。
 前两种方式不利于程序的扩展，因为都需要在程序使用具体的类来完成。
3：使用的Class类中的方法，静态的forName方法。
 指定什么类名，就获取什么类字节码文件对象，这种方式的扩展性最强，只要将类名的字符串传入即可。
// 1. 根据给定的类名来获得  用于类加载
String classname = "cn.itcast.reflect.Person";// 来自配置文件
Class clazz = Class.forName(classname);// 此对象代表Person.class
// 2. 如果拿到了对象，不知道是什么类型   用于获得对象的类型
Object obj = new Person();
Class clazz1 = obj.getClass();// 获得对象具体的类型
// 3. 如果是明确地获得某个类的Class对象  主要用于传参
Class clazz2 = Person.class;

5、九个预定义Class实例对象：

八个基本数据类型（boolean,char,byte,short,int,lang,float,double）
八个基本数据类型外加void
参看 Class.isPrimitive方法的帮助

int.class == Integer.TYPE

6、数组类型的Class实例对象

    Class.isArray()

7、总之，只要是在源程序中出现的类型，都有各种的Class实例对象。

    例如int[]，void。

8、代码示例：

class Demo{
    public static void main(String[] args) throws Exception{
        String str1 = "abc";
        Class cls1 = str1.getClass();
        Class cls2 = String.class;
        Class cls3 = Class.forName("java.lang.String");
        System.out.println(cls1 == cls2);               //true
        System.out.println(cls1 == cls3);               //true
        System.out.println(cls1.isPrimitive());         //false
        System.out.println(int.class.isPrimitive());    //true
        System.out.println(int.class == Integer.class); //false
        System.out.println(int.class == Integer.TYPE);  //true
    }   
}

二、反射的概念

反射就是把java类中的各种成分映射成相应的java类。
也可以理解成反射就是程序自己能够检测自身信息，就像人会通过镜子来查看自己的身体。

例如,一个java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也是用一个个java类来表示。

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

一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象胡有什么用？怎么使用？这这是学习和应用反射的要点

 

三、JAVA反射的常规使用步骤

 

反射调用一般分为4个步骤：

1、得到要调用类的class对象

2、对该class对象调用newInstance()方法，得到要调用类的实例对象

3、得到要调用的类中的方法(Method)

4、方法调用(invoke)

四、构造方法的反射

Constructor 类

Constructor类代表某个类中的一个构造方法。
得到某个类所有的构造方法：
例子：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();

该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
该方法内部的具体代码是怎么样写的呢？用到了缓冲机制来保存默认构造方法的实例对象。

一个类有多个构造方法，用什么方式可以区分清楚想要得到其中的哪个方法呢？根据参数的个数和类型，
例如，Class.getMethod(name.Class...args)中的args参数就代表索要获取的那个方法的各个参数的类型的列表。
重点：参数类型用什么方式表示？用Class实例对象。
例如：
int.class，(int []).class
int [] ints = new int[0];
ints.getClass();

代码示例：

class Demo{
    public static void sop(Object obj){System.out.println(obj);}
	public static void main(String[] args) throws Exception {
		String s1 = "1234";
		Class c1 = s1.getClass();
		Class c2 = String.class;
		Class c3 = Class.forName("java.lang.String");
		sop(c1==c2);                    //c1与c2是否是同一个对象true
		sop(c1==c3);                    //c1与c3是否是同一个对象true
		sop(String.class.isPrimitive());//String是否是基本类型false
		sop(int.class.isPrimitive());   //int是否是基本类型true
		sop(int.class==Integer.class);  //int与Integer的字节码是否是同一个对象false
		sop(int.class==Integer.TYPE);   //int与Integer.TYPE的字节码是否是同一个对象true
		sop(int[].class.isPrimitive()); //int[]是否是基本类型false
		sop(int[].class.isArray());     //int[]是否是数组类型true
	}
}

五、成员变量的反射

Field类
Field类代表某个类中的一个成员变量，
Field可以用eclipse自动生成Java类的构造方法
问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？
类只有一个，而该类的实例对象有多个，如果是与对象关联，那么关联的是哪个对象呢？
所以字段fieldX代表的是x的定义，而不是具体的x变量。

代码示例：

Point类的构造函数

public Point(int x,int y)在坐标空间中指定的(x,y)位置构造并初始化一个点。

class Point {
	private int x;
	public int y;
	public String s1="abababab";
	public String s2="aaaabbbb";
	
	public Point(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	public Point(int x, int y, String s1, String s2) {
		super();
		this.x = x;
		this.y = y;
		this.s1 = s1;
		this.s2 = s2;
	}

	//toString()返回此点的字符串表示形式及其在 (x,y) 坐标空间中的位置。
	public String toString(){
		return s1+"---"+s2;
	}
}

下面的这个单独的程序实现对上面这个类的成员变量的反射。

import java.lang.reflect.Field;
class FieldRef{
	public static void main(String[] args) throws Exception{
		//创建一个坐标
		Point point = new Point(5, 8);
		
		//获取字段y的值
		Field fieldY = point.getClass().getField("y");
		
		//获取public修饰的字段
		System.out.println("输出public属性字段"+fieldY.get(point));
		
		//获取字段的值
		Field fieldX = point.getClass().getDeclaredField("x");
		
		//获取类中的类字段
		fieldX.setAccessible(true);
		
		//获取private修饰的字段
		System.out.println("输出private属性字段"+fieldX.get(point));
		
		//调用chang方法
		chang(point);
		System.out.println(point);
	}
	//通过反射改变字段中的字母
	public static void chang(Object obj) throws Exception{
		
		//创建字段数组，获取所有成员字段
		Field[] fields = obj.getClass().getFields();
		for(Field field : fields){
			
			//如果类型为String类型
			if(String.class == field.getType()) {
				String oldValue = (String) field.get(obj);
				
				//获取成员字段值，替换该值
				String newValue = oldValue.replace('a', 'b');
				//设置成员字段的值
				field.set(obj, newValue);
			}
		}
	}
}

六、数组的反射

具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象。
代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用，
非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
Arrays.asList()方法处理int[]和String[]时的差异。
Array工具类用于完成对数组的反射操作。

import java.lang.reflect.Array;
import java.util.Arrays;

class ArrayRef {
	public static void sop(Object obj){System.out.println(obj);}
	public static void main(String[] args){
		//定义几个不同维数的数组
		int[] a1 = new int[]{1,2,3};
		int[] a2 = new int[4];
		int[][] a3 = new int[2][3];
		String[] a4 = new String[]{"1","2","3"};
		
		sop(a1.getClass()==a2.getClass());			//a1与a2的字节码是否相同
		sop(a3.getClass().getName());				//获取a3数组的名字
		sop(a1.getClass().getSuperclass().getName());//a1数组父类的名字
		
		sop("------------------------");
		Object obj1 = a1;
		//Object[] obj2=a1;//两个对象类型不同，不能运算
		Object boj3 = a4;
		Object[] boj4 = a4;
		Object boj5 = a3;
		Object[] boj6 = a3;
		sop("无工具类Arrays的输出："+a1);
		sop("无工具类Arrays的输出："+a4);
		sop("有工具类Arrays的输出："+Arrays.asList(a1));
		sop("有工具类Arrays的输出："+Arrays.asList(a4));
		printObject(a1);	
		printObject(1);
	}
	//打印对象中成员方法
	private static void printObject(Object obj) {
		Class cla = obj.getClass();
		//如果是是一个数组，就打印该数组中所有对象
		if(cla.isArray()){
			int len = Array.getLength(obj);			
			sop("\n调用自定义方法的数组的输出");
			for (int i = 0; i < len; i++) {
				sop(Array.get(obj, i));
			}
		}
		else{
			sop("调用自定义方法的普通对象的输出\n"+obj);
		}
	}
}

七、集合的反射

 

思路:
1、通过文件输出流，创建一个文件Config.properties，
2、获取”className=java.util.ArrayList“的字节码后存入文件中。文件可以手动创建。
3、创建文件输入流和一个属性集，读取指定文件内容，加载到属性集中。
4、用键”className“在属性集中收索。
5、获得新集合，往集合中添加元素。
6、打印集合

代码示例：

import java.io.*;
import java.util.*;

class CollectRef {
	public static void main(String[] args) throws Exception {
		//在当前目录下创建一个文件，并写入指定数据，可以手动创建该文件。
		OutputStream os = new FileOutputStream("Config.properties");
		os.write("className=java.util.ArrayList".getBytes());
		os.close();
		
		//创建文件输入流对象，读取数据
		InputStream is = new FileInputStream("Config.properties");
		//创建属性集
		Properties props = new Properties();
		//加载输入流对象
		props.load(is);                     
		is.close();
		
		//用指定的键在此属性集中搜索属性
		String className = props.getProperty("className");

		//创建此Class对象所表示的类的一个新集合
		Collection cols = (Collection)Class.forName(className).newInstance();
		cols.add("1");
		cols.add("2");
		cols.add("5");
		cols.add("3");
		System.out.println("集合中的元素："+cols);
	}
}

 

 

八、通过反射获得泛型的实际类型参数

 分析：
 比如：Vector<Date> v = new Vector<Date>();
 那么通过v是无法知道定义它的那个泛型类型的，那么可以把这个v交给一个方法当做参数或者返回值类型来使用，
 然后通过Method类的getGenericParameterTypes()方法来获得该方法的参数列表，从而获得参数实际间类型。

代码示例：

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.Date;
import java.util.Vector;

/**
 * 通过反射获得泛型的实际类型参数
 * @author Administrator
 */
public class GenericTest {
	public static void main(String[] args) throws Exception {
		//通过v对象是无法得到的，值能通过方法来获取，那么就要定义一个方法如下面applyVector方法。
		//Vector<Date> v = new Vector<Date>();
		
		//获得字节码，通过字节码获得方法，参数是一个方法名，Vector的字节码
		Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);
		
		//通过Method类的getGenericParameterTypes()方法
		//反射applyMethod方法的参数化类型，可能有多个，所以是数组。
		Type[] types = applyMethod.getGenericParameterTypes();
		
		//返回types的第一个参数，返回的是ParameterizedType类型。
		ParameterizedType pType = (ParameterizedType)types[0];
		
		//获得原始类型
		System.out.println(pType.getRawType());
		
		//获得实际类型。
		System.out.println(pType.getActualTypeArguments()[0]);
	}
	
	//需要定义这个方法，通过这个方法的参数列表来反射他的参数类型。
	public static void applyVector(Vector<Date> v) {
	}
}
/*
结果
class java.util.Vector
class java.sql.Date
*/