Java反射,枚举讲解

2023-12-14 14:42:14

?💕"理想者最可能疯狂。"💕

作者:Mylvzi?

?文章主要内容:Java反射,枚举讲解?

"💕

作者:Mylvzi?

?文章主要内容:数据结构之Map/Set讲解+硬核源码剖析?

一.反射?

1.概念

Java的反射机制(reflection)是指在Java程序在运行状态过程中,能够拿到任意类的任意属性和任意方法,从而能够动态的调用,修改属性方法,这种机制就叫做"反射"

说明:

1.为什么强调"运行状态":在下面会讲到,.java程序经过编译,再到JVM上运行,最终每个.java文件都会生成一个类Class,我们的所有反射操作都是根据生成的Class类完成的

2.拿到任意类的任意属性和方法,包括他的私有属性和私有方法,这看起来和封装冲突了,因为我们之前讲过私有属性和私有方法只能在类内使用,类外无法使用,其实通过反射机制可以实现在类外使用私有属性和私有方法

2.反射用途?

  • 获取私有属性/方法 :在日常的第三方应用开发过程中,经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统 应用开放,这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
  • 开发框架:反射最重要的用途就是开发各种通用框架,比如在spring中,我们将所有的类Bean交给spring容器管理,无 论是XML配置Bean还是注解配置,当我们从容器中获取Bean来依赖注入时,容器会读取配置,而配置中给的 就是类的信息,spring根据这些信息,需要创建那些Bean,spring就动态的创建这些类。

3.反射的相关类(最重要的)

3.1Class类

? Java文件被编译后会生成一个.class文件,这个.class文件会被JVM解析为一个类,这个类就是java.lang.Class,当程序运行时,对应的Java文件就是Class类的一个实例化对象,我们通过反射机制就能动态的调用这个对象的所有属性和方法

3.2?获取class对象的三种方式

1.全路径获取(最常用的方式)

? 通过Class类对象的静态方法forName

Class.forName("反射对象的全路径");

?代码验证:

        Class c1;
        try {
            // forName这个方法会抛出异常 要去解决异常
            c1 = Class.forName("reflectDemo.Student");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        }

?

一定要记得处理异常

2.通过 反射对象.class获取
        // 2.使用.class方法
        Class c2 = Student.class;
3.通过getClass方法

先实例化出一个需要反射类的实例化对象,再通过此对象的getClass方法获取

        // 3.使用getClass方法  需要先实例化一个需要反射的对象
        Student student = new Student();
        Class c3 = student.getClass();

?以上三种方式都能获取到Class对象,那有人发现,我分别定义了三个变量来接受Class对象,分别是c1,c2,c3,那他们三个一定是不同的对象吧?实际上,这三个变量是同一个对象,因为Class对象只有一个,因为一个.java文件对应一个Class对象

        // 都输出true
        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c2.equals(c3));

3.3 创建对象??

创建对象? 即实例化一个反射获得对象,通过newInstance方法使用

newInstance()? ?创建类的实例

    // 创建对象  即实例化反射得到的Class对象
    public static void reflectNewInstance(){
        try {
            // 先获取一个Class对象
            Class<?> c1 = Class.forName("reflectDemo.Student");

            // 此处要进行类型转换
            Student student = (Student) c1.newInstance();
            System.out.println(student);

        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }

    }

?

说明:

  1. newInstance方法的返回值是泛型,需要进行类型转换
  2. ?newInstance方法会抛出异常,需要处理异常

3.4 获得构造方法

? 获取到反射对象的私有构造方法

  • getConstructor(Class... parameterTypes) 获得该类中与参数类型匹配的公有构造方法
  • getConstructors() 获得该类的所有公有构造方法
  • getDeclaredConstructor(Class... parameterTypes) 获得该类中与参数类型匹配的构造方法
  • getDeclaredConstructors() 获得该类所有构造方法
    public static void reflectPrivateConstructor() {
        // 先获取一个Class对象
        try {

            // 1.先获取一个Class对象
            Class<?> c1 = Class.forName("reflectDemo.Student");

            // 2.获取私有的构造方法
            Constructor<Student> con = (Constructor<Student>) c1.getDeclaredConstructor(String.class,int.class);

            // 3.使用私有的构造方法需要添加"保险"
            con.setAccessible(true);

            // 4.创建一个反射的对象
            Student student = con.newInstance("张三",100);

            // 5.打印
            System.out.println(student);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

?

3.5 获取属性Fileld

    public static void reflectPrivateField() {
        try {
            Class c1 = Class.forName("reflectDemo.Student");
            // 使用Field类接受一个私有属性               此处存放你要获取的私有属性的名称
            Field field = c1.getDeclaredField("name");
            // 私有的都需要添加保险
            field.setAccessible(true);
            // 创建一个类的实例
            Student student = (Student) c1.newInstance();
            // 改变私有属性的值
            // 第一个参数是你要修改的对象  第二个参数是你修改的值
            field.set(student,"zhizi");
            System.out.println(student);
            
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

?3.6?获取方法method

    public static void reflectPrivateMethod() {
        try {

            // 1.先创建一个对象
            Class c1 = Class.forName("reflectDemo.Student");

            // 获取私有的方法
            Method method = c1.getDeclaredMethod("function",String.class);
            
            // 私有的都需要添加保险
            method.setAccessible(true);

            // 创建一个类的实例
            Student student = (Student) c1.newInstance();
            
            // 修改方法
            method.invoke(student,"我是修改的私有构造方法");
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InstantiationException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        }
    }

?

注意:方法的修改是通过method.invoke,属性的修改是field.set

4.反射的优点和缺点

优点:

  1. 对于任意一个类,都能获取其所有属性和方法
  2. 增加程序的灵活性,降低耦合性,提高自适应能力
  3. 开发框架

缺点:

  1. 使用反射会降低效率
  2. 反射技术绕过了源代码技术,带来维护相关的问题,同时也增加代码的复杂性

二.枚举

1.背景和定义

枚举是在JDK1.5以后引入的。和之前C语言中学习过的枚举常量类似,都是将一组常量有序组织起来的集合

在这之前定义常量的方式

public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;

使用枚举常量?

    public enum Color{
        Black,Red,Blue;
    }

?

本质:是 java.lang.Enum 的子类,也就是说,自己写的枚举类,就算没有显示的继承 Enum ,但是其默认继承了 这个类。

2.使用

1.switch语句

    public enum Color{
        Black,Red,Blue;
    }

    public static void main(String[] args) {
        Color color = Color.Black;
        switch (color) {
            case Red:
                System.out.println("Red");
                break;
            case Blue:
                System.out.println("Blue");
                break;
            case Black:
                System.out.println("Black");
                break;
            default:
                break;
        }
    }

2.枚举的定义

? 直接将枚举类型定义为一个类

public enum TestEnum {
    RED,BLACK,GREEN,WHITE;
    public static void main(String[] args) {
    //拿到枚举实例BLACK
    TestEnum testEnum = TestEnum.BLACK;
    //拿到枚举实例RED
    TestEnum testEnum21 = TestEnum.RED;
}
}

3、常用方法 Enum 类的常用方法

  • ?values() 以数组形式返回枚举类型的所有成员
  • ordinal() 获取枚举成员的索引位置
  • valueOf() 将普通字符串转换为枚举实例
  • compareTo() 比较两个枚举成员在定义时的顺序
    public enum Color{
        Black,Red,Blue;
    }

    public static void main(String[] args) {

        // 1.values方法  以数组形式返回枚举类型的所有成员
        Color[] colors = Color.values();
        for (Color color : colors) {
            System.out.println(color);
        }

        // 2.ordinal获取枚举成员的索引位置
        int index = Color.Red.ordinal();
        System.out.println(index);// 输出1  索引是从 0开始

        // 3.valueOf 将普通字符串转换为枚举实例
        Color color = Color.valueOf("Red");
        System.out.println(color);// 输出red

        // 4.compareTo
        // 计算:Red.ordinal - Black.ordinal
        System.out.println(Color.Red.compareTo(Color.Black));// 输出1  先定义Black
    }

?

注意:在Java的Enum的源码中,并不包好values方法,但却可以使用,这是为什么呢?

是因为values() 方法是由编译器在编译时自动添加到每个枚举类中的。

这个方法会返回一个包含枚举类型所有值的数组。虽然在 enum 类的源代码中看不到 values() 方法的定义,但编译器在生成字节码时会自动添加这个方法,因此你可以在代码中直接调用 YourEnumType.values() 来获取该枚举类型中所有的枚举常量值。

4.枚举的构造方法(重要)

枚举的构造方法是私有的

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private String name;
    private int key;
/**
* 1、当枚举对象有参数后,需要提供相应的构造函数
* 2、枚举的构造函数默认是私有的 这个一定要记住
* @param name
* @param key
*/
    private TestEnum (String name,int key) {
    this.name = name;
    this.key = key;
}

}

5.枚举的优缺点

优点

  1. 枚举常量跟简单,更安全
  2. 枚举内部有内置方法,代码更优雅??

缺点

  1. 不可继承,无法扩展

6.枚举和反射

? 反射可以拿到任意类的任意属性和任意方法,对于枚举来说,其构造方法是私有的。是否也能通过反射拿到其构造方法呢?

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private String name;
    private int key;
    private TestEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }

    public static void refletct() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        Class c1 = Class.forName("TestEnum");
        Constructor con = c1.getDeclaredConstructor(String.class,int.class);
        con.setAccessible(true);
        // 通过构造类con实例化一个对象
        TestEnum testEnum = (TestEnum) con.newInstance("绿色",666);
        System.out.println(testEnum);
    }
    
    public static void main(String[] args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
        refletct();
    }
}

运行结果:
?java.lang.NoSuchMethodException指没有对应的构造方法

为什么会报这个错误呢?为什么说没有指定的构造方法呢?问题出现在哪里?我们之前说过。所有的枚举类都是继承于java.lang.Enum,既然是继承,肯定继承了除父类构造方法之外的所有的属性和方法,而且子类要先帮助父类进行构造,按理说我们自己写的enum类中应该有类似于super()这样的方法进行父类的构造,而实际上我们并没有写,是违反了继承的规则么?不是的,枚举类比较特殊,虽然我们写的是两个参数,但实际上他还默认添加了两个参数,请看源码:

虽然我们写了两个参数String和int,但实际上他还有两个默认的参数String和int,也就是构造方法中要有四个参数,下面修改一下构造方法

//注意传入对应的参数,获得对应的构造方法来构造对象,当前枚举类是提供了两个参数分别是String和int。
Constructor<?> declaredConstructorStudent =
classStudent.getDeclaredConstructor(String.class,int.class,String.class,int.class)

运行结果:

?此处又出现了类型转换异常,定位到错误代码出,发现报错的代码竟然是

让我们再去看下newInstance的源码

?枚举类在上图画红线部分被过滤了,不能通过反射获取枚举类的实例!!!

文章来源:https://blog.csdn.net/Mylvzi/article/details/134987254
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。