Java中的反射

小太阳T'u'T

于 2020-03-05 20:21:44 发布

阅读量124

点赞数

文章标签： java 反射 jvm class

本文链接：https://blog.csdn.net/lu_qq/article/details/104679147

版权

反射
说起来反射，我们需要明确Java文件和.class文件的关系
笼统的说：java文件通过编译生成.class文件这就是他们之间的关系
细致的说：java文件中含代码的所有内容：成员变量，构造方法，成员方法…编译成对应的
.class文件，我们将编译好的.class文件放进内存的代码区，.class字节码文件所占的内存空间就可以看作一个Class类对象：构造方法Constructor,成员方法Method,成员变量Filed，注解Annotation把以上的四个内容，看作一个Class类对象的属性，提供操作的方法和执行方式。通过反射的方式可以让代码又更好的普适性
.class字节码问题：
.java文件，通过javac编译工具生成对应的.class字节码文件
使用JDK提供的反编译工具，可以看到.class文件中包含
class 完整的包名.类名
Filed 成员变量，成员变量的名字和成员变量的数据类型【如果是引用数据类型，也是完整的包名.类名】
Method 成员方法，方法权限修饰符，返回值类型，方法名，形参列表数据类型（如果是引用数据数据类型，就是完整的包名.类名）
代码区存在一块空间 ==> .class ==> Java程序的所有内容
在这里插入图片描述

反射中的方法

1.Class涉及到的方法
Class Class.forName(String packageNameAndClassName);
Class类的静态成员方法，通过完整的包名.类名获取对应.class文件的Class对象，同事也可以作为.class文件加载的方法。
Class 类名.class；
通过类名.class方法，获取对应.class文件的Class对象，通常用于方法的参数类型。
Class 类对象.getClass();
通过类对象.getClass获得.class文件对应的Class对象，或者说数据类型判断

package com.qfedu.a_reflect;

public class Demo1 {
	public static void main(String[] args) throws ClassNotFoundException {
		Class<?> forName = Class.forName("com.qfedu.a_reflect.Person");
		Class<?> forName1 = Class.forName("com.qfedu.a_reflect.Person");
		  Class<com.qfedu.a_reflect.Person> cls = Person.class;
		  Class<? extends Person> class1 = new Person().getClass();
		  System.out.println(forName == cls);
		  System.out.println(forName == forName1);
		  System.out.println(forName == class1);
		  System.out.println(cls == class1);
		  
	}
}

** 2.Constructor 构造方法类涉及到的方法**
public Constructor[] getConstructors();
当前Class类对象对应的Java文件中所有public修饰的构造方法的数组
public Constructor[] getDeclaredConstructors();
【暴力反射】
当前Class类对象对应的Java文件中所有构造方法的数组，包括私有化的构造方法
public Constructor getConstructor(Class… initArgumentTypes);
根据指定的数据类型，来选择对应的构造方法，这里可能抛出异常NoSuchMethodException
这里有且只能获取获取类内的指定数据类型public修饰构造方法类对象
Class: 约束数据类型，当前方法所需的参数类型
例如:
这里需要int类型 int.class
这里需要String类型 String.class
之类需要Perosn类型 Person.class
… : 不定长参数
构造方法需要的参数类型是很多的，有可能无参数，有可能有参数。… 不定长参数
类约束使用，增强代码的普适性
initArgumentTypes:
参数名初始化参数类型复数
public Constructor getDeclaredConstructor(Class…);
获取当前Class类对象对应的java文件中是指定数据类型的构造方法可以是私有的
【暴力反射】
这里有且只能获取获取类内的指定数据类型public修饰构造方法类对象
Class: 约束数据类型，当前方法所需的参数类型
例如:
这里需要int类型 int.class
这里需要String类型 String.class
之类需要Perosn类型 Person.class
… : 不定长参数
构造方法需要的参数类型是很多的，有可能无参数，有可能有参数。… 不定长参数
类约束使用，增强代码的普适性
initArgumentTypes:
参数名初始化参数类型复数
Object newInstance(Object… initArguments);
通过Constructor对象来调用，传入当前构造方法所需创建对象的初始化参数，创建对象。
Object: Object类是Java中所有类的基类，这里可以传入任意类型的参数
… : 不定长参数，因为Constructor类对象在获取的过程中，约束的参数个数都不确定，
这里使用不定长参数来传入数据

package com.qfedu.a_reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {
		public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
			Class<?> cls = Class.forName("com.qfedu.a_reflect.Person");
			Constructor<?>[] constructors = cls.getConstructors();
			System.out.println("当前Class类对象对应的Java文件中public修饰的构造方法");
			for (Constructor<?> constructor : constructors) {
				System.out.println(constructor);
			}
			Constructor<?>[] declaredConstructors = cls.getDeclaredConstructors();
			System.out.println("当前Class类对象对应的Java文件中所有的构造方法");
			for (Constructor<?> constructor : declaredConstructors) {
				System.out.println(constructor);
			}
			System.out.println("--------------------------------------------------------");
			Constructor<?> constructor = cls.getConstructor();
			Constructor<?> constructor2 = cls.getConstructor(int.class);
			Constructor<?> constructor3 = cls.getConstructor(int.class,String.class);
			//Constructor<?> constructor4 = cls.getConstructor(String.class);
			//System.out.println(constructor4);
			System.out.println(constructor);
			System.out.println(constructor2);
			System.out.println(constructor3);
			Constructor<?> declaredConstructor = cls.getDeclaredConstructor(String.class);
			System.out.println(declaredConstructor);
			Constructor<?> declaredConstructor3 = cls.getDeclaredConstructor(int.class,String.class);
			Constructor<?> declaredConstructor2 = cls.getDeclaredConstructor();
			System.out.println(declaredConstructor2);
			System.out.println("--------------------------------------------------------");
			//Object obj = cls.getConstructor().newInstance();
			declaredConstructor3.setAccessible(true);
			declaredConstructor.setAccessible(true);
//用到的暴力反射都必须事先进行私有化权限的操作
			Object obj1 = declaredConstructor3.newInstance(18,"鲁千旗");
			Object obj = declaredConstructor.newInstance("鲁千旗");
			System.out.println(obj1);
		}
}

Method成员方法涉及到的方法
public Method[] getMethods();
获得Class类对象对应的java文件中public修饰的成员方法组成的数组，包括从父类继承而来的public修饰方法。
public Method[] getDeclaredMethods();
获得Class类对象对应的Java文件中所有的成员方法组成的数组，但是不包括从父类继承而来的方法。
public Method getMethod(String MethodName,Class…parameterTypes);
根据指定方法名和数据类型，获取对应的public修饰的成员方法
methodName:
方法名，指定获取的是哪一个方法
parameterTypes:
Class用于约束当前使用你的参数数据类型
… 不定长参数，方法参数个数，顺序，有参无参问题
例如：
cls是Class类对象
cls.getMethod(“setName”, String.class);
cls.getMethod(“getName”);
public Method getDeclaredMethod(String MethodName,Class…parameterTypes);
根据指定的方法名和数据类型，获取对应的成员方法包括私有的但是不
包括从父类继承而来的方法
methodName:
方法名，指定获取的是哪一个方法
parameterTypes:
Class用于约束当前使用你的参数数据类型
… 不定长参数，方法参数个数，顺序，有参无参问题
例如：
cls是Class类对象
cls.getMethod(“setName”, String.class);
cls.getMethod(“getName”);
Object invoke(Object obj, Object… arguments);
通过Method类对象调用，执行对应的方法，需要的参数
obj :
执行当前方法的执行者
arguments:
Object… 不定长参数，当前方法执行所需的实际参数，

package com.qfedu.a_reflect;

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

public class Demo3 {
		public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
			Class<?> cls = Class.forName("com.qfedu.a_reflect.Person");
			Method[] methods = cls.getMethods();
			for (Method method : methods) {
				System.out.println(method);
			}
			System.out.println("----------------------------------");
			Method[] declaredMethods = cls.getDeclaredMethods();
			for (Method method : declaredMethods) {
				System.out.println(method);
			}
			System.out.println("----------------------------------");
			
			
			Method method = cls.getMethod("game");
			Method method2 = cls.getMethod("game", String.class);
			Object obj = cls.getConstructor().newInstance();
			//引用，获得的方法需要类对象引用
			 method.invoke(obj);
			 method2.invoke(obj, "英雄联盟");
			 Method declaredMethod = cls.getDeclaredMethod("testPrivate");
			 Method declaredMethod2 = cls.getDeclaredMethod("testPrivate", String.class);
			 declaredMethod2.setAccessible(true);
			 declaredMethod.setAccessible(true);
			 declaredMethod2.invoke(obj, "粑粑");
			 declaredMethod.invoke(obj);
			 
		}
}

Field成员变量涉及到方法
public Filed[] getFileds();
获取当前Class对象对应的java文件中，所有public修饰的成员变量数组
public Filed[] getDeclaredFileds();
获取当前Class对象对应的java文件中，所有成员变量数组，包括私有成员变量
public Filed getFiled(String filedName);
获取指定变量名的成员变量对象，要求是public修饰的成员变量
public Filed getDeclaredFiled(String name);
获取指定变量名的成员变量对象，包括private私有化修饰的成员变量
void set(Object obj, Object value);
设置指定调用者中对应成员变量的数据
obj : 调用者
value: 对应当前成员变量需要赋值的内容
Object get(Object obj);
获取指定调用者中指定成员变量的数据
obj: 调用者

package com.qfedu.a_reflect;

import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class Demo4 {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
		Class<?> cls = Class.forName("com.qfedu.a_reflect.Person");
		Constructor<?> declaredConstructor = cls.getDeclaredConstructor(int.class,String.class);
		declaredConstructor.setAccessible(true);
		Object obj = declaredConstructor.newInstance(22,"lqq");
		Field field = cls.getDeclaredField("test");
		Field field1 = cls.getDeclaredField("id");
		Field field2 = cls.getDeclaredField("name");
		field.setAccessible(true);
		field1.setAccessible(true);
		field2.setAccessible(true);
		field.set(obj, 19999);
		System.out.println(obj);
		Object test = field.get(obj);
		Object id = field1.get(obj);
		Object name = field2.get(obj);
		System.out.println(id);
		System.out.println(name);
		System.out.println(test);
		
	}
}

给予暴力反射私有化内容的权限操作

setAccessible(boolean flag);
给予Constructor，Method, Field对象，私有化内容，操作权限设置
true表示可以操作

小太阳T'u'T

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java中的反射

反射说起来反射，我们需要明确Java文件和.class文件的关系笼统的说：java文件通过编译生成.class文件这就是他们之间的关系细致的说：java文件中含代码的所有内容：成员变量，构造方法，成员方法…编译成对应的.class文件，我们将编译好的.class文件放进内存的代码区，.class字节码文件所占的内存空间就可以看作一个Class类对象：构造方法Constructor,成员方法...
复制链接

扫一扫