反射、枚举和lambda表达式

这篇具有很好参考价值的文章主要介绍了反射、枚举和lambda表达式。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

一、反射

Java的反射(reflection)机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任
意一个对象,都能够调用它的任意方法和属性,既然能拿到那么,我们就可以修改部分类型信息;这种动态获取信
息以及动态调用对象方法的功能称为java语言的反射(reflection)机制。
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

反射的相关类

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

类名 用途
Class类 代表类的实体,在运行的java应用程序种表示类和接口
Field 代表类的成员变量
Method类 代表类的方法
Constructor类 代表类的构造方法

反射机制的起源:
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));
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

反射的基本使用

获得类常用方法

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

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);
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们需要注意newInstance返回的是一个泛型,在编译阶段擦除为Object,所以我们在接受的时候需要强制类型转换
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
2.通过反射获取构造方法
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们来获取一下私有的构造方法

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);
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们可以发现系统报错,无法获取私有的,那到底是怎么回事呢?因为我们需要打开一下权限。

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);
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
3.通过反射获取相关属性

方法 用途
getField(String name) 获得某个公有的属性对象
getFields() 获得所有公有的属性对象
getDeclaredField(String name) 获得某个属性对象
getDeclaredFields() 获得所有属性对象
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);
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
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);
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

反射优点和缺点

优点:

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

缺点:文章来源地址https://www.toymoban.com/news/detail-811865.html

  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;
        }
    }
}

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
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]);
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
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());
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
valueOf()将普通字符串转换为枚举实例

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
只能转换枚举类型种已经定义的

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
Enum类和enum关键字定义的类型都有values方法,但是点进去会发现找不到这个方法。这是因为java编译器在编译这个类(enum关键字定义的类默认继承java.lang.Enum)的时候自动插入了一条static的方法values。在官方文档中有说明。
文档地址:官方文档

枚举与反射

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

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;
    }
}

在枚举中调用
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
为什么我们通过反射调用枚举的构造方法时会报java.lang.IllegalArgumentException: 异常呢?
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们在源码中可以发现枚举在这里被过滤了,你不能通过反射获取枚举类的实例。
这里证明: 枚举实现单例模式是安全的

总结

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 注解,那么编译器就会按照函数式接口的定义来要求该接
    口,这样如果有两个抽象方法,程序编译就会报错的。所以,从某种意义上来说,只要你保证你的接口中只
    有一个抽象方法,你可以不加这个注解。加上就会自动进行检测的。
    反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
    我们以优先级队列为例,传入的比较器,我们可以发现这个接口上面有@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();
    }

这里我们使用匿名内部类
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
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("匿名内部类");
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
参数只有一个时,可以去掉括号。
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());
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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));
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

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

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

lambda在集合中的应用

1.forEach() 方法演示
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们来看一下forEach的参数
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们发现是一个函数式接口,所以我们可以使用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 + " "));
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
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表达式:

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((String s,Integer i) -> System.out.println(s + " -> " + i ));
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
3.sort() 方法演示
反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构
我们发现这里是一个函数式接口

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 + " ");
        }
    }

反射、枚举和lambda表达式,JAVA SE,数据结构与算法,jvm,java,面试,数据结构

总结

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

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

缺点:

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

到了这里,关于反射、枚举和lambda表达式的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • Lambda表达式(JAVA)

    注:如果没有学过 匿名内部类 和 接口 不推荐往下看。 (parameters) - expression 或 (parameters) -{ statements; } parameters:表示参数列表; -:可理解为“被用于”的意思; expression:表示一条语句; statements:表示多条语句。 Lambda可以理解为:Lambda就是匿名内部类的简化。 lambda表达式

    2024年02月08日
    浏览(52)
  • Java- Lambda表达式

    目录 一、Lambda简介 二、Lambda使用前提 三、Lambda语法 1.操作符 a.\\\"-\\\"  b.\\\"::\\\" 2.格式  a.无参数 b.有参数 四、Lambda演化过程 五、Lambda实现排序 Lambda 表达式,也可称为闭包,它是推动 Java 8 发布的最重要新特性。Lambda 允许把函数作为一个方法的参数(函数作为参数传递进方法中)

    2024年02月03日
    浏览(73)
  • Java Lambda表达式

    1.1 函数式编程思想概括 在数学中,函数就是有输入量、输出量的一套计算方案,也就是“拿数据做操作” 面向对象思想强调“必须通过对象的形式来做事情” 函数式思想则尽量忽略面

    2024年02月07日
    浏览(58)
  • Java Lambda 表达式

    💗wei_shuo的个人主页 💫wei_shuo的学习社区 🌐Hello World ! Java Lambda 表达式是 Java 8 引入的一种函数式编程特性,它是一种轻量级的匿名函数,允许我们将函数作为方法的参数进行传递。Lambda 表达式可以理解为是一种简洁的方式来表示可传递的代码块,它可以替代传统的匿名内

    2024年02月08日
    浏览(52)
  • 【JAVA】包装类、正则表达式、Arrays类、Lambda表达式

    包装类是8种基本数据类型对应的引用类型 作用:后期的集合和泛型不支持基本类型,只能使用包装类 基本数据类型和其对应的引用数据类型的变量可以互相赋值 基本数据类型 引用数据类型 byte Byte short Short int Integer long Long char Character float Float double Double boolean Boolean 包装类

    2024年02月13日
    浏览(56)
  • java lambda表达式详解

    我们知道,在Java中,接口是不能实例化的,但是接口对象可以指向它的实现类对象。如果接口连实现对象都没有呢?那还可以使用匿名类的方式,如下: 复制 但是,使用匿名内部的方式,代码量其实并不是非常简洁,而为了使代码更加的简洁,Java引进了 Lambda 表达式的写法,

    2024年02月03日
    浏览(49)
  • Java学习——lambda表达式

    什么是Lambda表达式? 可以将Lambda表达式理解为一个匿名函数; Lambda表达式允许将一个函数作为另外一个函数的参数; 我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码作为实参),也可以理解为函数式编程, 将一个函数作为参数进行传递 。 为什么要引入Lambda表

    2024年02月04日
    浏览(60)
  • Java中的lambda表达式

    目录 一、背景 二、lambada表达式的基本使用 三、变量捕获 四、lambda在集合中的使用(map和set) 五、优缺点 一、背景 (1)、lambda表达式的定义: (2)、lambda表达式的语法: (3)、函数式接口 二、lambada表达式的基本使用 (1)没有使用lambda表达式,简单调用函数式接口展

    2024年02月08日
    浏览(52)
  • 浅谈 Java 中的 Lambda 表达式

    更好的阅读体验 huge{color{red}{更好的阅读体验}} 更好的阅读体验 Lambda 表达式是一种匿名函数,它可以作为参数传递给方法或存储在变量中。在 Java8 中,它和函数式接口一起,共同构建了函数式编程的框架。 函数式编程是一种编程范式,也是一种思想。 它将计算视为函数求

    2024年02月11日
    浏览(63)
  • Java新特性:Lambda表达式

    Java新特性:Lambda表达式 Lambda 表达式(Lambda expression),也可称为闭包(Closure),是 Java(SE)8 中一个重要的新特性。Lambda 表达式允许我们通过表达式来代替功能接口。Lambda 表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表

    2024年02月13日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包