java--反射

反射

反射就是把Java类中的各种成分映射成相应的java类。一个类有多个组成部分，例如：成员变量，方法，构造方法等。反射就是加载类，并反射（解剖）出类的各个组成部分。
加载类的三种方式：
　　Class clazz1=Class.forName("类的完整名称");
　　Class clazz2=new Person().getClass();
　　Class clazz3=Person.class;
1，字节码。
　　字节是电脑里的数据量单位 字节码(Byte-code)是一种包含执行程序、由一序列 op 代码/数据对组成的二进制文件。字节码是一种中间码它比机器码更抽象。它经常被看作是包含一个执行程序的二进制文件，更像一个对象模型。字节码被这样叫是因为通常每个 opcode 是一字节长，但是指令码的长度是变化的。
一：Class类代表Java类，它的各个实例对象又分别对应什么呢？
　　①：对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
　　②：一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节  码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？
二：如何得到各个字节码对应的实例对象（ Class类型）
　　①：类名.class，例如，System.class
　　②：对象.getClass()，例如，new Date().getClass()

　　③：Class.forName("类名")，例如，Class.forName("java.util.Date");

public class Test 
{
	public static void main(String args[])throws Exception
	{
		String s="dgdfgfd";
		Class cls1=String.class;
		Class cls2=s.getClass();
		Class cls3=Class.forName("java.lang.String");
		System.out.println(cls1==cls2);
		System.out.println(cls2==cls3);
		
		System.out.println(cls1.isPrimitive());//判定指定的 Class 对象是否表示一个基本类型。
		System.out.println(int.class.isPrimitive());
		System.out.println(int.class == Integer.class);
		System.out.println(int.class == Integer.TYPE);
		System.out.println(int[].class.isPrimitive());
		System.out.println(int[].class.isArray());
	}
}

结果：

true
true
false
true
false
true
false
true
2，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
	{
		String s="dgdfgfd";
		Class cls2=s.getClass();
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);//获取StringBuffer的构造方法
		Constructor[] constructor2= Class.forName("java.lang.String").getConstructors();
		System.out.println(constructor1.toString());
//		for(Constructor c:constructor2)
//			System.out.println(c.toString());	
		String str = (String)constructor1.newInstance(new StringBuffer("abc"));
		System.out.println(str);

	}
}

结果：

public java.lang.String(java.lang.StringBuffer)
abc

3，Field类。
Field类代表某个类中的一个成员变量
得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。

package Test;

import java.lang.reflect.*;
public class Test 
{
	public static void main(String args[])throws Exception
	{
		pe p = new pe(3,5);
		Field fieldY = p.getClass().getField("y");
		//fieldY的值是多少？是5,错！fieldY不是对象身上的 [变量]，而是类上，要用它去取某个对象上对应的值
		System.out.println("filedY="+fieldY.get(p));
		
		Field fieldX = p.getClass().getDeclaredField("x");//x是私有的
		fieldX.setAccessible(true);
		System.out.println("filedX="+fieldX.get(p));	
		
		Field fieldS = p.getClass().getDeclaredField("name");//name不是公有的
		System.out.println("filedS="+fieldS.get(p));
		func(p);
		System.out.println(p.name+"...."+p.email);
	}
	public static void func(Object obj)throws Exception //将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"。
	{
		Field [] fields = obj.getClass().getDeclaredFields();
		for(Field field : fields)
		{
			if(field.getType()==java.lang.String.class)
			{
				field.setAccessible(true);
				String original = (String)field.get(obj);
				field.set(obj,original.replaceAll("b","a"));
			}
		}
	}
}
	
class pe
{
	private int x;
	String name="abc";
	String email="abd";
	public int y;
	
	pe(int x,int y)
	{
		this.x=x;
		this.y=y;
	}
}

filedY=5
filedX=3
filedS=abc
aac....aad

4，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对象对应的是一个静态方法！
jdk1.4和jdk1.5的invoke方法的区别：
　　Jdk1.5：public Object invoke(Object obj,Object... args)
　　Jdk1.4：public Object invoke(Object obj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。
　　例如，Class.getMethod方法用于得到一个方法，该方法要接受什么参数呢？显然要一个方法名，而一个同名的方法有多个重载形式，用什么方式可以区分清楚想得到重载方法系列中的哪个方法呢？根据参数的个数和类型，例如，Class.getMethod(name,Class... args)中的args参数就代表所要获取的那个方法的各个参数的类型的列表。
参数类型用什么来表示啊？用Class对象！

import java.lang.reflect.*;
public class Test 
{
	public static void main(String args[])throws Exception
	{
		String s="abc";
		Method methodCharAt = String.class.getMethod("charAt", int.class);//"charAt"需要的方法名， int.class一个参数的类型。
		System.out.println(methodCharAt.invoke(s, 1));
		System.out.println(methodCharAt.invoke(s, new Object[]{2}));//new Object[]{2}表示，一个任意Object的数组，元素有一个整数类型对象2
	}
}

用反射方法执行某个类中的main方法
　　启动Java程序的main方法的参数是一个字符串数组，即public static void main(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,new String[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
main方法解决办法：
　　①：mainMethod.invoke(null,new Object[]{new String[]{"xxx"}});
　　②：mainMethod.invoke(null,(Object)new String[]{"xxx"});  编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了

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

怎么得到数组中的元素类型？

似乎没有办法直接得到，需要取出每个元素对象，然后再对各个对象进行判断，因为其中每个具体元素的类型都可以不同

import java.lang.reflect.*;
import java.util.Arrays;
public class Test 
{
	public static void main(String args[])throws Exception
	{
		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().getName());
		System.out.println(a1.getClass().isArray());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		
		Object aObj1 = a1;
		Object aObj2 = a4;
		//Object[] aObj3 = a1; 必须是2维数组
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;
		
		System.out.println(a1);
		System.out.println(a4);

		//Arrays.asList()方法处理int[]和String[]时的差异。
		System.out.println(Arrays.asList(a1));//返回一个受指定数组支持的固定大小的Set列表。
		System.out.println(Arrays.asList(a4));	
		
		printObject(a4);
		printObject("xyz");
	}
	public static void printObject(Object obj) 
	{
		Class clazz = obj.getClass();
		if(clazz.isArray())
		{
			int len = Array.getLength(obj);
			for(int i=0;i<len;i++)
			{
				System.out.println(Array.get(obj, i));
			}
		}
		else
		{
			System.out.println(obj);
		}
	}
}

6，反射的作用。
框架与框架要解决的核心问题:
框架与工具类有区别，工具类被用户的类调用，而框架则是调用用户提供的类。
框架要解决的核心问题
我在写框架时，你这个用户可能还在上小学，还不会写程序呢？我写的框架程序怎样能调用到你以后写的类呢？
因为在写才程序时无法知道要被调用的类名，所以，在程序中无法直接new 某个类的实例对象了，而要用反射方式来做。