反射机制【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);    //sun.misc.Launcher$AppClassLoader@18b4aac2
            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!

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
THE END
分享
二维码
< <上一篇
下一篇>>