黑马程序员--Java编程--反射

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

Java编程--反射

一，反射的基石-Class类

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

对比：众多的人用Person类表示，众多的Java类用Class表示。

Class类代表的Java类，它的各个实例对象分别是什么呢？

1，对应各个类在内存中的字节码，例如Person类的字节码，ArrayList类的字节码，等等。

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

如何得到各个字节码对应的实例对象(Class类型)？

1，类名.class，例如，System.class。

2，对象.getClass()，例如new Date().getClass();

3,Class.forName("类名")，例如，Class.forName("java.util.Date");

数组类型的Class实例对象：Class.IsArray();

总结：只要是在源程序中出现的类型，都有各自的Class实例对象。

二，构造函数对应的类Constructor

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

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

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

得到某一个构造方法：

Constructor constructor = Class.forName("java.lang.String").getConstructor(StinrgBuffer.class);

创建实例对象：

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

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

Class.newInstance()方法：

例：String str = (String) Class.forName("java.lang.String").newInstance();

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

该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例。

三，成员变量对应的类Field

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

示例：

ReflectPoint point = new ReflectPoint(1,7);

Field fieldY = Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");

Field fieldX = Class.forName("cn.itcast.corejava.ReflectPoint").geetDeclareField("x");

四，成员函数对应的类Method

得到类中的一个方法：

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

调用方法：

1，通常方式:System.out.println(str.charAt());

2，反射方式：Sytem.out.println(charAt.invoke(str,1));

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

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

1，jdk1.5:public Object invoke(Object obj, Object...args)

2，jdk1.4:public Object invoke(Object obj, Object[] args),即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用jdk1.4改写为charAt.invoke("str",new Object[]{1})形式。

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

目标：

写一个程序，这个程序能根据用户提供的类名，去执行该类中的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的语法解释，因此会出现参数类型不对的问题。

解决办法：

1，mainMethod.invoke(null,new Object[]{new String [] {"xxx"}});

2，mainMethod.invoke(null,(Object)new String[] {"xxx"});，编译器会作特殊处理，编译时不把参数当做数据看待，也就不会把数组打散成若干个参数了。

六，数组的反射

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

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

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

Arrays.asList()方法处理int[]和String[]时的差异：字符串数组的每个元素都会加入集合中，而int类型数组元素为基本数据类型不能放入集合，所以会吧int[]看做一个整体放入集合，让入的是int数组的地址。

七，ArrayList_HashSet的比较及Hashcode分析

hashCode方法与HashSet类：

八，反射的作用-是实现框架功能

由于在写程序时无法知道要被调用的类名，所以，在程序中无法直接new某个类的实例对象了，而要用反射方式来做。

九，代码实现

以上问题的代码实现：

import java.lang.reflect.*;
import java.util.*;
class ReflectTest 
{
	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);
		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);//TYPE代表包装类型所包装的基本类型。
		System.out.println(int[].class.isPrimitive());//任何类型在内存中都有一份字节码。
		//数组类型的Class实例对象，Class.isArray()判断是否是数组类型类
		//总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[],void
	
		
		//new String(new StringBuffer("adc"));
		Constructor constructor1 = String.class.getConstructor(StringBuffer.class);
		String str2 = (String)constructor1.newInstance(/*"abc"*/new StringBuffer("abc"));
		System.out.println(str2.charAt(2));
	
		ReflectPoint pt1 = new ReflectPoint(3,5);
		Field fieldY = pt1.getClass().getField("y");
		//fieldY的值是多少？是5，错！ field不是对象身上的变量，而是类上的要用它去取某个对象上对应的值。
		System.out.println(fieldY.get(pt1));
		Field fieldX = pt1.getClass().getDeclaredField("x");//getField()对私有的成员变量不可见
		fieldX.setAccessible(true);//暴力获取私有不可用变量
		System.out.println(fieldX.get(pt1));

		changeStringValue(pt1);
		System.out.println(pt1);
		
		
		//str1.charAt(1);
		Method methodCharAt = String.class.getMethod("charAt",int.class);
		System.out.println(methodCharAt.invoke(str1,1));
		//System.out.println(methodCharAt.invoke(null,1));//null，意味着是静态方法。
		System.out.println(methodCharAt.invoke(str1,new Object[]{2}));
	
		//TestArgument.main(new String[]{"111","222","333"});
		String startingClassName = args[0];
		Method mainMethod = Class.forName(startingClassName).getMethod("main",String[].class);
		mainMethod.invoke(null,new Object[]{new String[]{"111","222","333"}});
	
		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;//错，数组里装的是int不是Object
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;

		System.out.println("here");
		System.out.println(a1);
		System.out.println(a4);
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));//int数组和String数组差异。
	
		printObject(a1);
		printObject(a4);
		printObject("xyz");
	}

	private 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);
		}
	}
	private static void changeStringValue(Object obj)throws Exception{
		Field[] fields = obj.getClass().getFields();
		for(Field field : fields){
			//field.getType().equals(String.class)
			if(field.getType() == String.class){
				String oldValue = (String)field.get(obj);
				String newValue = oldValue.replace('b','a');
				field.set(obj,newValue);
			}
		}
	}
}



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

import java.lang.reflect.*;
import java.util.*;
import java.io.*;
class ReflectTest2 
{
	public static void main(String[] args) throws Exception
	{
		InputStream ips = new FileInputStream("config.properties");
		Properties props = new Properties();
		props.load(ips);
		ips.close();//如果不close(),ips对象关联的系统资源未被释放。对象被JVM垃圾回收。
		String className = props.getProperty("className");
		Collection collections2 = (Collection)Class.forName(className).newInstance();//调空参数构造函数
		//编译时java编译器只检测语法，如果没有(Collection)的类型声明会出现类型不兼容的错误。
		Collection collections = new ArrayList();
		//Collection collections2 = 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);
		collections2.add(pt1);
		collections2.add(pt2);
		collections2.add(pt3);
		collections2.add(pt1);

		//pt1.y = 7;//修改了y值就删不掉pt1了，因为计算的pt1的值变了
					//对应的新的哈希值得区域没有pt1，防止内存泄露，以为删除了，但是没有删除，造成内存泄露。
		//collections.remove(pt1);

		System.out.println(collections.size());
		System.out.println(collections2.size());
	}
}

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){
		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 String toString(){
		return str1 + ":" + str2 + ":" + str3;
	}
	@Override
	public boolean equals(Object obj){
		if(this == obj)
			return true;
		if(obj == null)
			return false;
		if(getClass()!= obj.getClass())
			return false;
		final ReflectPoint other = (ReflectPoint) obj;
		if(x != other.x)
			return false;
		if(y !=other.y)
			return false;
		return true;
	}
	
}