黑马程序员学习日记--反射

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一：反射的基础

Class类：

Java程序中每个java类都属于同一类事物，描述这类事物的Java类名及时Class。

得到各个字节码对应的实例对象（Class类型）：

类名.class

对象.getClass()

Class.forName("类名")

九个预定义的Class：（isPremitive（））

包含八种基本类型（byte,short,int,long,float,double,char,boolean）的字节码对象和一种返回值为void类型的void.class

二：反射的概念

就是把Java类中的各个成分映射成相应的Java类

Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类中的所有属性和方法。对于任意一个对象，都能够调用它的任意一个方法和属性。这种动态获取的信息，以及动态调用对象的方法的功能成为Java的反射机制。

应用：

应用程序是使用的类不确定时，可以通过配置文件，让使用者将具体的类名存储到配置文件中，然后该程序通过反射技术，对指定的类进行内容的获取。

三：Class类中的方法

static Class forName（String className）

返回给定字符串名的类或接口的相关联的字节码对象

Class getClass（）

返回的是Object运行时的所属类

Constructor getConstructor()

返回的是Constructor对象，它反映此Class对象所表示的类的指定公共构造方法

Field getField(String name)

返回一个Field对象，它表示此Class对象对代表额类或接口的指定公共成员字段

Field getFields( )

返回一个Field对象数组

Method getMothod(String name,Class...parameterTypes)

返回一个Method对象，他表示的是此Class对象所代表的类的指定公共成员方法

Method[] getMethods()

String getName（）

以String形式返回此Class对象所表示的实体名称

Class getSuperclass()

返回此Class所表示的类的超类的实例对象

boolean isArray()

boolean isPrimitive()

T newInstance()

以空构造函数创建实例对象

四：构造方法，成员方法，成员变量的反射

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

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

Field getField（String s）

获取公有或父类中公有指定变量

Field getDeclaredField（String s）

获取该类中任意指定成员变量，包括私有

SetAccessible（true）：暴力访问

set(Object obj,Object value)

Object get(Object obj)

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

Method getMethod("方法名"，参数.class列表)

Method[ ] getMethods()

Method[ ] getDeclaredMethods()

Object.invoke(Object obj,parameter)如果方式静态的，obj为null

五:数组的反射

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

代表数组的class实例对象的getSuperclass（）方法返回的是Object类对应的Class实例对象

Array.getLength(Object obj) 获取数组长度

Array.get(Object obj,int index)  获取数组中元素

练习代码：

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

public class ReflectTest {
	public static void main(String[] args) throws Exception{
		String s = "abc";
		Class cls1 = String.class;
		Class cls2 = s.getClass();
		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(Integer.class.isPrimitive());
		System.out.println(int.class==Integer.TYPE);
		
		System.out.println(int[].class.isPrimitive());
		System.out.println(int[].class.isArray());
		System.out.println(void.class.isPrimitive());
		//new String(new StringBuffer("abc"));
		Constructor const1 = String.class.getConstructor(StringBuffer.class);
		String s1 = (String)const1.newInstance(new StringBuffer("abc"));
		System.out.println(s1.charAt(2));
		
		ReflectPoint rp1 = new ReflectPoint(3,5);
		Field fy = rp1.getClass().getField("y");
		System.out.println(fy.get(rp1));
		Field fx = rp1.getClass().getDeclaredField("x");
		fx.setAccessible(true);
		System.out.println(fx.get(rp1));
		
		changeValue(rp1);
		System.out.println(rp1);
		
		Method mCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(mCharAt.invoke(s,1));
		System.out.println(mCharAt.invoke(s,new Object[]{2}));
		
		//TestArguments.main(new String[]{"111","222","333"});
		Method mainMethod = Class.forName(args[0]).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[3][4];
		String[] a4 = new String[]{"a","c","d"};
		System.out.println(a1.getClass()==a2.getClass());
		System.out.println(a1.getClass().getName());
		System.out.println(a3.getClass().getName());
		System.out.println(a4.getClass().getName());
		System.out.println(a1.getClass().getSuperclass().getName());
		System.out.println(a3.getClass().getSuperclass().getName());
		System.out.println(a4.getClass().getSuperclass().getName());
		
		System.out.println(a1);
		System.out.println(a4);
		
		printObj(Arrays.asList(a1));
		printObj(Arrays.asList(a4));
		printObj("hoop");
		printObj(a1);
		printObj(a4);
		//System.out.println(a1.getClass().isArray());
		//System.out.println(Array.getLength(a1));
		//System.out.println(Array.get(a1,0));
	}
	public static void printObj(Object obj){
		Class objC = obj.getClass();
		if(objC.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);
		}
	}
	public static void changeValue(Object obj) throws Exception{
		Field[] fields = obj.getClass().getFields();
		for(Field field : fields){
			if(field.getType()==String.class){
				String olds =(String)field.get(obj);
				String news = olds.replace('a', 'b');
				field.set(obj,news);
			}
		}
	}
}

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

public class ReflectPoint {
	private int x;
	public int y;
	public String s1 = "ball";
	public String s2 = "basketball";
	public String s3 = "itcast";
	public ReflectPoint(int x, int y) {
		super();
		this.x = x;
		this.y = y;
	}
	@Override
	public String toString()
	{
		return s1+":"+s2+":"+s3;
	}
	@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;
	}
	
}

六：框架

通过反射调用Java类的一种方式

框架和工具类的区别：工具类被用户类调用，框架是调用用户提供的类

练习代码：

import java.io.*;
import java.util.*;
public class ReflectTest_2 {
	public static void main(String[] args) throws Exception{
		InputStream is = new FileInputStream("Config.Properties");
		Properties props = new Properties();
		props.load(is);
		is.close();
		String className = props.getProperty("className");
		Collection coll = (Collection)Class.forName(className).newInstance();
		//Collection coll = new HashSet();
		ReflectPoint pt1 = new ReflectPoint(3,2);
		ReflectPoint pt2 = new ReflectPoint(5,5);
		ReflectPoint pt3 = new ReflectPoint(3,2);
		coll.add(pt1);
		coll.add(pt2);
		coll.add(pt3);
		coll.add(pt1);
		//pt1.y=4;
		//coll.remove(pt1);
		System.out.println(coll.size());
	}
}