反射

m0_37755380

于 2019-04-02 12:49:52 发布

阅读量90

点赞数

本文链接：https://blog.csdn.net/m0_37755380/article/details/88969277

版权

反射的本质理解:
通过Class对象(指向字节码文件)反向获得对象的各种信息

反射：
       在运行时，我们可以获取任意一个类的所有方法和属性
        在运行时，让我们调用任意一个对象的所有方法和属性

反射的前提：
        要获取类的对象（Class对象）

加载过程：
        JVM将.class文件(字节码文件)读入内存，并同时为之创建一个Class对象

public final class Class<T>extends Objectimplements Serializable, GenericDeclaration, Type, AnnotatedElementClass

类的实例表示正在运行的 Java 应用程序中的类和接口。
枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。
Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

以下示例使用 Class 对象来显示对象的类名：
void printClassName(Object obj) {
System.out.println("The class of " + obj +
" is " + obj.getClass().getName());
}
还可以使用一个类字面值（JLS Section 15.8.2）来获取指定类型（或 void）的 Class 对象。例如：
System.out.println("The name of class Foo is: "+Foo.class.getName());

Class类的实例表示正在运行的 Java 应用程序中的类和接口
也就是jvm中有N多的实例每个类都有该Class对象。（包括基本数据类型）

Class 没有公共构造方法。Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的defineClass 方法自动构造的。
也就是这不需要我们自己去处理创建，JVM已经帮我们创建好了

反射的应用:
1.自定义MyBeanUtils工具类
2.向指定类型的集合中添加不同类型的元素(不知道有什么用)

1.MyBeanUtils工具类

/*
自定义工具类
构造方法私有
成员方法静态
 */
public class MyBeanUtils {
	private MyBeanUtils() {}
	public static void setProperty(Object bean,String name,Object value) throws ReflectiveOperationException {
		//根据Javabean对象获取相应的字节码对象
		Class class1 = bean.getClass();
		//根据字节码对象获取对应的Filed对象
		Field declaredField = class1.getDeclaredField(name);
		//设置权限 使虚拟机不进行访问检查
		declaredField.setAccessible(true);
		//赋值
		declaredField.set(bean, value);
	}
	public static String getProperty(Object bean,String name) throws ReflectiveOperationException {
		//根据Javabean对象获得相应的字节码对象
		Class<Object> class1 = (Class<Object>) bean.getClass();
		//根据字节码对象获得相应的Filed对象
		Field declaredField = class1.getDeclaredField(name);
		//设置权限 避开虚拟机访问检查
		declaredField.setAccessible(true);
		//根据Filed对象获取bean对象的成员变量值
		Object object = declaredField.get(bean);
		//返回
		return object.toString();
	}
	public static void populate(Object bean,Map map) throws ReflectiveOperationException {
		//根据Javabean对象获得相对应的字节码对象
		Class class1 = bean.getClass();
		Set<String> keySet = map.keySet();
		//遍历Map集合
		for(Object obj : keySet){
			//根据字节码对象获得bean的成员变量相应的Filed对象
			Field declaredField = class1.getDeclaredField(obj.toString());
			//设置权限
			declaredField.setAccessible(true);
			//根据Filed对象为bean的成员变量赋值
			declaredField.set(bean,map.get(obj));
		}
	}	
}

public class MyBeanUtilsDemo {
	public static void main(String[] args) throws ReflectiveOperationException  {
		Person p = new Person();
		MyBeanUtils.setProperty(p, "name","The Prince of Tennis");
		System.out.println(p.getName());
		System.out.println(MyBeanUtils.getProperty(p, "name"));
		
		Map<String,Object> map = new HashMap<String,Object>();
		map.put("name", "sz");
		map.put("age", 18);
		map.put("gender", "man");
		MyBeanUtils.populate(p,map);
		System.out.println(p);
	}
}

public class Person implements Serializable {
	
	private static final long serialVersionUID = 1049712678750452511L;
	
	private String name;
	private int age;
	private String gender;
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", gender=" + gender + "]";
	}
}

2.向指定类型的集合中添加不同类型的元素(不知道有什么用)

public class ReflectMethodDemo {
	public static void main(String[] args) throws Exception {
		//向Integer集合添加String元素
		//定义集合
		ArrayList<Integer> arrayList = new ArrayList<>();
		arrayList.add(666);
//		The method add(Integer) in the type ArrayList<Integer> is not applicable for the arguments (String)
//		arrayList.add("sz");
		//根据对象获取字节码对象
		Class class1 = arrayList.getClass();
		//根据字节码对象获得对象方法
		Method myAdd = class1.getDeclaredMethod("add", Object.class);
		//设置权限
		myAdd.setAccessible(true);
		//调用方法
		myAdd.invoke(arrayList, "sz");
		myAdd.invoke(arrayList, 99);
		for(Object obj : arrayList){
			System.out.println(obj.toString());
		}
	}
	private static void tepl() throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		// 用今天讲到的反射技术 向集合中添加一个字符串
		ArrayList<Integer> list = new ArrayList<>();
		// list.add(10);
		// list.add("java");
		Class c = list.getClass();
		Method add = c.getDeclaredMethod("add", Object.class);
		add.setAccessible(true);
		add.invoke(list, "java");
		add.invoke(list, "mysql");
		add.invoke(list, 10);
		System.out.println(list);
	}
}

反射的基础内容

public class ReflectDemo {
	public static void main(String[] args) throws ClassNotFoundException {
		//demo();
		Student s = new Student();
		System.out.println(s);
		System.out.println("---------------");
		System.out.println(s.getClass());
		System.out.println(s.getClass().getName());
		System.out.println("---------------");
		System.out.println(Student.class);
		System.out.println(Student.class.getName());
		System.out.println("---------------");
		printClassName(s);
	}
	private static void demo() throws ClassNotFoundException {
		// 通过Object的getClass()方法获取，必须要有对象
		Student s = new Student();
		Class clazz = s.getClass();

		// 通过类名获取字节码对象(类字面量)
		Class clazz2 = Student.class;

		// static Class<?> forName(String className)
		Class clazz3 = Class.forName("com.itheima_01.Student");

		System.out.println(clazz == clazz2);
		System.out.println(clazz == clazz3);
		System.out.println(clazz);
	}
    public static void printClassName(Object obj) {
        System.out.println("The class of " + obj +
                           " is " + obj.getClass().getName());
    }
}

/*
 *	通过反射获取构造方法并使用
		 Constructor<T> getConstructor(Class<?>... parameterTypes) 
      		返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
      		  
		 Constructor<?>[] getConstructors() 
      		返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法   
	
	T newInstance(Object... initargs) 
	          使用此 Constructor 对象表示的构造方法来创建该构造方法的声明类的新实例
	          并用指定的初始化参数初始化该实例。 
 */
public class ReflectDemo2 {
	public static void main(String[] args) throws ReflectiveOperationException {
		Class clazz = Class.forName("com.itheima_01.Student");
		//m1(clazz);
		//m2(clazz);
//		m3(clazz);
		m4(clazz);
		
	}

	private static void m4(Class clazz)
			throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
		Constructor c = clazz.getDeclaredConstructor(String.class,int.class);
		System.out.println(c);
		c.setAccessible(true);
		Object newInstance = c.newInstance("liwan",14);
		System.out.println(newInstance);
	}

	private static void m3(Class clazz) {
		Constructor[] c = clazz.getDeclaredConstructors();
		for(Constructor con : c){
			System.out.println(con);
		}
	}

	private static void m2(Class clazz)
			throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
		Constructor c = clazz.getConstructor();//无参构造方法
		Object newInstance = c.newInstance();
		System.out.println(newInstance);
	}

	private static void m1(Class clazz) {
		Constructor[] constructors = clazz.getConstructors();
		for(Constructor c : constructors){
			System.out.println(c);
		}
	}

	private static void method3(Class clazz)
			throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
		Constructor c = clazz.getConstructor(String.class,int.class);//获取有参构造，参数1类型为String，参数2类型为int
		System.out.println(c);
		Object obj = c.newInstance("lisi",30);
		System.out.println(obj);
	}

	private static void method2(Class clazz)
			throws NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
		Constructor c = clazz.getConstructor();//获取无参构造
		System.out.println(c);
		Object obj = c.newInstance();
		System.out.println(obj);
	}

	private static void method(Class clazz) {
		//Constructor<?>[] getConstructors() :获取所有public修饰的构造方法 
		Constructor[] cs = clazz.getConstructors();
		for (int i = 0; i < cs.length; i++) {
			System.out.println(cs[i]);
		}
	}
	
}

/*
 * 通过反射获取成员变量并调用:  
 * 
 * 1.批量的
 * 		1).Field[] getFields():获取所有的"公有字段"
 * 		2).Field[] getDeclaredFields():获取所有字段，包括：私有、受保护、默认、公有；
 * 2.获取单个的：
 * 		1).public Field getField(String fieldName):获取某个"公有的"字段；
 * 		2).public Field getDeclaredField(String fieldName):获取某个字段(可以是私有的)
 * 
 * 	 设置字段的值：
 * 		Field --> public void set(Object obj,Object value):
 * 					参数说明：
 * 					1.obj:要设置的字段所在的对象；
 * 					2.value:要为字段设置的值；
 * 
 *  Object get(Object obj) 
          	返回指定对象上此 Field 表示的字段的值 
 */

public class ReflectDemo3 {
	public static void main(String[] args) throws ReflectiveOperationException {
		//获取学生类的字节码对象
		//Class clazz = Class.forName("com.itheima_01.Student");
		Class clazz = Student.class;
		//获取学生类的对象
		Object stu = clazz.newInstance();
		System.out.println(stu);
		
//		//Field getField(String name)  :根据字段名称获取公共的字段对象
		Field f = clazz.getField("age");//获取成员变量对象
		System.out.println(f);
		
		//void set(Object obj, Object value)
		f.set(stu,28);//通过成员变量对象，修改指定对为指定的值
		
		
		//Object get(Object obj)
		Object age = f.get(stu);//通过对象获取成员变量的值
		System.out.println(age);
		
		System.out.println(stu);
		
		
	}
	private static void method(Class clazz) {
		//Field[] getFields()  :获取公共的成员变量
		Field[] fs = clazz.getFields();
		for (int i = 0; i < fs.length; i++) {
			System.out.println(fs[i]);
		}
		System.out.println("----------");
		//getDeclaredFields()  ：获取所有的成员变量
		Field[] fs2 = clazz.getDeclaredFields();
		for (int i = 0; i < fs2.length; i++) {
			System.out.println(fs2[i]);
		}
	}
}

/*
 *	通过反射获取私有成员变量并使用  
 *			 Field[] getDeclaredFields()  
 *			 Field getDeclaredField(String name) 
 */
public class ReflectDemo4 {
	public static void main(String[] args) throws ReflectiveOperationException {
		//获取学生类的字节码对象
		Class clazz = Class.forName("com.itheima_01.Student");
		//获取学生对象
		Object stu = clazz.newInstance();
		//获取私有的字段对象
		Field f = clazz.getDeclaredField("name");
		f.setAccessible(true);//设置反射时取消Java的访问检查,暴力访问
		//System.out.println(f);
		
		f.set(stu, "lisi");
		
		Object name = f.get(stu);
		System.out.println(name);
	}
}

/*
 *	通过反射获取成员方法并使用  
 *		Method getMethod(String name, Class<?>... parameterTypes)  
 *	Method:
 *		Object invoke(Object obj, Object... args)  
 *		
 */

public class ReflectDemo5 {
	public static void main(String[] args) throws ReflectiveOperationException {
		//获取学生类的字节码对象
		Class clazz = Class.forName("com.itheima_01.Student");
		//获取学生类的对象
		Object stu = clazz.newInstance();
		
		//获取无参有返回值的方法
		Method m = clazz.getMethod("getName");
		Object obj = m.invoke(stu);
		System.out.println(obj);
	}

	private static void method2(Class clazz, Object stu)
			throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		//获取有参无返回值的方法
		Method m = clazz.getMethod("setName", String.class);
		m.invoke(stu, "lisi");
		System.out.println(stu);
	}

	private static void method(Class clazz, Object stu)
			throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
		//获取无参无返回值的方法
		Method m = clazz.getMethod("method");
		m.invoke(stu);
	}
}

public class Student {
	private String name;
	public int age;
	public Student() {

	}
	public Student(int age) {
		super();
		this.age = age;
	}
	protected Student(String name) {
		super();
		this.name = name;
	}
	private Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public int getAge() {
		return age;
	}

	public void setAge(String name,int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public void learn(){
		System.out.println("沉迷学习，无法自拔");
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
}