反射：reflection

反射reflection

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制（即通过对象查找类的详细信息）。

反射机制的作用

1.反编译：  .class  ---->>  .java；
2.通过反射机制访问Java对象的属性和方法，构造方法等；

反射机制中的常用类

java.lang.Class;                
java.lang.reflect.Constructor;
java.lang.reflect.Field;        
java.lang.reflect.Method;
java.lang.reflect.Modifier;

通过反射机制获取类的三种方式：

1.通过类名.class的方式得到
2.通过对象.getClass()方法获取
3.通过forName()的方式获取，需要传入完整包.类名称的路径，可能抛出ClassNotFoundException异常

Class<?> class0 = Person.class ;//通过.class的方法取得类的信息

Class<?> class2 = new Person().getClass();//通过.getClass()的方法取得类的信息

Class<?> class1 = null ;
try {
	class1 = Class.forName("study1102.Person");//通过.forName()的方法取得类的信息
} catch (ClassNotFoundException e) {
	e.printStackTrace();
}

反射中的常用方法：

.getInterface() ;取得一个类的所有接口
.getSuperclass() ;取得一个类继承的父类
.getConstructors() ;取得一个类的构造方法
.getMethods() ;取得一个类的全部方法
.getDeclaredFields() ;取得一个类的全部属性

.getModifiers() ; 取的构造方法的修饰符；

注:返回一个int类型的数值，可以使用Modifier类中的toString()方法转换成String类型的访问权限

.newInstance() ; 实例化对象

Demo：

定义一个person类，使用反射中常用方法取得信息

/**
 * 定义一个接口作为练习使用
 * @author SUMMER
 */
interface PersonInterface{
	
}

/**
 * 定义一个人的类作为练习使用
 * @author SUMMER
 */
public class Person implements PersonInterface {
	
	private String name ;//姓名
	
	private int age ;//年龄
	
	public Person() {//无参构造
		
	}
	
	public Person(String name) {//带一个String类型的构造方法
		this.name  = name ;
	}
	
	public Person(String name , int age) {//带二个参数的构造方法
		this.name = name ;
		this.age = age ;
	}

	/**
	 * @return the name
	 */
	public String getName() {
		return name;
	}

	/**
	 * @param name the name to set
	 */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}

	/**
	 * @param age the age to set
	 */
	public void setAge(int age) {
		this.age = age;
	}

	public static void teststatic() {
		System.out.println("Person类中的静态方法");
	}
	/* (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

}

通过反射取得当前类中的接口信息，父类，所有属性，所有方法，并实例化

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

/**
 * 用于取得对象信息
 * @author SUMMER
 */
public class GetReflectionInfo {

	/**
	 * 取得当前类中的所有接口信息
	 */
	public static void getInterfaceInfo() {
		Class<?> classe = Person.class ;//通过.class的方法取得类的信息
		Class<?>[] classes = classe.getInterfaces();
		System.out.println("取得当前类中的所有接口信息："+Arrays.toString(classes));
	}
	
	/**
	 * 取得当前类中的父类信息
	 */
	public static void getSuperclassInfo() {
		Class<?> classe = null ;
		try {
			classe = Class.forName("study1102.Person");//通过.forName()的方法取得类的信息
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		Class<?> classes = classe.getSuperclass();
		System.out.println("取得当前类中的父类信息："+classes);
	}	
	
	/**
	 * 取得当前类中的所有构造方法信息
	 */
	public static void getConstructorsInfo() {
		Class<?> classe = null ;
		classe = new Person().getClass();//通过.getClass()的方法取得类的信息
		Constructor<?>[] constructors = classe.getConstructors();
		System.out.println("取得当前类中的所有构造方法信息："+Arrays.toString(constructors));
		for (Constructor<?> constructor : constructors) {
			System.out.println("----------------------------");
			System.out.println("当前构造方法的方法名："+constructor.getName());
			System.out.println("当前构造方法的访问权限："+Modifier.toString(constructor.getModifiers()));
			//constructor.getModifiers()取得了一个int类型的返回值，则可以调用Modifier中的toString（）将int类型的数值转换成一个String类型的访问权限
			System.out.println("当前构造方法的参数类型"+Arrays.toString(constructor.getParameterTypes()));
		}
	}
	
	/**
	 * 取得当前类中的所有方法信息
	 */
	public static void getMethodsInfo() {
		Class<?> classe = Person.class ;//通过.class的方法取得类的信息
		Method[] methods = classe.getMethods();
		System.out.println("取得当前类中的所有方法信息：");
		for (Method method : methods) {
			System.out.println(method);
		}
	}
	
	/**
	 * 取得当前类中的所有属性信息
	 */
	public static void getDeclaredFieldsInfo() {
		Class<?> classe = Person.class ;//通过.class的方法取得类的信息
		Field[] fields = classe.getDeclaredFields();
		System.out.println("取得当前类中的所有属性信息："+Arrays.toString(fields));
	}
	
	/**
	 * 通过constructor类实例化对象
	 */
	public static void getNewInstance() {
		Person person = null ;
		try {
			person = Person.class.newInstance() ;
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}//通过.class的方法取得类的信息
		person.setName("zhangdandan");
		person.setAge(18);
		System.out.println("通过constructor类实例化对象："+person);
	}
	
	/**
	 * 主方法
	 * @param args
	 */
	public static void main(String[] args) {
		getInterfaceInfo();
		System.out.println("#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*");
		getSuperclassInfo();
		System.out.println("#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*");
		getConstructorsInfo();
		System.out.println("#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*");
		getMethodsInfo();
		System.out.println("#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*");
		getDeclaredFieldsInfo();
		System.out.println("#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*#*");
		getNewInstance();
	}
}

通过反射为对象赋值，修改指定属性内同，调用普通方法，静态方法

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * 使用反射为对象赋值，修改值，调用指定方法
 * @author SUMMER
 */
public class SetterGetterReflection {
	public static void main(String[] args) {
		Class<?> classe = Person.class ;//初始化Person类
		Object object = null ;//定义一个object类型的引用
		
		try {
			
			
			object = classe.newInstance();//实例化一个Person类的对象
			Method method = classe.getMethod("setName", String.class);//取得Person类中的setName()方法
			Method method2 = classe.getMethod("setAge", int.class);//取得Person类中的setAge()方法
			method.invoke(object, "zhangsan");//使用Person类对象调用setName()方法并设置值
			method2.invoke(object, 15);//使用Person类对象调用setAge()方法并设置值
			System.out.println("当前对象内容"+object);//打印当前对象
			
			
			Field field = classe.getDeclaredField("name");//取得Person类中的name属性
			field.setAccessible(true);//设置当前反射的属性在使用时取消 Java 语言访问检查，修改访问权限为public
			field.set(object, "lisi");//为当前属性赋值
			System.out.println("当前对象内容"+object);//打印当前对象
			
			
			Method method3 = classe.getMethod("teststatic");//取得Person类中的静态方法
			method3.invoke(classe);//直接使用初始化完成的Person类对象调用此方法
			//method3.invoke(object);//也可以使用对象调用静态方法，但使用类名调用更加合理
			
			
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (NoSuchFieldException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		
	}
}