反射、枚举和lambda表达式

àì夳堔傛蜴生んèń 2023-09-27 12:17 129阅读 0赞

![在这里插入图片描述][98207d4093b14229879ef6f7d22c9396.gif_pic_center]

#### 文章目录 ####

*  一、反射
 *   *  反射的相关类
     *  获得Class对象的三种方法
     *  反射的基本使用
     *  反射优点和缺点
 *  二、枚举
 *   *  背景及定义
     *  枚举的使用
     *  为什么Enum源码中找不到values()方法？
     *  枚举与反射
     *  总结
 *  三、Lambda表达式
 *   *  函数式接口
     *  Lambda表达式的基本使用
     *  lambda在集合中的应用
     *  总结

## 一、反射 ##

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任  
意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信  
息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。  
![在这里插入图片描述][0640af6eb170471aa9a35ab4f84fcf4b.png]

### 反射的相关类 ###

.在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统  
应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。

<table> 
 <thead> 
  <tr> 
   <th>类名</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Class类</td> 
   <td>代表类的实体，在运行的java应用程序种表示类和接口</td> 
  </tr> 
  <tr> 
   <td>Field</td> 
   <td>代表类的成员变量</td> 
  </tr> 
  <tr> 
   <td>Method类</td> 
   <td>代表类的方法</td> 
  </tr> 
  <tr> 
   <td>Constructor类</td> 
   <td>代表类的构造方法</td> 
  </tr> 
 </tbody> 
</table>

**反射机制的起源:**  
Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成为一个动态的类

### 获得Class对象的三种方法 ###

这里我们已获取Person为例

class Person {
        
        int age;
        String name;
    
        public Person() {
        
            
        }
        public Person(int age, String name) {
        
            this.age = age;
            this.name = name;
        }
    }

1.使用类对象的getClass()方法

public static void main(String[] args) {
        
            Person person = new Person();
            Class<? > p = person.getClass();
        }

2.通过类名 .class方法

public static void main(String[] args) {
        
            Class<?> p1 = Person.class;
        }

3.使用 Class.forName(“类的全路径名”);  
这里我们需要处理相关的异常

public static void main(String[] args) {
        
            Class<?> p2 = null;
            try {
        
                 p2 = Class.forName("Person");
            } catch (ClassNotFoundException e) {
        
                throw new RuntimeException(e);
            }
        }

我们来验证一下这三种方式获取的类对象

public static void main(String[] args) {
        
            Person person = new Person();
            Class<? > p = person.getClass();
            Class<?> p1 = Person.class;
            Class<?> p2 = null;
            try {
        
                 p2 = Class.forName("Person");
            } catch (ClassNotFoundException e) {
        
                throw new RuntimeException(e);
            }
            System.out.println(p.equals(p1));
            System.out.println(p.equals(p2));
            System.out.println(p1.equals(p2));
        }

![在这里插入图片描述][238b798869c744948b199f435d2a1163.png]

### 反射的基本使用 ###

获得类常用方法

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getClassLoader()</td> 
   <td>获得类的加载器</td> 
  </tr> 
  <tr> 
   <td>getDeclaredClasses()</td> 
   <td>返回一个数组，包含类中所有类和接口的对象</td> 
  </tr> 
  <tr> 
   <td>forName(String className)</td> 
   <td>根据类名返回对象</td> 
  </tr> 
  <tr> 
   <td>newInstance()</td> 
   <td>创建类的实例</td> 
  </tr> 
  <tr> 
   <td>getName</td> 
   <td>获取类的完整路径名字</td> 
  </tr> 
 </tbody> 
</table>

**1.通过反射创建对象**

public static void reflectNewInstance() {
        
            try {
        
                Class<?> personClass = Class.forName("Person");
                Person student = (Person)personClass.newInstance();
                System.out.println(student);
            } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
        
                throw new RuntimeException(e);
            }
        }

![在这里插入图片描述][d369c56d0502498584165db279adaa0b.png]  
我们需要注意newInstance返回的是一个泛型，在编译阶段擦除为Object，所以我们在接受的时候需要强制类型转换  
![在这里插入图片描述][7268c94da92f4d2e840facdb90b9df9a.png]  
**2.通过反射获取构造方法**  
![在这里插入图片描述][8ef71acca95346c3b60621b222bd2052.png]  
我们来获取一下私有的构造方法

public static void reflectConstructor() {
        
            try {
        
                Class<?> personClass = Class.forName("Person");
                Constructor<?> constructor = personClass.getDeclaredConstructor(int.class, String.class);
                Person person = (Person)constructor.newInstance(18, "张三");
                System.out.println(person);
            } catch (ClassNotFoundException e) {
        
                throw new RuntimeException(e);
            } catch (NoSuchMethodException e) {
        
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
        
                throw new RuntimeException(e);
            } catch (InstantiationException e) {
        
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
        
                throw new RuntimeException(e);
            }
        }

![在这里插入图片描述][11f0e361fd7f45f189c3cc018ae82fd7.png]  
我们可以发现系统报错，无法获取私有的，那到底是怎么回事呢？因为我们需要打开一下权限。

public static void reflectConstructor() {
        
            try {
        
                Class<?> personClass = Class.forName("Person");
                Constructor<?> constructor = personClass.getDeclaredConstructor(int.class, String.class);
                constructor.setAccessible(true);//把权限打开
                Person person = (Person)constructor.newInstance(18, "张三");
                System.out.println(person);
            } catch (ClassNotFoundException e) {
        
                throw new RuntimeException(e);
            } catch (NoSuchMethodException e) {
        
                throw new RuntimeException(e);
            } catch (InvocationTargetException e) {
        
                throw new RuntimeException(e);
            } catch (InstantiationException e) {
        
                throw new RuntimeException(e);
            } catch (IllegalAccessException e) {
        
                throw new RuntimeException(e);
            }
        }

![在这里插入图片描述][e591580c320d4fc897b34767d4065258.png]  
![在这里插入图片描述][d6df6b4fc6424ed7b3203f7e81973564.png]  
**3.通过反射获取相关属性**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>用途</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>getField(String name)</td> 
   <td>获得某个公有的属性对象</td> 
  </tr> 
  <tr> 
   <td>getFields()</td> 
   <td>获得所有公有的属性对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredField(String name)</td> 
   <td>获得某个属性对象</td> 
  </tr> 
  <tr> 
   <td>getDeclaredFields()</td> 
   <td>获得所有属性对象</td> 
  </tr> 
 </tbody> 
</table>

public static void reflectField() {
        
            try {
        
                Class<?> personClass = Class.forName("Person");
                Field field = personClass.getDeclaredField("name");
                field.setAccessible(true);
                Person person = (Person)personClass.newInstance();
                field.set(person,"张三");
                System.out.println(person);
            } 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);
            }
        }

![在这里插入图片描述][b789d24a492049f8b161762fc35451b7.png]  
**3.通过反射获取相关方法**

private void print(String s) {
        
            System.out.println(s);
        }

这里以获取这个私有方法为例

public static void reflectMethod() {
        
            try {
        
                Class<?> personClass = Class.forName("Person");
                Method print = personClass.getDeclaredMethod("print",String.class);
                print.setAccessible(true);
                Person person = (Person)personClass.newInstance();
                print.invoke(person,"反射测试方式成功！");
            } 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);
            }
        }

![在这里插入图片描述][0a84e074c2ee44119b0eb3df2b208a38.png]

### 反射优点和缺点 ###

**优点：**

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

**缺点：**

1.  使用反射会有效率问题。会导致程序效率降低。
2.  反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

## 二、枚举 ##

### 背景及定义 ###

我们创建一个Color枚举类型

public enum ColorEnum {
        
        BLACK,YELLOW,GREEN;
    }

优点：将常量组织起来统一进行管理  
场景：错误状态码，消息类型，颜色的划分，状态机等等…  
本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了这个类。

### 枚举的使用 ###

1.switch语句

enum ColorEnum {
        
        BLACK,YELLOW,GREEN;
    }
    public class Test {
        
        public static void main(String[] args) {
        
            ColorEnum colorEnum = ColorEnum.YELLOW;
            switch (colorEnum) {
        
                case BLACK:
                    System.out.println("BLACK");
                    break;
                case YELLOW:
                    System.out.println("YELLOW");
                    break;
                case GREEN:
                    System.out.println("GREEN");
                    break;
                default:
                    break;
            }
        }
    }

![在这里插入图片描述][c26790315baa41e4adc984bbfd560164.png]  
2.常用方法  
**values() 以数组形式返回枚举所有成员**

public static void main(String[] args) {
        
            ColorEnum[] colorEnums = ColorEnum.values();
            for (int i = 0; i < colorEnums.length; i++) {
        
                System.out.println(colorEnums[i]);
            }
        }

![在这里插入图片描述][adba5dacb6da4f6a958c4bc90fc202de.png]  
**ordinal()获取枚举成员的索引位置**

public static void main(String[] args) {
        
            ColorEnum[] colorEnums = ColorEnum.values();
            for (int i = 0; i < colorEnums.length; i++) {
        
                System.out.println(colorEnums[i].ordinal());
            }
        }

![在这里插入图片描述][63b07404b2024c88915d5adb984f4eb1.png]  
**valueOf()将普通字符串转换为枚举实例**

public static void main(String[] args) {
        
            ColorEnum colorEnum = ColorEnum.valueOf("BLACK");
            System.out.println(colorEnum);
        }

![在这里插入图片描述][21e19cbc9a9743afb34b394dab8326cd.png]  
只能转换枚举类型种已经定义的

public static void main(String[] args) {
        
            ColorEnum colorEnum = ColorEnum.valueOf("RED");
            System.out.println(colorEnum);
        }

![在这里插入图片描述][b10a983100f84befba7db8d265a8cb08.png]

**compareTo() 比较两个枚举成员在定义时的顺序**

public static void main(String[] args) {
        
            System.out.println(ColorEnum.GREEN.compareTo(ColorEnum.YELLOW));
            System.out.println(ColorEnum.BLACK.compareTo(ColorEnum.YELLOW));
        }

![在这里插入图片描述][219790a5566d48629910d2f247ef4737.png]

### 为什么Enum源码中找不到values()方法？ ###

![在这里插入图片描述][6c6787851d9d4915988ec2e54f90d608.png]  
Enum类和enum关键字定义的类型都有values方法，但是点进去会发现找不到这个方法。这是因为java编译器在编译这个类（enum关键字定义的类默认继承java.lang.Enum）的时候自动插入了一条static的方法values。在官方文档中有说明。  
文档地址：[官方文档][Link 1]

### 枚举与反射 ###

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

enum ColorEnum {
        
        BLACK(0,"black"),YELLOW(1,"yellow"),GREEN(2,"green");
        private int id;
        private String color;
    
        private ColorEnum(int id, String color) {
        
            this.id = id;
            this.color = color;
        }
    }

在枚举中调用  
![在这里插入图片描述][8894c301bfcd45edb165d6901ab32afb.png]  
为什么我们通过反射调用枚举的构造方法时会报java.lang.IllegalArgumentException: 异常呢？  
![在这里插入图片描述][1344f94f2b31481b98d372cd10dd0f36.png]  
我们在源码中可以发现枚举在这里被过滤了，你不能通过反射获取枚举类的实例。  
这里证明: **枚举实现单例模式是安全的**

### 总结 ###

1、枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承与 java.lang.Enum  
2、枚举可以避免反射和序列化问题  
3、枚举实现单例模式是安全的  
**优点：**

1.  枚举常量更简单安全 。
2.  枚举具有内置方法 ，代码更优雅

**缺点：**

1.  不可继承，无法扩展

## 三、Lambda表达式 ##

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure） 。  
先了解一下什么是函数式接口？

### 函数式接口 ###

要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法 。  
注意：

1.  如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
2.  如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接  
    口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只  
    有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。  
    ![在这里插入图片描述][2a38dcbda569455a8d43b32787b530e0.png]  
    我们以优先级队列为例，传入的比较器，我们可以发现这个接口上面有@FunctionalInterface关键字，证明它就是一个函数式接口，我们在传入参数的时候就可以使用lambda表达式。

### Lambda表达式的基本使用 ###

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

在这里我们自定义几个函数式接口。  
**1.无参数无返回值**

@FunctionalInterface
    interface LambdaTest {
        
         void func();
    }
        public static void main(String[] args) {
        
            LambdaTest lambda = new LambdaTest() {
        
                @Override
                public void func() {
        
                    System.out.println("lambda测试");
                }
            };
            lambda.func();
        }

这里我们使用匿名内部类  
![在这里插入图片描述][74abd2d9b75743579de00658c879c536.png]

public static void main(String[] args) {
        
            LambdaTest lambdaTest = (() -> System.out.println("lambda测试"));
            lambdaTest.func();
        }

![在这里插入图片描述][71b0f95f28994f0e9bd4acf0b70cb961.png]  
**2.有参数无返回值**

@FunctionalInterface
    interface LambdaTest {
        
        void func(String s);
    }
        public static void main(String[] args) {
        
            LambdaTest lambda = new LambdaTest() {
        
                @Override
                public void func(String s) {
        
                    System.out.println("lambda测试" + s);
                }
            };
           lambda.func("匿名内部类");
        }

![在这里插入图片描述][3ce0ff9eee2c407c8ac6eb8287f538c3.png]

public static void main(String[] args) {
        
            LambdaTest lambda = s -> System.out.println("lambda测试" + s);
            lambda.func("lambda测试");
        }

![在这里插入图片描述][5d38042b294047d1843a5b46db1cbb89.png]  
参数只有一个时，可以去掉括号。  
**3.没有参数有返回值**

@FunctionalInterface
    interface LambdaTest {
        
        int func();
    }
        public static void main(String[] args) {
        
            LambdaTest lambdaTest = new LambdaTest() {
        
                @Override
                public int func() {
        
                    return 1;
                }
            };
            System.out.println(lambdaTest.func());
        }

![在这里插入图片描述][88f89fbbe17b43d08ec1ae4e50e1b0dd.png]

interface LambdaTest {
        
        int func();
    }
    public class Test {
        
        public static void main(String[] args) {
        
            LambdaTest lambdaTest = () -> 1;
            System.out.println(lambdaTest.func());
        }

![在这里插入图片描述][4627edc953b64056821b1e19efe8d1d3.png]

**4.有参数有返回值**

@FunctionalInterface
    interface LambdaTest {
        
        int func(int a,int b);
    }
        public static void main(String[] args) {
        
            LambdaTest lambdaTest = new LambdaTest() {
        
                @Override
                public int func(int a, int b) {
        
                    return a + b;
                }
            };
            System.out.println(lambdaTest.func(1, 2));
        }

![在这里插入图片描述][cc9caa97b8e24513884b6c887da72ed8.png]

public static void main(String[] args) {
        
            LambdaTest lambdaTest = (a,b) -> a+b;
            System.out.println(lambdaTest.func(1, 2));
        }

![在这里插入图片描述][a2cb4007b110417f98cc34e0f1c4194d.png]

### lambda在集合中的应用 ###

**1.forEach() 方法演示**  
![在这里插入图片描述][fa67248e69e44bd9840e0346ff6badeb.png]  
我们来看一下forEach的参数  
![在这里插入图片描述][c1f50ac78aea4fd4b16f237b0e1cb050.png]  
我们发现是一个函数式接口，所以我们可以使用lambda表达式

public static void main(String[] args) {
        
            Set<Integer> set = new HashSet<>();
            set.add(1);
            set.add(2);
            set.add(3);
            set.add(4);
            set.forEach(new Consumer<Integer>() {
        
                @Override
                public void accept(Integer integer) {
        
                    System.out.print(integer + " ");
                }
            });
        }

lambda表达式:

public static void main(String[] args) {
        
            Set<Integer> set = new HashSet<>();
            set.add(1);
            set.add(2);
            set.add(3);
            set.add(4);
            set.forEach(integer -> System.out.print(integer + " "));
        }

![在这里插入图片描述][9e9802bc9b024f2d81deb2e389bb1b04.png]  
**2.HashMap 的 forEach()**  
匿名内部类:

public static void main(String[] args) {
        
            HashMap<String,Integer> hashMap = new HashMap<>();
            hashMap.put("aaa",1);
            hashMap.put("bbb",2);
            hashMap.put("ccc",3);
            hashMap.forEach(new BiConsumer<String, Integer>() {
        
                @Override
                public void accept(String s, Integer integer) {
        
                    System.out.println(s + " -> " + integer );
                }
            });
        }

lambda表达式:

![在这里插入图片描述][b7832becf3134edf8be9d23d1401e14b.png]  
**3.sort() 方法演示**  
![在这里插入图片描述][b69adce366c54122922284c6a4c02a1e.png]  
我们发现这里是一个函数式接口

public static void main(String[] args) {
        
            ArrayList<Integer> arrayList = new ArrayList<>();
            arrayList.add(3);
            arrayList.add(1);
            arrayList.add(2);
            arrayList.sort(new Comparator<Integer>() {
        
                @Override
                public int compare(Integer o1, Integer o2) {
        
                    return o1 - o2;
                }
            });
        }

lambda表达式:

public static void main(String[] args) {
        
            ArrayList<Integer> arrayList = new ArrayList<>();
            arrayList.add(3);
            arrayList.add(1);
            arrayList.add(2);
            arrayList.sort((o1,o2) -> o1 - o2);
            for (Integer integer : arrayList) {
        
                System.out.print(integer + " ");
            }
        }

![在这里插入图片描述][545283c0e6f4427b9bdb02003ef16572.png]

### 总结 ###

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。  
**优点：**

1.  代码简洁，开发迅速
2.  方便函数式编程
3.  非常容易进行并行计算
4.  Java 引入 Lambda，改善了集合操作

**缺点：**

1.  代码可读性变差
2.  在非并行计算中，很多计算未必有传统的 for 性能要高
3.  不容易进行调试

[98207d4093b14229879ef6f7d22c9396.gif_pic_center]: https://img-blog.csdnimg.cn/98207d4093b14229879ef6f7d22c9396.gif#pic_center
[0640af6eb170471aa9a35ab4f84fcf4b.png]: https://img-blog.csdnimg.cn/0640af6eb170471aa9a35ab4f84fcf4b.png
[238b798869c744948b199f435d2a1163.png]: https://img-blog.csdnimg.cn/238b798869c744948b199f435d2a1163.png
[d369c56d0502498584165db279adaa0b.png]: https://img-blog.csdnimg.cn/d369c56d0502498584165db279adaa0b.png
[7268c94da92f4d2e840facdb90b9df9a.png]: https://img-blog.csdnimg.cn/7268c94da92f4d2e840facdb90b9df9a.png
[8ef71acca95346c3b60621b222bd2052.png]: https://img-blog.csdnimg.cn/8ef71acca95346c3b60621b222bd2052.png
[11f0e361fd7f45f189c3cc018ae82fd7.png]: https://img-blog.csdnimg.cn/11f0e361fd7f45f189c3cc018ae82fd7.png
[e591580c320d4fc897b34767d4065258.png]: https://img-blog.csdnimg.cn/e591580c320d4fc897b34767d4065258.png
[d6df6b4fc6424ed7b3203f7e81973564.png]: https://img-blog.csdnimg.cn/d6df6b4fc6424ed7b3203f7e81973564.png
[b789d24a492049f8b161762fc35451b7.png]: https://img-blog.csdnimg.cn/b789d24a492049f8b161762fc35451b7.png
[0a84e074c2ee44119b0eb3df2b208a38.png]: https://img-blog.csdnimg.cn/0a84e074c2ee44119b0eb3df2b208a38.png
[c26790315baa41e4adc984bbfd560164.png]: https://img-blog.csdnimg.cn/c26790315baa41e4adc984bbfd560164.png
[adba5dacb6da4f6a958c4bc90fc202de.png]: https://img-blog.csdnimg.cn/adba5dacb6da4f6a958c4bc90fc202de.png
[63b07404b2024c88915d5adb984f4eb1.png]: https://img-blog.csdnimg.cn/63b07404b2024c88915d5adb984f4eb1.png
[21e19cbc9a9743afb34b394dab8326cd.png]: https://img-blog.csdnimg.cn/21e19cbc9a9743afb34b394dab8326cd.png
[b10a983100f84befba7db8d265a8cb08.png]: https://img-blog.csdnimg.cn/b10a983100f84befba7db8d265a8cb08.png
[219790a5566d48629910d2f247ef4737.png]: https://img-blog.csdnimg.cn/219790a5566d48629910d2f247ef4737.png
[6c6787851d9d4915988ec2e54f90d608.png]: https://img-blog.csdnimg.cn/6c6787851d9d4915988ec2e54f90d608.png
[Link 1]: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
[8894c301bfcd45edb165d6901ab32afb.png]: https://img-blog.csdnimg.cn/8894c301bfcd45edb165d6901ab32afb.png
[1344f94f2b31481b98d372cd10dd0f36.png]: https://img-blog.csdnimg.cn/1344f94f2b31481b98d372cd10dd0f36.png
[2a38dcbda569455a8d43b32787b530e0.png]: https://img-blog.csdnimg.cn/2a38dcbda569455a8d43b32787b530e0.png
[74abd2d9b75743579de00658c879c536.png]: https://img-blog.csdnimg.cn/74abd2d9b75743579de00658c879c536.png
[71b0f95f28994f0e9bd4acf0b70cb961.png]: https://img-blog.csdnimg.cn/71b0f95f28994f0e9bd4acf0b70cb961.png
[3ce0ff9eee2c407c8ac6eb8287f538c3.png]: https://img-blog.csdnimg.cn/3ce0ff9eee2c407c8ac6eb8287f538c3.png
[5d38042b294047d1843a5b46db1cbb89.png]: https://img-blog.csdnimg.cn/5d38042b294047d1843a5b46db1cbb89.png
[88f89fbbe17b43d08ec1ae4e50e1b0dd.png]: https://img-blog.csdnimg.cn/88f89fbbe17b43d08ec1ae4e50e1b0dd.png
[4627edc953b64056821b1e19efe8d1d3.png]: https://img-blog.csdnimg.cn/4627edc953b64056821b1e19efe8d1d3.png
[cc9caa97b8e24513884b6c887da72ed8.png]: https://img-blog.csdnimg.cn/cc9caa97b8e24513884b6c887da72ed8.png
[a2cb4007b110417f98cc34e0f1c4194d.png]: https://img-blog.csdnimg.cn/a2cb4007b110417f98cc34e0f1c4194d.png
[fa67248e69e44bd9840e0346ff6badeb.png]: https://img-blog.csdnimg.cn/fa67248e69e44bd9840e0346ff6badeb.png
[c1f50ac78aea4fd4b16f237b0e1cb050.png]: https://img-blog.csdnimg.cn/c1f50ac78aea4fd4b16f237b0e1cb050.png
[9e9802bc9b024f2d81deb2e389bb1b04.png]: https://img-blog.csdnimg.cn/9e9802bc9b024f2d81deb2e389bb1b04.png
[b7832becf3134edf8be9d23d1401e14b.png]: https://img-blog.csdnimg.cn/b7832becf3134edf8be9d23d1401e14b.png
[b69adce366c54122922284c6a4c02a1e.png]: https://img-blog.csdnimg.cn/b69adce366c54122922284c6a4c02a1e.png
[545283c0e6f4427b9bdb02003ef16572.png]: https://img-blog.csdnimg.cn/545283c0e6f4427b9bdb02003ef16572.png