java 反射 Reflect

反射 Reflect

概念

概念：将类的各个组成部分封装为其他对象，这就是反射机制

Java代码在计算机中经历的三个阶段

一、Source源代码阶段

java代码编译成字节码文件

还没进内存，在硬盘上

二、Class类对象阶段

Class类对象：

把类的成员变量封装为 Field[] 对象

把类的构造方法封装为 Constructor[] 对象

把类的成员方法封装为 Method[] 对象

三、Runtime运行时阶段

Person person  =  new Person(); 
	引用				对象

第一阶段->第二阶段：类加载器ClassLoader把字节码文件加载进内存

第二阶段->第三阶段：创建对象

好处

​ 1、可以在程序运行过程中，操作这些对象；

​ 2、可以解耦，提高程序的扩展性。

获取Class对象的方式

三种方式：

第一阶段的方式：

​ Class.forName("全类名"); 将字节码文件加载进内存，返回class对象

第二阶段方式:

​ 类名.class 通过类名的属性class获取对象

第三阶段方式：

​ 对象.getClass(); getClass方法在Object类中定义着

结论：同一字节码文件在一次程序的运行过程中，只会被加载一次，不论通过哪一种方式获取的class对象都是同一个

什么情况用？

第一种：多用于配置文件，将类名定义在配置文件中，读取文件，加载类

第二种：多用于参数的传递

第三种：多用于对象的获取字节码的方式

举例：

package my.reflect;
public class Person {
    private String name;
    private int age;
    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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;
    }
}

package my.reflect;
public class reflect {
   public static void main(String[] args) throws Exception {
        //第一种方法
        Class cls1 = Class.forName("my.reflect.Person");
        System.out.println(cls1);
        //第二种方法
        Class cls2 = Person.class;
        System.out.println(cls2);
        //第三种方法
        Person p =new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);
        
        System.out.println(cls1 == cls2);   //true
        System.out.println(cls1 == cls3);   //true
    }
}

class对象功能

获取功能

一、获取成员变量们

Field[]	getFields()	
Field	getField(String name)
获取所有public修饰的成员变量，其他protected、private等修饰符都不行

Field[]	getDeclaredFields()
Field	getDeclaredField(String name)
获取所有的成员变量，不考虑修饰符
假如成员变量是private，直接获取值会报错，要忽略访问权限修饰符的安全检查

以下其他获取方法同样

package my.reflect;
import java.lang.reflect.Field;
public class demo {
   public static void main(String[] args) throws Exception {
        
        Class personClass = Person.class;

        //获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field:fields){
            System.out.println(field);
        }
        //获取指定成员变量a
        Field a = personClass.getField("a");
        Person p = new Person();
        //获取成员变量a的值
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"我是a");
        System.out.println(p);

        System.out.println("=========================");

        //获取所有的成员变量
   Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField:declaredFields){
            System.out.println(declaredField);
        }
        Field d = personClass.getDeclaredField("d");
        
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);  //暴力反射
        
        Object value2 = d.get(p);
        System.out.println(value2);     
       //直接获取会报错，破坏java封装性，要忽略访问权限修饰符的安全检查

    }
}

获取了能干嘛？

1、设置值

​ void set(Object obj,Object value)

2、获取值

​ get(Object obj) 传对象

3、忽略访问权限修饰符的安全检查

​ setAccessible(true) 暴力反射

二、获取构造方法们

Constructor<?>[]	getConstructors()
Constructor<T>		getConstructor(类<?>... parameterTypes)

Constructor<?>[]	getDeclaredConstructors()
Constructor<T>		getDeclaredConstructor(类<?>... parameterTypes)

package my.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class demo2 {
   public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass = Person.class;

        //获取构造方法
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);

        //创建对象
        Object person = constructor.newInstance("张三", 22);
        System.out.println(person);

        //获取空构造方法并创建对象
    Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);

        Object person1 = constructor1.newInstance();
        //简化创建对象方法，使用类的newInstance方法
        Object o = personClass.newInstance();
        
    }
}

获取了能干嘛？

1、创建对象

​ T newInstance(Obejct... initargs)

​ 如果使用空参数的构造方法创建对象，操作可以简化：可以使用class对象的newInstance方法

三、获取成员方法们

Method[] getMethods()
Method	 getMethod(String name,类<?>... parameterTypes)

Method[] getDeclaredMethods()
Method	 getDeclaredMethod(String name,类<?>... parameterTypes)

package my.reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class demo3 {
   public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass = Person.class;

        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method.invoke(p);

        //获取指定名称和指定参数的方法
        Method eat_method2 = personClass.getMethod("eat",String.class);
        //执行方法
        eat_method2.invoke(p,"嗦粉");

        System.out.println("-----------------");
        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods(); 
        //会获取一些隐藏方法，包括Object以及父类
        for (Method method : methods) {
            System.out.println(method);
            method.getName();   //获取方法名称
        }
    }
}

获取了能干嘛？

1、执行方法

​ Object invoke(Object obj,Object... args)

2、获取方法名称

​ String getName()

四、获取类名

String getName()	//全类名（包名.类名）
String getPackage()