Java反射

最新推荐文章于 2023-07-20 15:13:23 发布

带你去学习

最新推荐文章于 2023-07-20 15:13:23 发布

阅读量1.3k

点赞数

分类专栏： Java基础文章标签：反射

本文链接：https://blog.csdn.net/zhou870498/article/details/80071156

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

一、类加载器

1.类的加载

当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
①加载
就是指将class文件读入内存，并为之创建一个Class对象。
任何类被使用时系统都会建立一个Class对象
②连接
验证是否有正确的内部结构，并和其他类协调一致
准备负责为类的静态成员分配内存，并设置默认初始化值
解析将类的二进制数据中的符号引用替换为直接引用
③初始化
就是我们以前讲过的初始化步骤

2.类初始化时机

①创建类的实例
②类的静态变量，或者为静态变量赋值
③类的静态方法
④使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
⑤初始化某个类的子类
⑥直接使用java.exe命令来运行某个主类

3.类加载器

负责将.class文件加载到内在中，并为之生成对应的Class对象

4.类加载器的组成

①Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
②Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录
③System ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径。

二、反射

1.概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。定义一个bean对象：

public class Person {
	//成员变量
	public String name;
	public int age;
	private String address;

	//构造方法
	public Person() {
		System.out.println("空参数构造方法");
	}

	public Person(String name) {
		this.name = name;
		System.out.println("带有String的构造方法");
	}
	//私有的构造方法
	private Person(String name, int age){
		this.name = name;
		this.age = age;
		System.out.println("带有String，int的构造方法");
	}

	public Person(String name, int age, String address){
		this.name = name;
		this.age = age;
		this.address = address;
		System.out.println("带有String, int, String的构造方法");
	}


	//成员方法
	//没有返回值没有参数的方法
	public void method1(){
		System.out.println("没有返回值没有参数的方法");
	}
	//没有返回值，有参数的方法
	public void method2(String name){
		System.out.println("没有返回值，有参数的方法 name= "+ name);
	}
	//有返回值，没有参数
	public int method3(){
		System.out.println("有返回值，没有参数的方法");
		return 123;
	}
	//有返回值，有参数的方法
	public String method4(String name){
		System.out.println("有返回值，有参数的方法");
		return "哈哈" + name;
	}
	//私有方法
	private void method5(){
		System.out.println("私有方法");
	}


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

2.获取Class对象的三种方式

①通过Object类中的getObject()方法

	Person p = new Person();
	Class c = p.getClass();

②通过类名.class 获取到字节码文件对象（任意数据类型都具备一个class静态属性）

	Class c2 = Person.class;

③通过Class类中的方法（将类名作为字符串传递给Class类中的静态方法forName）

	Class c3 = Class.forName("com.neusoft.entity.Person");

3.反射的使用

（1）通过反射获取构造方法 Constructor
获取public修饰, 指定参数类型所对应的构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)
获取包含私有的指定参数类型所对应的构造方法
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
获取所有的public 修饰的构造方法
public Constructor<?>[] getConstructors()
获取包含私有的所有的构造方法
public Constructor<?>[] getDeclaredConstructors()

获取构造方法示例：

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
	//获取Class对象
	Class c = Class.forName("com.neusoft.Person");//包名.类名
	
	//获取所有的构造方法
	//Constructor[] cons = c.getConstructors();
	Constructor[] cons = c.getDeclaredConstructors();
	for (Constructor con : cons) {
		System.out.println(con);
	}
	
	System.out.println("------------------------");
	//获取一个构造方法
	//public Person() 
	Constructor con1 = c.getConstructor(null);
	System.out.println(con1);
	
	//public Person(String name)
	Constructor con2 = c.getConstructor(String.class);
	System.out.println(con2);
	
	//private Person(String name, int age)
	Constructor con3 = c.getDeclaredConstructor(String.class, int.class);
	System.out.println(con3);
	
	//public Person(String name, int age, String address)
	Constructor con4 = c.getDeclaredConstructor(String.class, int.class, String.class);
	System.out.println(con4);
}

通过反射方式，获取构造方法，创建对象示例：

	Class c = Class.forName("com.neusoft.entity.Person");
	Constructor con = c.getConstructor(String.class, int.class, String.class);
	Object obj = con.newInstance("小明", 22, "哈尔滨");

通过反射方式，获取私有构造方法，创建对象示例：

	//1,获取到Class对象
	Class c = Class.forName("com.neusoft.entityPerson");
	Constructor con = c.getDeclaredConstructor(String.class, int.class);
	//3,暴力反射 
	con.setAccessible(true);//取消 Java 语言访问检查
	//4,通过构造方法类中的功能，创建对象
	Object obj = con.newInstance("小明", 23);
	System.out.println(obj);

（2）通过反射获取对应的成员变量 Field
获取指定的public修饰的变量
public Field getField(String name)
获取指定的包含私有的任意变量
public Field getDeclaredField(String name)
获取所有public修饰的变量
public Field[] getFields()
获取包含私有的所有变量
public Field[] getDeclaredFields()

获取成员变量示例：

public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException {
		//获取Class对象
		Class c = Class.forName("com.neusoft.entity.Person");
		//获取成员变量
		//多个变量
		//Field[] fields = c.getFields();
		Field[] fields =  c.getDeclaredFields();
		for (Field field : fields) {
			System.out.println(field);
		}
		System.out.println("-----------------");
		//一个变量
		//public int age;
		Field ageField = c.getField("age");
		System.out.println(ageField);
		//private String address
		Field addressField = c.getDeclaredField("address");
		System.out.println(addressField);
	}

通过反射，创建对象，获取指定的成员变量，进行赋值与获取值操作示例：

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
			InvocationTargetException, NoSuchFieldException {
	//1,获取Class对象
	Class c = Class.forName("com.neusoft.entity.Person");
	//2，获取构造方法
	//public Person(String name) 
	Constructor con = c.getConstructor(String.class);
	//3，通过构造方法，创建对象
	Object obj = con.newInstance("小明");
	//4，获取指定的成员变量
	//public String name;
	Field nameField = c.getField("name");
	//public int age;
	Field ageField = c.getField("age");
	//private String address;
	Field addressField = c.getDeclaredField("address");
	addressField.setAccessible(true); //取消 Java 语言访问检查
	//5，通过方法，给指定对象的指定成员变量赋值或者获取值
	System.out.println("name = "+ nameField.get(obj));
	System.out.println("age = "+ ageField.get(obj));
	System.out.println("address = "+ addressField.get(obj));
	//赋值
	ageField.set(obj, 23);
	addressField.set(obj, "凯利广场");
	System.out.println("------------------------");
	System.out.println("name = "+ nameField.get(obj));
	System.out.println("age = "+ ageField.get(obj));
	System.out.println("address = "+ addressField.get(obj));
}

（3）通过反射获取到对应的方法 Method
获取public修饰的方法
public Method getMethod(String name, Class<?>... parameterTypes)
获取包含私有的任意方法
public Method getDeclaredMethod(String name, Class<?>... parameterTypes)
获取本类与父类中所有public 修饰的方法
public Method[] getMethods()
获取本类中包含私有的所有的方法
public Method[] getDeclaredMethods()

获取成员方法示例：

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException {
	//获取Class对象
	Class c = Class.forName("com.neusoft.entity.Person");
	//获取多个方法
	//Method[] methods = c.getMethods();
	Method[] methods = c.getDeclaredMethods();
	for (Method method : methods) {
		System.out.println(method);
	}
	System.out.println("-----------------------");
	//获取一个方法：
	//public void method1()
	Method method = c.getMethod("method1", null);
	System.out.println(method);
	//public String method4(String name){
	method = c.getMethod("method4", String.class);
	System.out.println(method);
	//私有方法
	//private void method5()
	method = c.getDeclaredMethod("method5", null);
	System.out.println(method);
}

通过反射，创建对象，调用指定的方法示例：

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
        InvocationTargetException {
    //1， 获取Class对象
    Class c = Class.forName("com.neusoft.entity.Person");
    //2,获取构造方法
    //public Person(String name, int age, String address){
    Constructor con = c.getConstructor(String.class, int.class, String.class);
    //3，通过构造方法，创建对象
    Object obj = con.newInstance("小明", 23, "哈尔滨");
    //4，获取指定的方法
    //public void method1()  没有返回值没有参数的方法
    //Method m1 = c.getMethod("method1", null);
    //public String method4(String name)
    Method m4 = c.getMethod("method4", String.class);
    //5，执行找到的方法
    //m1.invoke(obj, null);
    Object result = m4.invoke(obj, "itcast");
    System.out.println("result = " + result);
}

通过反射，创建对象，调用指定的private方法示例：

public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException,
        InvocationTargetException {
    //1， 获取Class对象
    Class c = Class.forName("cn.itcast_01_Reflect.Person");
    //2,获取构造方法
    //public Person(String name, int age, String address){
    Constructor con = c.getConstructor(String.class, int.class, String.class);
    //3，通过构造方法，创建对象
    Object obj = con.newInstance("小明", 23, "哈尔滨");
    //4，获取指定的方法
    //private void method5(){
    Method m5 = c.getDeclaredMethod("method5", null);
    //5,开启暴力访问
    m5.setAccessible(true);
    //6，执行找到的方法
    m5.invoke(obj, null);
}