黑马程序员——反射

最新推荐文章于 2015-08-29 14:25:13 发布

smliar

最新推荐文章于 2015-08-29 14:25:13 发布

阅读量268

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/smliar/article/details/39612647

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

反射就是把Java类中的各种成分映射成相应的java类。

一、Class类（反射的基石）

import java.util.Date;

public class ReflectPoint {
	private Date birthday = new Date();
	
	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 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;
	}


	@Override
	public String toString(){
		return str1 + ":" + str2 + ":" + str3;
	}


	public int getX() {
		return x;
	}


	public void setX(int x) {
		this.x = x;
	}


	public int getY() {
		return y;
	}


	public void setY(int y) {
		this.y = y;
	}


	public Date getBirthday() {
		return birthday;
	}


	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	
}

1、Class类（反射的基石）

获得指定名字的Class对象： Class<?> forName(String className)

获得注解对象：Annotation[] getAnnotations()

获得类加载器：ClassLoader getClassLoader()

获取构造方法：Constructor<T> getConstructor(Class<?>... parameterTypes)，Constructor<?>[] getConstructors()（获得所有构造方法），Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)（无视权限暴力反射前提），Constructor<?>[] getDeclaredConstructors()（无视权限暴力反射前提）。

获得成员变量：Field getField(String name)，Field[] getFields()（获得所有成员变量），Field getDeclaredField(String name)（无视权限暴力反射前提）， Field[] getDeclaredFields() （无视权限暴力反射前提）。

获得方法： Method getMethod(String name,Class<?>... parameterTypes)，Method[] getMethods()（获得所有方法）， Method getDeclaredMethod(String name, Class<?>... parameterTypes) （无视权限暴力反射前提）， Method[] getDeclaredMethods() （无视权限暴力反射前提）

获得父类：Class<? super T> getSuperclass()

创建实例对象： T newInstance()

加载配置文件：InputStream getResourceAsStream(String name)

2、获取.class字节码

（1）类名.class，例如，System.class，（2）对象.getClass()，例如，new Date().getClass()，（3）Class.forName("类名")，例如，Class.forName("java.util.Date");，（4）九个预定义Class实例对象，（5）数组类型的Class实例对象，Class.isArray()。

3、Field类（代表某个类中的一个成员变量）

（1）通过Class类获取实例对象；（2）获取成员变量的值Object get(Object obj)；（3）设置成员变量的值 set(Object obj，setInt(基本数据类型)(Object obj, int i)

import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Arrays;

public class ReflectTest {

	/**
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		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);
		System.out.println(int[].class.isPrimitive());
		System.out.println(int[].class.isArray());		
		
		//new String(new StringBuffer("abc"));
		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,错！fieldY不是对象身上的变量，而是类上，要用它去取某个对象上对应的值
		System.out.println(fieldY.get(pt1));
		Field fieldX = pt1.getClass().getDeclaredField("x");
		fieldX.setAccessible(true);
		System.out.println(fieldX.get(pt1));	
		
		changeStringValue(pt1);
		System.out.println(pt1);
		
		Method methodCharAt = String.class.getMethod("charAt", int.class);
		System.out.println(methodCharAt.invoke(str1, 1));
		System.out.println(methodCharAt.invoke(str1, new Object[]{2}));
		
		//TestArguments.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"}});
		mainMethod.invoke(null, (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;
		Object[] aObj4 = a3;
		Object[] aObj5 = a4;
		
		System.out.println(a1);
		System.out.println(a4);
		System.out.println(Arrays.asList(a1));
		System.out.println(Arrays.asList(a4));	
		
		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){
			//if(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);
			}
		}
		
	}

}

4、Constructor类（代表某个类中的一个构造方法）

（1）通过Class类获取实例对象，Constructor<T> getConstructor(Class<?>... parameterTypes)；（2）创建实例对象，通过newInstance()方法，通常方式：String str = new String(new StringBuffer("abc"));，反射方式： String str = (String)constructor.newInstance(new StringBuffer("abc"));

5、Method类（代表某个类中的一个成员方法）

（1）通过Class类获取实例对象（2）调用得到的方法，Object invoke(Object obj, Object... args)

6、JavaBean（内省）（成员方法必须有getter和setter方法）

特点：JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。

应用场景：如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。

规则：JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。

PropertyDescriptor类（用于描述JavaBean）：构造方法：PropertyDescriptor(String propertyName, Class<?> beanClass) ；获取get方法（只读）：Method getReadMethod() ；获取set方法（只写）：Method getWriteMethod() 。

内省操作：简单的内省操作：（1）创建javabean对象（2）创建操作javabean类的PropertyDescriptor类的实例对象，并传递要操作的变量名（3）通过getReadMethod() 或getWriteMethod() 方法获取想要得到的方法（4）通过反射操作对方法进行调用等；

复杂的内省操作：（1）创建javabean对象（2）通过Introspector类的静态方法static BeanInfo getBeanInfo(Class<?> beanClass, int flags) 获得javabean的所有属性和公开方法（3）通过BeanInfo的PropertyDescriptor[] getPropertyDescriptors() 方法获得一个PropertyDescripto数组（4）遍历数组，并用getName()方法与需要的属性名进行比较，拿到后通过PropertyDescriptor类获得get或set方法。（5）对拿到的方法进行反射操作，并break结束遍历。