Java中的反射机制

最新推荐文章于 2024-09-11 16:58:56 发布

cangerwjd

最新推荐文章于 2024-09-11 16:58:56 发布

阅读量136

点赞数

文章标签： Java

本文链接：https://blog.csdn.net/cangerwjd/article/details/80572695

版权

什么是反射：
反射就是通过获取class字节码文件对象/Class的类对象,获取该字节码文件对象中的成员变量,构造方法,和成员方法

Field: 简称成员变量 (Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。)
Constructor:简称构造方法，提供关于类的单个构造方法的信息以及对它的访问权限。
Method:简称成员方法，类或接口上单独某个方法（以及如何访问该方法）的信息

面试题:
如何获取class字节码文件对象/Class的类对象
三种方式来获取这个class字节码文件对象:
1)Object中的getClass()
2)任何数据类型的静态属性class
3)Class类中的方法:
forName(String className)
forName("类路径")

开发中使用第三种方式,forName方法中的参数是一个String类型,以后可以用字符串类型数据作为配置文件!

public class Person {
	
	private String name ;
	int age ;
	public String address ;
	
	//公共的无参
	public Person() {
	}
	
	//私有的带一个参数的构造方法
	private Person(String name) {
		this.name = name ;
	}
	
	//没有权限修饰符的带两个参数的构造方法
	Person(String name,int age){
		this.name = name ;
		this.age =age ;
	}
	
	//公共的带三个参数的构造方法
	public Person(String name,int age,String address) {
		this.name = name ;
		this.age =age ;
		this.address = address;
	}
	
	//成员方法
	//无参的,没有返回值
	public void show() {
		System.out.println("show Person");
	}
	
	//有参的,没有返回值的
	public void method(String s) {
		System.out.println("method"+s);
	}
	
	//有参的,并且有返回值的
	public String getString(String s,int i) {
		return s+i ;
	}
	
	//私有的
	private void function() {
		System.out.println("function Person");
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", address=" + address + "]";
	}

}

public class ReflectDemo {
	
	public static void main(String[] args) throws ClassNotFoundException {
		
		//如何获取class字节码文件对象
		//创建Person对象
		Person p1 = new Person() ;
		Class c1 = p1.getClass() ;  //获取class字节码文件对象 
		
		Person p2 = new Person();
		Class c2 = p2.getClass() ;
		System.out.println(p1==p2);//false
		System.out.println(c1==c2);//true
		
		System.out.println("------------------");
		
		//数据类型的静态属性class
		Class c3 = Person.class ;
		System.out.println(c3==c2);
		
		//开发中常用使用第三种方式
		//public static Class<?> forName(String className)
		//Class c4 = Class.forName("Person") ;
		//出现异常:java.lang.ClassNotFoundException: Person
		//reflect.Person 
		//参数:类路径:包名.类名
		Class c4 = Class.forName("reflect.Person") ;
		System.out.println(c4==c2);
		
	}
}

通过反射获取构造方法并使用

通过反射实现以下代码：

1)公共的无参构造形式

Person p = new Person() ;

System.out.println(p) ;

public class ReflectDemo {
	
	public static void main(String[] args) throws Exception {
		
		//1)先获取Person类的字节码文件对象
		Class c = Class.forName("reflect.Person") ;
		
		//2)获取构造方法并使用
		//public Constructor<?>[] getConstructors():获取当前字节码文件对象中的所有公共构造方法
		//Constructor[] cons = c.getConstructors() ;
		//for(Constructor con : cons) {
		//	System.out.println(con);
		//}
		/**
		 * public reflect.Person(java.lang.String,int,java.lang.String)
		 * public reflect.Person()
		 */
		//public Constructor<?>[] getDeclaredConstructors():获取当前字节码文件对象中的所有的构造方法
		//Constructor[] cons = c.getDeclaredConstructors() ;
		//for(Constructor con : cons) {
		//	System.out.println(con);
		//}
		/**
		 *  public reflect.Person(java.lang.String,int,java.lang.String)
			reflect.Person(java.lang.String,int)
			private reflect.Person(java.lang.String)
			public reflect.Person()
		 */
		
		//如何获取单个的构造方法
		//public Constructor<T> getConstructor(Class<?>... parameterTypes)
		//如果是无参的,不用写;如果是有参的,getContStructor方法中的参数是当前参数类型的静态属性class
		Constructor con = c.getConstructor() ;
		//public reflect.Person()
		//获取当前构造的对象
		//System.out.println(con);
		//public T newInstance(Object... initargs):initargs:实际参数
		//表示示的构造方法来创建该构造方法的声明类的新实例，并用指定的初始化参数初始化该实例
		Object obj = con.newInstance();
		System.out.println(obj);

	}
}

2)公共的有参构造的形式
Person p = new Person("张三",20,"西安") ;

System.out.println(p) ;

public class ReflectDemo2 {
	
	public static void main(String[] args) throws Exception {
		
		//1)获取Person类的字节码文件对象
		Class c = Class.forName("reflect.Person") ;
		
		//2)获取单个构造方法(公共的,带三个参数的)
		//public Constructor<T> getConstructor(Class<?>... parameterTypes)
		Constructor con = c.getConstructor(String.class,int.class,String.class) ;
		//System.out.println(con);
		
		//3)创建构造方法表示的该类的实例对象
		Object obj = con.newInstance("张三",20,"西安") ;
		System.out.println(obj);
		//Person [name=张三, age=20, address=西安]
		
	}
}

3)私有的有参构造方法

private Person(String name) {

this.name = name ;
}
Person p = new Person("高圆圆") ;
System.out.println(p) ;

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
		//获取字节码文件对象
		Class c = Class.forName("reflect.Person") ; 
		
		//构造方法是私有的
		//public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
		Constructor con = c.getDeclaredConstructor(String.class) ;
		//创建该类的实例,通过con对象创建
		//java.lang.IllegalAccessException: Class reflect.ReflectDemo3 can not access a member of class reflect.Person with modifiers "private"
		//public void setAccessible(boolean flag)
		//值为true则指示反射的对象在使用时取消Java语言访问检查
		con.setAccessible(true);
		Object obj = con.newInstance("张三") ;
		System.out.println(obj);
		//Person [name=张三, age=0, address=null]
	}
}

这里由于构造方法是私有的，因此必须在取消Java语言访问检查后才能实例化，否则会出现java.lang.IllegalAccessException异常。

注意：若不知道构造方法的权限修饰符是什么，推荐直接使用getDeclaredConstructors()方法，并且取消语言访问检查。

通过反射获取成员变量并使用

public class ReflectDemo {

	public static void main(String[] args) throws Exception {
		
		//获取Person类的字节码文件对象
		Class c = Class.forName("reflect.Person");
		
		//获取当前字节码文件对象中的所有的公共的成员变量
		//public Field[] getDeclaredFields():获取当前字节码文件对象中所有的字段
		//Field[] fields = c.getDeclaredFields();
		//public Field[] getFields():获取当前字节码文件对象中所有的公共字段
		//Field[] fields = c.getFields() ;
		
		/*for(Field field:fields) {
			System.out.println(field);
		}*/
		
		/**
		 * 之前要给Person类中的address赋值
		 * Person p =new Person() ;
		 * p.address= "北京" ;
		 */
		//获取构造方法(Constructor)对象
		Constructor con = c.getConstructor() ;
		Object obj = con.newInstance() ;
		//System.out.println(obj);
		
		//获取Field类对象
		//public Field getField(String name):获取的是公共的字段
		//参数name:表示当前字段的名称
		Field addressFiled = c.getField("address") ;
		//public void set(Object obj,Object value)
		//参数1:表示给哪个对象设置当前字段的值
		//参数2:表示给当前获取的那个Field对象的字段设置一个新的值
		addressFiled.set(obj, "北京");
		System.out.println(obj);
		
		System.out.println("-------------------------");
		
		//给name字段赋值
		//java.lang.NoSuchFieldException: name
		//name是私有的,必须指定方法获取
		//public Field getDeclaredField(String name):指定的字段
		Field nameField = c.getDeclaredField("name") ;
		//Field nameField = c.getField("name") ;
		// java.lang.IllegalAccessException: Class reflect.ReflectDemo can not access a member of class reflect.Person with modifiers "private"
		//因为是私有,应该取消Java语言访问检查
		nameField.setAccessible(true);
		nameField.set(obj, "张三");
		System.out.println(obj);
		
		System.out.println("---------------------------");
		
		Field ageField = c.getDeclaredField("age") ;
		ageField.setAccessible(true);
		ageField.set(obj,27);
		System.out.println(obj);
	}
}

通过获取成员方法并使用

public class MethodReflectDemo {

	public static void main(String[] args) throws Exception {

		// 通过反射获取Person字节码文件对象
		Class c = Class.forName("org.westos_01.Person");

		// 获取当前字节码文件对象中的所有的公共的成员方法(包括父类中的)
		// public Method[] getMethods()
		// public Method[] getDeclaredMethods():所有的成员方法
		// Method[] methods = c.getMethods() ;
		/*
		 * Method[] methods = c.getDeclaredMethods() ; 
		 * for(Method method:methods) {
		 * 		System.out.println(method); 
		 * }
		 */
		
		/***
		 * 之前调用Person类中的show() 
		 * Person p = new Person() ; 
		 * p.show() ;
		 */
		// 获取Constructor对象
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();

		// 获取单个的成员方法,Method
		// 调用public void show(){}
		// public Method getMethod(String name, Class<?>... parameterTypes)
		// 参数1: 表示方法名
		// 参数2:表示当前方法的参数数据类型的静态class属性
		Method m1 = c.getMethod("show");
		// public Object invoke(Object obj, Object... args)
		// 参数1:指定的哪个对象上调用底层invoke(),
		// 参数2:表示调用那个方法所传递的实际参数
		m1.invoke(obj); // 在obj对象上调用m1对象所表示的成员方法
		System.out.println("--------------------");
		/**
		 * public void method(String s) { System.out.println("method"+s); }
		 */
		Method m2 = c.getMethod("method", String.class);
		// 调用底层方法
		m2.invoke(obj, "hello");
		System.out.println("-----------------------");
		/**
		 * public String getString(String s,int i) { return s+i ; }
		 */
		Method m3 = c.getMethod("getString", String.class, int.class);
		// 调用Method类中的invoke()方法,调用底层字节码文件对象的对应的成员方法
		Object objgetString = m3.invoke(obj, "javaweb", 100);
		System.out.println(objgetString);
		
		System.out.println("---------------------------");
		/**
		 * //私有的 private void function() { System.out.println("function Preson"); }
		 */
		// public Method getDeclaredMethod(String name , Class<?>... parameterTypes)
		Method m4 = c.getDeclaredMethod("function");
		// 取消Java语言访问检查
		m4.setAccessible(true);
		// 调用obj 对象中的底层的function()方法
		m4.invoke(obj);
	}
}

接下来我们通过一个小例子来感受一下反射应用在配置文件时的好处。

public class Student {
	
	public void love() {
		System.out.println("学生爱生活,爱Java");
	}
}

public class Teacher {

	public void love() {
		System.out.println("老师爱生活,爱讲Java");
	}
}

public class Worker {
	
	public void love() {
		System.out.println("工人爱生活,爱劳动");
	}
}

class文件中的内容：

className=reflect.Student

classMethod=love

public class Test {

	public static void main(String[] args)
			throws IOException, ClassNotFoundException, NoSuchMethodException, SecurityException,
			InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {

		// 反射之前的做法
		// 符合:Java设计元素:开闭原则:对修改关闭,对扩展开放
		/*
		 * Student s = new Student() ; 
		 * s.love(); 
		 * Teacher t = new Teacher() ; 
		 * t.love();
		 * Worker w = new Worker() ; 
		 * w.love();
		 */

		// 反射:可以将类路径作为配置文件

		// 创建属性集合类对象
		Properties prop = new Properties();
		// 需要将class.txt的内容加载到属性集合类中
		Reader r = new FileReader("class.txt");
		prop.load(r);
		r.close();

		// 属性集合类中有数据类
		String className = prop.getProperty("className");
		String classMethod = prop.getProperty("classMethod");

		// 创建Class类对象
		Class c = Class.forName(className);

		// 创建Constructor
		Constructor con = c.getConstructor();
		Object obj = con.newInstance();
		
		//获取Method类对象
		Method m = c.getMethod(classMethod) ;
		
		//调用obj对象中的底层的love()方法
		m.invoke(obj) ;

	}
}

在没有使用反射作为配置文件时，如果需要调用不同类中的love方法，则必须每次都创建一个该类对象，比较麻烦，但将反射作为配置文件后只需要修改class文件中的类路径就可以了，代码不用修改，大大减少了工作量。

需求：有一个ArrayList<Integer>对象，利用反射在这个集合中添加一个字符串数据

public class ArrayListDemo {
	
	public static void main(String[] args) throws Exception{
		
		ArrayList<Integer>  array = new ArrayList<Integer>() ;
		
		//给集合中添加元素
		array.add(100) ;
		//array.add("hello") ;此时如果添加字符串类型的数据，报错！
		
		//获取arrray对象所在的字节码文件对象
		Class c = array.getClass() ;
		
		//可以通过字节码文件对象可以调用底层的add() 
		//先通过Class类的对象获取Method对象
		//公共的有参成员方法 add(Object obj)
		Method m = c.getMethod("add",Object.class) ;
		
		//通过调用array对象中的底层的哪个invoke
		m.invoke(array,"hello") ;
		m.invoke(array,"world") ;
		m.invoke(array,"java") ;
		
		System.out.println(array);
	}
}

需求：写一个方法：public void setProperty(Object obj, String propertyName, Object value){}，此方法可将obj对象中名为propertyName的属性的值设置为value。

public class Tool {
	
	public void setProperty(Object obj, String propertyName, Object value) throws
					NoSuchFieldException, SecurityException,
					IllegalArgumentException, 
					IllegalAccessException{
		
		//作用:就是给对象的字段(成员变量)赋值,value
		//获取当前类的的字节码文件对象
		Class c = obj.getClass() ;
		//如果不知道字段的权限的修饰,用public Field getDeclaredField(String name)
		//已经声明的字段(包括私有...)
		Field field = c.getDeclaredField(propertyName) ;
		//取消Java语言访问检查
		field.setAccessible(true);
		//赋值
		field.set(obj, value);
	}
}

public class ToolDemo {
	
	public static void main(String[] args) throws NoSuchFieldException,
	SecurityException, IllegalArgumentException, 
	IllegalAccessException {
		
		//创建Tool类对象
		Tool t = new Tool() ;
		//现在需要给Person类的name和age赋值
		Person p = new Person() ;
		
		t.setProperty(p, "name", "张三");
		t.setProperty(p, "age", 27);
		System.out.println(p);
		
		System.out.println("--------------");
		
		Dog d = new Dog() ;
		
		t.setProperty(d, "name", "小白");
		t.setProperty(d, "price",800.0);
		System.out.println(d);
	}
}

class Dog{
	private String name ;
	double price;
	@Override
	public String toString() {
		return "Dog [name=" + name + ", price=" + price + "]";
	}
}

class Person{
	private String name ;
	public int age ;
	
	public String toString() {
		return name+"---"+age;
	}
}