反射机制【Java】

在一些特定的场景中，我们可能会需要获取一些私有的成员变量或方法的信息，但直接在类外调用是无法成功获取到的，因此我们就需要一种机制来获取一些需要的变量或属性，也就是反射机制。

定义

反射属于是java的一种机制，通过这种机制，可以对处于运行状态中的任意一个类获取到它的所有属性或方法，同时可以调用这些属性和方法。这样一种动态获取信息同时动态调用对象方法或属性的功能就是java的反射机制。

代表了类的实体，一般在运行的java应用程序中表示类和接口；

Class类属于是反射机制的起源。原因是对于一个java文件而言，经编译之后就会生成一个.class文件，之后该文件要经过JVM解析，解析得到一个对象java.lang.Class。也就是说，每个java文件最终都会成为Class类对象的一个实例。此时若是我们需要使用或修改这个类的属性或方法，自然就需要使用反射机制来完成，此时这个类也就成为了一个动态的类。

获得Class对象的方式

进行反射的第一步首先是获取当前需要反射的类的类对象，再通过Class对象的方法来实现反射。常见的获取Class对象的方式主要有3种：

• 通过使用类对象的getClass()方法获取；
• 使用.class方法获取；
• 通过使用Class.forName(“类对象的完整路径名”)获取；

下面使用代码来演示具体的使用方法：

package reflect;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 晨曦
 * Date: 2023-05-10
 * Time: 10:25
 */

class Student{
    private String name="liming";

    public int age=20;

    public Student (){
        System.out.println("一个不带参数的构造方法");
    }

    private Student(String name, int age) {
        this.age=age;
        this.name=name;
        System.out.println("name:"+name+"; age:"+age);
    }

    private void study(String name){
        this.name=name;
        System.out.println(name+" i love study");
    }

    public void play(){
        System.out.println("i want to play");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

public class testDemo1 {
    public static void main(String[] args) {
        //1.通过getClass()获取Class对象
        Student student=new Student();
        Class c1=student.getClass();


        //2.直接通过类名.class获取类对象
        Class c2=Student.class;

        Class c3=null;
        try {
        //forName的参数必须是完整的路径名（包名+类名）
            c3=Class.forName("reflect.Student");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);


        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c3.equals(c2));

    }
}

由于一个JVM只会解析出一个Class实例，因此获取的c1,c2,c3三个对象实际都是同一个；

三种获取方式各有千秋，第一种通过getClass获取Class对象的方式需要格外创建一个实例；第二种直接通过 类名.class 的方式更加安全，程序的性能要更高；通过 Class 对象的 forName() 静态方法来获取的方式需要明确类的路径名，使用更加广泛；

反射的具体使用

使用上面的Student类具体演示反射的使用方法，主要就是获取到类中一些私有的方法或属性；

package reflect;

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

public class ReflectTest {

    /*
     * 通过反射创建对象
     * */
    public static void reflectNewInstance() {
      try {
            //1.获取类对象
            Class<?> c=Class.forName("reflect.Student");
            //2.创建类的实例
            Student student=(Student) c.newInstance();
        }  catch (Exception e) {
            e.printStackTrace();
        }

    }

    /*
     * 通过反射调用私有的构造方法
     * */

    public static void reflectPrivateConstructor() {

        try {
            //1.获取类对象
            Class<?> c = Class.forName("reflect.Student");
            //获得该类中与参数类型相匹配的构造方法
           Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class);
            //获得该类的所有公有的构造方法
           /*Constructor<?> constructor=c.getConstructor();*/

            //2.修改访问权限（设置为true）
            constructor.setAccessible(true);
            Student student = (Student) constructor.newInstance("lisi",24);     //调用类中对应的方法  name:lisi; age:24

            ClassLoader classLoader=c.getClassLoader();//获得类的加载器
            System.out.println(classLoader);    //[email protected]
            String str=c.getName();//获得类的完整路径名
            System.out.println(str);        //reflect.Student
        } catch (Exception e) {
            e.printStackTrace();
        }


    }


/*
* 通过反射获取私有属性
* */
    public static void reflectPrivateField(){

        try {
            //1.获取类对象
            Class<?> c = Class.forName("reflect.Student");
            //2.获得某个属性对象
            Field field=c.getDeclaredField("name");
            //3.修改访问权限
            field.setAccessible(true);
            //4.创建类的实例
            Student student=(Student) c.newInstance();
            //5.设置属性值
            field.set(student,"白白");
            //6.获取属性值
            String name=(String) field.get(student);
            System.out.println(name);       //白白
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }



    /*
    * 通过反射调用私有方法
    *
    * */
    public static void reflectPrivateMethod(){
        try {
            //1.获取类对象

            Class<?> c = Class.forName("reflect.Student");
            //2.获取类中的某个方法，第一个参数代表类名，第二个参数代表方法的参数类型
            Method method=c.getDeclaredMethod("study",String.class);
            //3.对于私有的方法，修改权限
            method.setAccessible(true);
            Student student=(Student) c.newInstance();
            //根据参数进行匹配，调用对应的方法
            method.invoke(student,"白白");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) {
        //reflectNewInstance();
        reflectPrivateConstructor();
        //reflectPrivateField();
        //reflectPrivateMethod();
    }
}

几个重要的类及方法

• Class类

• Field类

• Constructor类

• Method类

反射的优缺点

优点：

对于任意一个类，都可以获取或调用类中的属性或方法；
反射机制增加了程序的扩展性，降低了耦合性；

缺点：

使用反射机制会降低程序的效率；
反射机制的代码更加复杂，维护成本高；

over!