JDK 8新特性 ——接口与函数式接口

野性酷女 2024-03-24 08:29 66阅读 0赞

## 一、接口 ##

### 1.1 接口组成更新概述 ###

*  **常量**

public static final 可以省略

*  **抽象方法**

public abstract 可以省略

*  **默认方法（since java8）**

如下图所示

![d61103bd3c078432772b01cd232d6bac.png][]

*  **静态方法（since java8）**

如下图所示

![f52b40e8de325adece3b4a0c392c0a9f.png][]

*  **私有方法（since java9）**

### 1.2 默认方法 ###

#### **1.2.1 使用场景** ####

假设我们已经存在一个劲接口MyInterface，但是随着业务的进行我们还需要在MyInterface接口中增加一个方法，但是如果我们增加的话，他的每个实现类都需要将这个方法进行实现。

此时有一个坏处，并不是每个类都能使用到这个接口，那我们就重新创建一个接口MyInterfaceSon去继承MyInterface接口，并且写上想增加的方法，如果有类想要使用这个方法，直接可以实现MyInterfaceSon这个类。 但是这样用的话，以后还是会出现想用的问题

public interface MyInterfaceSon extends MyInterface{
    }

**那我们就可以在接口中使用默认方法，如下所示，当我们添加一个默认方法后，实现MyInterface的类可以选择实现方法show3，也可以选择不实现，很人性化**

public interface MyInterface {
        void show1();
        void show2();
    
        public default void show3(){
        }
    }

**总结来说：方法的升级不会破坏现有的代码**

#### 1.2.2 默认方法的使用 ####

**public default 返回值类型 方法名(参数列表)\{ \}**

其中 public是可以省略的

public interface MyInterface {
        void show1();
        void show2();
    
        public default void show3(){
    //    方法体
        }
    }

当我们给MyInterface接口多加了一个default方法后，下面的实现类并没有报错

![8f82cae801723e0d63258b2c82c29d85.png][]

**当我们子类实现show3方法的时候，发现没有default这个关键字了，一定要注意**

![211e5176cc42ea4d539aeae9418c5c26.png][]

### 1.3 静态方法 ###

**静态方法只能通过接口名调用，不能通过实现类名或者对象名调用**

**public static 返回值类型 方法名(参数列表)\{\}**

public可以省略

public static  void show(){
        }

#### 1.3.1 静态方法的使用 ####

public interface Inter {
        void show();
        default void method(){
            System.out.println("Inter中的默认方法执行了");
        }
        public static void test(){
            System.out.println("Inter中的静态方法执行了");
        }
    }

public class InterImpl implements Inter{
        @Override
        public void show() {
            System.out.println("show方法执行了");
        }
    }

然后我们发现我们掉用不了静态的test方法

> 静态方法只能在包含接口类上调用  
> Static method may be invoked on containing interface class only

![f5855f52628cc01e045bcd91769d241d.png][]

> **为什么只能通过类来调用呢？**  
> 假设 InterImpl这个实现类实现了好几个接口，并且每个接口中都有test静态方法，那如果此时再通过实例对象调用，编译器将不会知道调用哪个接口的test方法

### 1.4 私有方法(Java9) ###

#### 1.4.1 接口中的私有方法 ####

Java 9 中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。

这样可能会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段代码抽取成一个共性的方法，而**这个共性方法是不需要让别人使用的，因此用私有给隐藏起来**，这就是Java 9增加私有方法的必然性

**格式：**

**private 返回值类型 方法名(参数列表)\{\}**

**private static 返回值类型 方法名(参数列表)\{\}**

**示例：**

private void show(){}
    
    private static void method(){}

#### 1.4.2 接口中私有方法的使用 ####

**一定要注意！！！！**

**默认方法可以调用私有静态方法，但是静态方法无法调用私有默认方法**

> **自我理解出现这种情况的原因：**  
> 其实说白了和这个根本没有关系，其实和 方法是不是静态方法或者是实例方法有关。  
> 我为什么这么说呢，我解释一下  
>   
> **静态方法什么时候被加载呢？**   
> 当然是在class文件被加载的时候，也就是说在方法区就被加载了  
>   
> **实例方法什么时候被加载？**  
> 在程序运行过程中类实例化后才会存在。  
>   
> 那这样说来就很清晰了，即我们不实例化我们也是可以使用静态方法的，但是不可以使用实例方法。 那如果我们在静态方法中调用了实例方法，但我没有对此类进行实例化，那肯定是不符合要求的呀，你 **没有实例化怎么能在静态方法中调用实例方法呢？**

public class InterImpl implements Inter{
    }

public interface Inter {
        default void show1() {
            System.out.println("show1开始执行");
    //        抽取下面的三行
    //        System.out.println("初级工程师");
    //        System.out.println("中级工程师");
    //        System.out.println("高级工程师");
            show();
            System.out.println("show1结束执行");
        }
    
        default void show2() {
            System.out.println("show2开始执行");
    //        抽取下面的三行
    //        System.out.println("初级工程师");
    //        System.out.println("中级工程师");
    //        System.out.println("高级工程师");
            show();
            System.out.println("show2结束执行");
        }
    
        private void show() {
    
            System.out.println("初级工程师");
            System.out.println("中级工程师");
            System.out.println("高级工程师");
        }
    
        static void method1() {
            System.out.println("method1开始执行");
    //        System.out.println("初级工程师");
    //        System.out.println("中级工程师");
    //        System.out.println("高级工程师");
            method();
            System.out.println("method1结束执行");
        }
    
        static void method2() {
            System.out.println("method2开始执行");
    //        System.out.println("初级工程师");
    //        System.out.println("中级工程师");
    //        System.out.println("高级工程师");
            method()
            System.out.println("method2结束执行");
        }
    
        private static void method() {
            System.out.println("初级工程师");
            System.out.println("中级工程师");
            System.out.println("高级工程师");
        }
    }

public class InterDemo {
        public static void main(String[] args) {
    //    按照多态的方式创建对象并使用
            Inter i = new InterImpl();
            i.show1();
            System.out.println("----------");
            i.show2();
            System.out.println("----------");
            Inter.method1();
            System.out.println("----------");
            Inter.method2();
        }
    }

## 二、引用 ##

> 对lambda表达式不熟悉可以看下面的文章  
> [(45条消息) JDK 8新特性——Lambda表达式\_我爱布朗熊的博客-CSDN博客][45_ JDK 8_Lambda_-CSDN]

### 2.1 体验方法引用 ###

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方法：拿参数做操作

那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同的方案，那是否还有必要再重写逻辑呢？那我们如何使用已经存在的解决方案的呢？

@FunctionalInterface
    public interface Printable {
        void printString(String s);
    }

public class PrintableDemo {
        public static void main(String[] args) {
    //     第一种写法： lambda表达式
           usePrintable( (s -> System.out.println(s)));
            System.out.println("****************");
    
    //     第二种写法：lambda表达式
            Printable printable = (s) -> {
                System.out.println(s);
            };
            usePrintable(printable);
            System.out.println("****************");
    
    //     第三种写法：方法引用符 ::
    //           System.out是一个对象，我们要调用此对象下的println方法
            usePrintable(System.out::println);
        }
    
        private static void usePrintable(Printable p){
            p.printString("爱生活爱Java");
        }
    }

![844577f757307eeffb2ee4b0b93d8ff2.png][]

### 2.2 方法引用符 ###

如果使用Lambda，那么根据"可推导就是可省略"的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导。如果使用方法引用，也是同样可以根据上下文进行推导

*   **:: 双冒号，引用运算符**，而它所在的表达式被称为方法引用

usePrintable(System.out::println);

直接使用System.out中的println方法来取代Lambda，代码更加的简洁

*  **对比一下lambda表达式**

usePrintable( (s -> System.out.println(s)));

**分析：** 拿到参数s之后通过Lambda表达式，传递给System.out.println方法去处理

### 2.3 引用类方法(静态方法) ###

*  **格式：** **类名::静态方法**

*   **范例：** **Integer::parseInt**

Integer类的方法，public static int parseInt(String s) 将此String转换为int类型的数据

@FunctionalInterface
    public interface Converter {
        int convert(String s);
    }

public class ConverterDemo {
        public static void main(String[] args) {
    //    1.匿名内部类表达式
            useConverter(new Converter() {
                @Override
                public int convert(String s) {
                    return Integer.parseInt(s);
                }
            });
    
    //    2.lambda表达式
    //        Converter converter = (String s) -> {
    //            return Integer.parseInt(s);
    //        };
    //        useConverter(converter);
            useConverter((String s) -> {
                return Integer.parseInt(s);
            });
    
    //     3.引用类方法
    //         lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
            useConverter(Integer::parseInt);
        }
    
        private static void useConverter(Converter c){
            int number = c.convert("666");
            System.out.println(number);
        }
    }

### 2.4 引用对象的实例方法(成员方法) ###

其实就是引用类中的成员方法、

*  **格式：** **对象::成员方法**

*   **范例：**  **"HelloWord"::toUpperCase**

String类中的方法：public String toUpperCase() 将此String所有字符转换成大写

public class PrinterDemo {
        public static void main(String[] args) {
    //      1.Lambda表达式
            userPrinter((String s) ->{
                String result = s.toUpperCase();
                System.out.println(result);
            });
    
    //      2.引用成员方法
            PrintString printString = new PrintString();
            userPrinter(printString::printUpper);
        }
    
        private static void userPrinter(Printer p) {
            p.printUpperCase("HelloWord");
    
        }
    }

public interface Printer {
        void printUpperCase(String s);
    }

public class PrintString {
        public void printUpper(String s){
            System.out.println(s.toUpperCase());
        }
    }

### 2.5引用类的实例方法 ###

其实就是引用类中的成员方法

*  **格式：** **类名::成员方法**

*   **范例：**  **String::substring**

String类中的方法：public String **substring**(int beginIndex, int endIndex) 从beginIndex开始到endIndex结束，截取字符串，返回一个子串，子串的长度为endIndex-beginIndex

public interface MyString {
        String mySubString(String s,int x,int y);
    }

public class MyStringDemo {
        public static void main(String[] args) {
    //      1.lambda表达式的形式
             useMyString((s,x,y)->{
                 String substring = s.substring(x, y);
                 return  substring;
             });
    
    //       2.方法引用
            useMyString(String::substring);
        }
    
        public static void useMyString(MyString my){
            String s = my.mySubString("HelloWorld", 2, 5);
            System.out.println(s);
        }
    }

### 2.6 引用构造器 ###

引用构造器，其实就是引用构造方法

*  **格式：** **类名:: new**

*  **范例：**  **Student::new**

## 三、函数式接口 ##

### 3.1 概述 ###

**函数式接口： 有且仅有一个抽象方法的接口**

Java中的函数式变成体现就是lambda表达式，所以函数式接口就是可以适用于Lambda使用的接口，只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导

public interface MyInterface {
        void show();
    }

public class MyInterfaceDemo {
        public static void main(String[] args) {
    
           MyInterface my  = ()->{
               System.out.println("函数式接口");
           };
    
           my.show();
        }
    }

![16c5e317260676e86b6ea6bae2b5b7b4.png][]

但是对于MyInterface接口，我们知道其有一个方法，知道是函数式接口，那万一以后有人再修改接口，新增加抽象方法，那岂不是我们在Demo中的程序无法运行了？

答案： 是的！

**为了避免这种情况，我们可以在接口上使用****@FunctionalInterface注解****，用意是标注此接口为函数式接口**

@FunctionalInterface
    public interface MyInterface {
        void show();
    }

### 3.2 函数式接口作为方法的参数 ###

public class RunnableDemo {
        public static void main(String[] args) {
    //      1.匿名内部类
            startThread(new Runnable() {
                @Override
                public void run() {
                    System.out.println(Thread.currentThread().getName()+"线程启动了");
                }
            });
    
    //      2.lambda表达式
            startThread(()->{
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            });
    
    //        2.1更清晰的写法
            Runnable runnable =()->{
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            };
            startThread(runnable);
    
        }
    
    //  Runnable 接口是函数式接口
        public static void startThread(Runnable r){
    //        Thread t = new Thread(r);
    //        t.start();
            new Thread(r).start();
        }
    }

![204596a18d0a579d2e718d7cdd2192e2.png][]

### 3.3 函数式接口作为方法的返回值 ###

很明显，我们的返回值类型是一个函数式接口

![2a195a4f28cdc40924d8a3438a209ba3.png][]

public class ComparatorDemo {
        public static void main(String[] args) {
            ArrayList<String> arrayList = new ArrayList<>();
            arrayList.add("cccc");
            arrayList.add("aa");
            arrayList.add("b");
            arrayList.add("saff");
            System.out.println("排序前："+arrayList);
    
    //      排序
            Collections.sort(arrayList,getComparator());
            System.out.println("排序后："+arrayList);
        }
    
        private static Comparator<String> getComparator(){
          Comparator<String> comp = new Comparator<String>() {
              @Override
              public int compare(String o1, String o2) {
                  return o1.length()-o2.length();
              }
          };
          return comp;
    //      比较的逻辑也能使用Lambda表达式的形式
    //        return (s1,s2)->{
    //            return s1.length()-s2.length();
    //        };
        }
    }

### 3.4 常用的函数式接口 ###

#### 3.4.1 Supplier ####

Supplier<T>:包含一个无参的方法

*  T get(): 获得结果

*  该方法不需要参数，它会按照某种实现逻辑(由Lambda表达式实现)返回一个数据

*  Supplier<T> 接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用

![b82a622d79c62860bbc823dd2200c051.png][]

public class SupplierDemo {
        public static void main(String[] args) {
    //      写法1：
            String string1 = getString(() -> {
                return "林青霞";
            });
            System.out.println(string1);
    
    //      写法2：
            Supplier<String> supplier =  ()->{
                return "林青霞";
            };
            String string2 = getString(supplier);
            System.out.println(string2);
    
        } 
    //    定义一个方法，返回字符串数据
        private static String getString(Supplier<String> supplier){
            return supplier.get();
        }
    }

##### 3.4.1.1 Supplier接口获取最大值 #####

public class SupplierTest {
        public static void main(String[] args) {
    //       定义一个int数组
            int[] arr= {19,50,28,37,46};
    
            int maxNum = getMax(() -> {
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) {
                    if (arr[i] > max) {
                        max = arr[i];
                    }
                }
                return max;
            });
            System.out.println(maxNum);
        }
    
        private static int getMax(Supplier<Integer> supplier){
            return supplier.get();
        }
    }

#### 3.4.2 Consumer接口 消费型接口 ####

![77bcb6a1b3f3b156086bc2c393e9c743.png][]

**Consumer<T> 包含两个方法**

Consumer接口也称为消费型接口，它消费的数据的数据类型由泛型指定

*  **void accept(T t): 对给定的参数执行此操作**

*  **default Consumer<T> andThen(Consumer after): 返回一个组合的Consumer，依次执行此操作，然后执行after操作**

public class ConsumerDemo {
        public static void main(String[] args) {
            operatorString("林青霞", (String s) -> {
                System.out.println(s);
            });
        }
    
        private static void operatorString(String name, Consumer<String> consumer) {
            consumer.accept(name);
        }
    }

![ddbfb885da2e302bf643a68ecfff2764.png][]

##### 3.4.2.1 Consumer—按要求打印信息 #####

*  String\[\] strArray=\{"林青霞,30" , "张曼玉,35" , "王祖贤,33" \};

*  字符串数组中有多条信息，请按照格式："姓名：xx，年龄：xx"的格式将信息打印出来

*   **要求：**

把打印姓名的动作作为第一个Consumer接口的Lambda实例

把打印年龄的动作作为第二个Consumer接口的Lambda实例

将两个Consumer接口按照顺序组合到一起使用

public class ConsumerTest {
        public static void main(String[] args) {
            String[] strArray={"林青霞,30" , "张曼玉,35" , "王祖贤,33" };
    
            printInfo(strArray,(String str)->{
                String name = str.split(",")[0];
                System.out.println("姓名："+name);
            },(String str)->{
                int age = Integer.parseInt(str.split(",")[1]);
                System.out.println("年龄："+age);
            });
    
        }
        private static void printInfo(String[] strArry, Consumer<String> con1,Consumer<String> con2){
            for (String str: strArry){
                con1.andThen(con2).accept(str);
            }
        }
    }

![6cce6a65139d67b10eaa8072eff432a0.png][]

#### 3.4.3 Predicate ####

**表示对一个参数进行判断的，返回一个布尔值**

下图是Api文档中对Predicate接口方法的描述

![d58c91105c71f6fa5387df8e069c792b.png][]

*  **Predicate<T>:常用的四个方法**

*   **boolean test(T t):**对给定的参数进行判断(判断罗辑由Lambda表达式实现)，返回一个布尔值

*  **default Predicate<T>negate0:**返回一个逻辑的否定，对应逻辑非default

*  **Predicate<T>and(Predicate other):** 返回一个组合判断，对应短路与

*   **defaultPredicate<T>or(Predicate other):** 返回一个组合判断，对应短路或

##### 3.4.3.1  Predicate<T> 接口通常用于判断参数是否满足指定的条件 #####

public class PredicateDemo01 {
        public static void main(String[] args) {
            boolean b = checkString("hello", (String s) -> {
                return s.length() > 8;
            });
            System.out.println(b);
        }
        private static boolean checkString(String s, Predicate<String> pre){
            return pre.test(s);
        }
    }

![5067f3791cef583ce261369eb62d45da.png][]

##### **3.4.3.2 negate逻辑非的运算** #####

private static boolean checkString(String s, Predicate<String> pre){
    //        return !pre.test(s);   这种情况是我们之前的饿用法
            return pre.negate().test(s);
        }

![0625630bd63937e68b81fc4d35bf58ea.png][]

##### 3.4.3.3 组合判断，对应短路与 #####

public class PredicateDemo01 {
        public static void main(String[] args) {
    
            boolean b = checkString("hello",
                    (String s) -> {
                        return s.length() > 8;
                    },
                    (String s) -> {
                        return s.length() <15;
                    });
            System.out.println(b);
        }
    
        //  同一个字符串给出两个不同的判断条件，最后把这两个判断的结果做逻辑与运算的结果作为最终的结果
        private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
    //        
    //        boolean b1 = pre1.test(s);
    //        boolean b2 = pre2.test(s);
    //        boolean b = b1 && b2;
    //        return b;
            return pre1.and(pre2).test(s);
        }
    }

##### 3.4.3.4 组合判断，对应短路或 #####

private static boolean checkString(String s, Predicate<String> pre1, Predicate<String> pre2) {
    
            return pre1.or(pre2).test(s);
        }

##### 3.4.3.5 筛选满足条件的数据 #####

*  String\[\] strArray=\{"林青霞,30","柳岩,34","张曼玉,35","貂蝉,31","王祖贤,33"\};

*  字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符审筛选到集合ArraList中，并遍历ArrayList

*  集合同时满足如下要求:姓名长度大于2;年龄大于33

public class PredicateDemo02 {
        public static void main(String[] args) {
            String[] strArray = {"林青霞,30", "柳岩,34", "张曼玉,35", "貂蝉,31", "王祖贤,33"};
            ArrayList<String> arrayList = myFilter(strArray,
                    (String s) -> {
                        return s.split(",")[0].length() > 2;
                    }, (String s) -> {
                        return Integer.parseInt( s.split(",")[1])>33;
                    });
            System.out.println(arrayList);
        }
    
        private static ArrayList<String> myFilter(String[] strArray, Predicate<String> pre1, Predicate<String> pre2) {
            ArrayList<String> arrayList = new ArrayList<>();
    //    便利数组
            for (String str : strArray) {
                if (pre1.and(pre2).test(str)) {
                    arrayList.add(str);
                }
    
            }
            return arrayList;
        }
    }

#### 3.4.4 Function ####

**Function<T,R>接口通常用于对参数进行处理，转换(处理逻辑由Lambda表达式实现)，然后返回一个新的值**

![7e2743342cd92ed5ac975ac07d6c260a.png][]

*  **R apply(T t):** 将此函数应用于给定的参数

*  **default<V> Function andThen(Function after):** 返回一个组合函数，首先将该函数应用于输入，然后将after函数应用于结果

public class FunctionDemo {
        public static void main(String[] args) {
            convert("100",(String s)->{
                return Integer.parseInt(s);
            });
        }
    //  将String转化为integer
        private static void convert(String s, Function<String, Integer> function){
            Integer apply = function.apply(s);
            System.out.println(apply);
        }
    }

![e05aeb57517d9ddb69dc6023cb21ac6d.png][]

##### 3.4.4.1 按照指定要求操作数据 #####

*  String s="林青霞,30"

*  请按照我指定的要求进行操作:

*  1:将字符串截取得到数字年龄部分

*  2:将上一步的年龄字特串转换成为int类型的数据

*  3:将上一步的int数据加70，得到一个int结果，在控制台输出请通过Function接口来实现函数拼接

public class FunctionDemo {
        public static void main(String[] args) {
    
            convert("林青霞,30",
                    (String s) -> {
    //                  提取出30
                        return s.split(",")[1];
                    },
    //               将字符串转换成Integer
                    s1 -> {
                         return Integer.parseInt(s1);
                    },
    //              将这个数加70
                    s2 -> {
                        return s2+70;
                    }
                    );
        }
    
        //  将String转化为integer
        private static void convert(String s, Function<String, String> function1, Function<String, Integer> function2, Function<Integer, Integer> function3) {
    //        Integer apply = function1.apply(s);
    //        System.out.println(apply);
            Integer integer = function1.andThen(function2).andThen(function3).apply(s);
            System.out.println(integer);
        }
    }

[d61103bd3c078432772b01cd232d6bac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/43c2c043211748e88a694371200f0ee4.png
[f52b40e8de325adece3b4a0c392c0a9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3a464cff44c044e29c2c5439b1a43172.png
[8f82cae801723e0d63258b2c82c29d85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/0204bcfd348e4f46845ff5f4ef26eaff.png
[211e5176cc42ea4d539aeae9418c5c26.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/fe985a4495cf4bd5b2f1818e68435198.png
[f5855f52628cc01e045bcd91769d241d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/daee52e13fc547468a3668a1cc745d6a.png
[45_ JDK 8_Lambda_-CSDN]: https://blog.csdn.net/weixin_51351637/article/details/129368377?spm=1001.2014.3001.5502
[844577f757307eeffb2ee4b0b93d8ff2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/89351b2a68d242caa948c88030841177.png
[16c5e317260676e86b6ea6bae2b5b7b4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/9746db927f0f4da5b128e16845713996.png
[204596a18d0a579d2e718d7cdd2192e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5ea7a83251354669bf7236b35971152e.png
[2a195a4f28cdc40924d8a3438a209ba3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/f547d1e6828345aabd52aa887ce32875.png
[b82a622d79c62860bbc823dd2200c051.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/e1105c8d6bb4433eaacb03e176f44077.png
[77bcb6a1b3f3b156086bc2c393e9c743.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/9351abcd95d943cc816f2847530647ad.png
[ddbfb885da2e302bf643a68ecfff2764.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a4f91ce1ddd749eb93a7036755d0da1d.png
[6cce6a65139d67b10eaa8072eff432a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/88e3090a6d174087b66b3302ba004874.png
[d58c91105c71f6fa5387df8e069c792b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/2f22d565f0674ad8b19f30723339ed26.png
[5067f3791cef583ce261369eb62d45da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/5d4566dfa6c64d12b8f285fa704f896a.png
[0625630bd63937e68b81fc4d35bf58ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/52a0d13c6d514ec8a3acf59b5fc0b30b.png
[7e2743342cd92ed5ac975ac07d6c260a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/64c6d98b46a34170afc2fc0dcd8b6d83.png
[e05aeb57517d9ddb69dc6023cb21ac6d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d82808b773a64d74ab1f8459b2bdf8a0.png