Java语言----反射、枚举以及lambda表达式

￡神魔★判官ぃ 2024-04-20 14:25 5阅读 0赞

**目录**

一.反射

1.1反射的基本情况

1.2反射中最重要的类

1.2.1 Class类

1.2.2Field类

1.2.3Constructor类

1.2.4Method类

1.3反射优缺点

二.枚举

2.1概念

2.2枚举（enum）类方法

2.3枚举的构造

三.Lambda表达式

3.1Lambda介绍

3.2 函数式接口

3.3使用lambda表达式

3.2.1不使用Lambda表达式调用

3.2.2使用Lambda表达式

3.2.3二者区别

3.4变量捕获

3.4.1匿名内部类的变量捕获

3.4.2Lambda变量捕获

总结

--------------------

> 😽个人主页：[tq02的博客\_CSDN博客-C语言,Java,Java数据结构领域博主][tq02_CSDN_-C_Java_Java]  
> 🌈梦的目标：努力学习，向Java进发，拼搏一切，让自己的未来不会有遗憾。  
> 🎁欢迎各位→点赞👍 + 收藏⭐ + 评论📝+关注✨  
> 本章讲解内容：反射、枚举以及Lambda表达式  
> ![9efc1f98e3a04f7ba348f9fe24741977.png][]
> 
> 使用编译器：IDEA

## 一.反射 ##

### 1.1反射的基本情况 ###

> 定义：Java在 **运行** 状态时，对于任意一个类，都能知道这个类的**所有属性和方法。**
> 
> 这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制

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

### 1.2反射中最重要的类 ###

<table style="width:700px;"> 
 <tbody> 
  <tr> 
   <td style="width:157px;">类名</td> 
   <td style="width:341px;">&nbsp; &nbsp; &nbsp; &nbsp; 用途</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">class类</td> 
   <td style="width:341px;">代表类的实体，在运行的Java应用程序中表示类和接口</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">Field类</td> 
   <td style="width:341px;">代表类的成员变量、类的属性</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">Method类</td> 
   <td style="width:341px;">代表类的方法</td> 
  </tr> 
  <tr> 
   <td style="width:157px;">Constructor类</td> 
   <td style="width:341px;"> <p>代表类的构造方法</p> </td> 
  </tr> 
 </tbody> 
</table>

在讲解这些类之前，我们需要先构建一个类，方便进行反射的操作：

class Student{
    //私有属性name
        private String name = "tq02";
    //公有属性age
        public int age = 22;
    //不带参数的构造方法
        public Student(){
        System.out.println("Student()");
        }
        private Student(String name,int age) {
        this.name = name;
        this.age = age;
        System.out.println("Student(String,name)");
        }
        
    private void eat(){
        System.out.println("i am eat");
    }
    public void sleep(){
        System.out.println("i am pig");
    }
    private void function(String str) {
        System.out.println(str);
    } 
    
    @Override
    public String toString() {
        return "Student{" +
        "name='" + name + '\'' +
        ", age=" + age +
        '}';
    }
    }

注：1.反射私有的构造方法、属性、方法时，Java具有安全性，因此我们需要使用.setAccessible("boolean");

2.使用Class类、Field、Constructor类时，需要处理异常。

#### 1.2.1 Class类 ####

> 在反射之前，第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有**属性和方法**；对于任意一个对象， 都能够调用它的任意方法和属性，既然能拿到，我们就可以修改部分类型信息。

--------------------

使用Class获取 **类** 的**三种方法**：

第一种：使用Class.forName("类的全路径名“”); //静态方法

第二种：使用.class方法。

第三种：使用类对象的getClass()方法;

注：无论哪种方法获取，其实获取的都是同一个类。

--------------------

代码实例 :

public class TestDemo {
    public static void main(String[] args) {
    //1.通过getClass获取Class对象
        Student s1 = new Student();
        Class c1 = s1.getClass();
    
    //2.直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
    //这说明任何一个类都有一个隐含的静态成员变量 class
        Class c2 = Student.class;
    
    //3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
    //但可能抛出 ClassNotFoundException 异常
        Class c3 = null;
        try {
    //注意这里是类的全路径，如果有包需要加包的路径
        c3 = Class.forName("Student");
        } catch (ClassNotFoundException e) {
        e.printStackTrace();
        } 
    
    //一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的
    //c1,c2,c3进行 equals 比较，发现都是true
    System.out.println(c1.equals(c2));
    System.out.println(c1.equals(c3));
    System.out.println(c2.equals(c3));
    }

#### 1.2.2Field类 ####

作用：可对类中属性进行操作

<table style="width:600px;"> 
 <tbody> 
  <tr> 
   <td style="width:189px;">方法</td> 
   <td style="width:309px;">用途</td> 
  </tr> 
  <tr> 
   <td style="width:189px;">getFiled（String name）</td> 
   <td style="width:309px;">获取某个公有的属性对象</td> 
  </tr> 
  <tr> 
   <td style="width:189px;">getFileds()</td> 
   <td style="width:309px;">获取所有公用的属性对象</td> 
  </tr> 
  <tr> 
   <td style="width:189px;">getDeclaredField(String name)</td> 
   <td style="width:309px;">获取某个属性对象</td> 
  </tr> 
  <tr> 
   <td style="width:189px;">getDeclcareFileds（）</td> 
   <td style="width:309px;">获取所有属性对象</td> 
  </tr> 
 </tbody> 
</table>

public static void reflectPrivateField() {
      try {
                Class<?> classStudent = Class.forName("Student");
                                                         //获取name成员变量
                Field field = classStudent.getDeclaredField("name");
                field.setAccessible(true);
                Student student= (Student)classStudent.newInstance();
    //修改成员变量，将student中的name值改成"小明"；
                field.set(student, "小明");
                String name = (String) field.get(student);
                System.out.println("反射私有属性修改了name：" + name);
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    }

#### 1.2.3Constructor类 ####

作用：对构造方法进行操作

<table> 
 <tbody> 
  <tr> 
   <td style="width:335px;">方法</td> 
   <td style="width:463px;">用途</td> 
  </tr> 
  <tr> 
   <td style="width:335px;">getConstructor(类型.class,类型.class）</td> 
   <td style="width:463px;">获取该类中与参数类型匹配的公有构造方法</td> 
  </tr> 
  <tr> 
   <td style="width:335px;">getConstructors(）</td> 
   <td style="width:463px;">获得该类的所有公有构造方法</td> 
  </tr> 
  <tr> 
   <td style="width:335px;">getDeclaredConstructors(类型.class,类型.class）</td> 
   <td style="width:463px;">获取该类中与参数匹配的构造方法(包含私有构造方法)</td> 
  </tr> 
  <tr> 
   <td style="width:335px;">getDeclaredConstructors（）</td> 
   <td style="width:463px;">获取该类所有的构造方法</td> 
  </tr> 
 </tbody> 
</table>

代码实例：

//反射构造方法
        public static void reflect() {
           try {
               Class<?> c1 = Class.forName("Student");
               Constructor<?> c2= c1.getDeclaredConstructor(String.class,int.class);
               c2.setAccessible(true);
    
               c2.newInstance("汤琦",22);
           }catch(Exception ex)
           {
               ex.printStackTrace();
           }
        }

#### 1.2.4Method类 ####

作用：对类中方法进行操作

<table style="width:650px;"> 
 <tbody> 
  <tr> 
   <td style="width:223px;">方法</td> 
   <td style="width:275px;">用途</td> 
  </tr> 
  <tr> 
   <td style="width:223px;">getMethod("方法名"，类型.class)</td> 
   <td style="width:275px;">使用该类的某个公有的方法</td> 
  </tr> 
  <tr> 
   <td style="width:223px;">getMethods（）</td> 
   <td style="width:275px;">使用该类所有公有的方法</td> 
  </tr> 
  <tr> 
   <td style="width:223px;">getDeclaredMethod("方法名"，类型.class)</td> 
   <td style="width:275px;">使用该类的某个方法</td> 
  </tr> 
  <tr> 
   <td style="width:223px;">getDeclaredMethod()</td> 
   <td style="width:275px;">使用该类所有方法</td> 
  </tr> 
 </tbody> 
</table>

实例代码：

public static void reflectPrivateMethod() {
            try {
                Class<?> c1 = Class.forName("Student");
                Method m1=c1.getDeclaredMethod("function", String.class);
                m1.setAccessible(true);
    
                Student fw=(Student) c1.newInstance();
                m1.invoke(fw,"给私有的function函数传的参数");
    
            }catch(Exception ex)
            {
                ex.printStackTrace();
            }
        }

### 1.3反射优缺点 ###

优点： 1. 对于任意一个类，都能够知道这个类的所有属性和方法；对 于任意一个对象，都能够调用它的任意一个方法  
2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力  
3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点： 1. 使用反射会有效率问题。会导致程序效率降低。具体参考里：[链接][Link 1]  
2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂

--------------------

##  ##

## 二.枚举 ##

### 2.1概念 ###

> 在Java中，可以说是一个集合，从下标0开始的集合。注：枚举是jdk1.5以后引用的。
> 
> 使用格式： public enum 类名\{
> 
> 常量1、常量2、常量3；
> 
> \}
> 
> 就是将class换成了enum

代码实例：

public enum TestEnum {
        RED,BLACK,GREEN,WHITE;//相当于集合，第一个常量下标值为0，第二个常量下标值为1......
        public static void main(String[] args) {
             TestEnum testEnum2 = TestEnum.BLACK;
             switch (testEnum2) {
             case RED: System.out.println("red"); break;
             case BLACK:System.out.println("black");break;
             case WHITE:System.out.println("WHITE");break;
             case GREEN:System.out.println("black");break;
             default:break;
    }
    }

### 2.2枚举（enum）类方法 ###

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td style="width:168px;">方法名</td> 
   <td style="width:330px;">用法</td> 
  </tr> 
  <tr> 
   <td style="width:168px;">values()</td> 
   <td style="width:330px;">以数组形式返回枚举的所有类型</td> 
  </tr> 
  <tr> 
   <td style="width:168px;"> <p>ordinal()</p> </td> 
   <td style="width:330px;">获取该枚举成员的下标值</td> 
  </tr> 
  <tr> 
   <td style="width:168px;">valueOf()</td> 
   <td style="width:330px;">将普通字符串转换成枚举实例</td> 
  </tr> 
  <tr> 
   <td style="width:168px;">compareTo()</td> 
   <td style="width:330px;">比较两个枚举成员定义时的顺序</td> 
  </tr> 
 </tbody> 
</table>

### 2.3枚举的构造 ###

枚举的构造方法默认是私有的。

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;
        }
        public static TestEnum getEnumKey (int key) {
            for (TestEnum t: TestEnum.values()) {
            if(t.key == key) {
            return t;
            }
        } 
        return null;
    }
        public static void main(String[] args) {
            System.out.println(getEnumKey(2));
        }
    }

注：自己写的枚举类，默认继承与enum这个类的。

--------------------

## 三.Lambda表达式 ##

### 3.1Lambda介绍 ###

> Lambda本质是匿名函数，基于数学中的λ演算得名，也可称为**闭包**（Closure）
> 
> 语法格式：（parameters）->expression 或 (parameters)->\{ statements;\}
> 
> **parameters**:类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
> 
> **->**：可理解为“被用于”的意思
> 
> **方法体**：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

常见表达式：

// 1. 不需要参数,返回值为 2
    () -> 2
    // 2. 接收一个参数(数字类型),返回其2倍的值
    x -> 2 * x
    // 3. 接受2个参数(数字),并返回他们的和
    (x, y) -> x + y
    // 4. 接收2个int型整数,返回他们的乘积
    (int x, int y) -> x * y
    // 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
    (String s) -> System.out.print(s)

### 3.2 函数式接口 ###

> 定义：该接口有且只有一个 **抽象方法**
> 
> 注：如果某接口含有**@FunctionalInterface** 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。

代码实例：

@FunctionalInterface
    interface NoParameterNoReturn {
    	//注意：只能有一个方法
    	void test();
    }

### 3.3使用lambda表达式 ###

先建立几个接口：

//无返回值无参数
    @FunctionalInterface
    interface NoParameterNoReturn {
    void test();
    } 
    //无返回值一个参数
    @FunctionalInterface
    interface OneParameterNoReturn {
    void test(int a);
    } 
    //无返回值多个参数
    @FunctionalInterface
    interface MoreParameterNoReturn {
    void test(int a,int b);
    } 
    //有返回值无参数
    @FunctionalInterface
    interface NoParameterReturn {
    int test();
    } 
    //有返回值一个参数
    @FunctionalInterface
    interface OneParameterReturn {
    int test(int a);
    } 
    //有返回值多参数
    @FunctionalInterface
    interface MoreParameterReturn {
    int test(int a,int b);
    }

Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法 。

#### 3.3.1不使用Lambda表达式调用 ####

public class TestDemo {
    public static void main(String[] args) {
    //接口使用匿名内部类
        NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
        @Override
        public void test() {
        System.out.println("hello");
        }
        };
    noParameterNoReturn.test();
    }

#### 3.3.2使用Lambda表达式 ####

public class TestDemo {
      public static void main(String[] args) {
        NoParameterNoReturn noParameterNoReturn = ()->{
        System.out.println("无参数无返回值");
    };
    noParameterNoReturn.test();
        OneParameterNoReturn oneParameterNoReturn = (int a)->{
        System.out.println("一个参数无返回值："+ a);
    };
    oneParameterNoReturn.test(10);
    
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
        System.out.println("多个参数无返回值："+a+" "+b);
    };
    moreParameterNoReturn.test(20,30);
    
        NoParameterReturn noParameterReturn = ()->{
        System.out.println("有返回值无参数！");
        return 40;
    };
    //接收函数的返回值
    int ret = noParameterReturn.test();
    System.out.println(ret);
        OneParameterReturn oneParameterReturn = (int a)->{
        System.out.println("有返回值有一个参数！");
        return a;
    };
    ret = oneParameterReturn.test(50);
    System.out.println(ret);
    
        MoreParameterReturn moreParameterReturn = (int a,int b)->{
        System.out.println("有返回值多个参数！");
        return a+b;
    };
    ret = moreParameterReturn.test(60,70);
    System.out.println(ret);
    }
    }

#### 3.3.3二者区别 ####

代码实例：

![845c6652f2624a6cbf2b44bcf75fb543.png][]

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。  
2. 参数的小括号里面只有一个参数，那么小括号可以省略  
3. 如果方法体当中只有一句代码，那么大括号可以省略  
4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

### 3.4变量捕获 ###

变量捕获，在匿名内部类中也存在，而类似匿名内部类的Lambda表达式，自然而然也存在。

#### 3.4.1匿名内部类的变量捕获 ####

![6ad2f79889ad423f9f502881a48c7923.png][] 如上图，在匿名内部类外，已经定义了a的值，因此匿名内部类直接捕获了外部的a变量。

#### 3.4.2Lambda变量捕获 ####

![037eec811fe34359aaceef3f55ce686c.png][]

如上图，使用直接捕获了外部的a变量。

注：无论是匿名内部类的变量捕获还是Lambda变量捕获，方法体里，不可修改外部变量的值。

--------------------

##  ##

## **总结** ##

反射、枚举以及Lambda表达式很少使用，算是偏僻的知识点，因此不要求掌握，只要求熟悉。

[tq02_CSDN_-C_Java_Java]: https://blog.csdn.net/m0_74097410?type=blog
[9efc1f98e3a04f7ba348f9fe24741977.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/471df7a91abc4a4094918316f3fc0fb8.png
[Link 1]: http://www.imooc.com/article/293679
[845c6652f2624a6cbf2b44bcf75fb543.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/0867114e309544a2b172f2f4200fc6c4.png
[6ad2f79889ad423f9f502881a48c7923.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8395916776e24651a55590519a9d62f4.png
[037eec811fe34359aaceef3f55ce686c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/8431eed1b3a44ff68da21d07b3efd4ad.png