java 8-17 新特性(学习留存，欢迎交流)

已于 2024-05-09 17:07:00 修改
阅读量726 收藏 23
点赞数 14
分类专栏： Java学习 文章标签： java 开发语言 学习
于 2024-05-04 15:59:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_72250569/article/details/138443635
版权

目录

一、java 8 新特性

二、java 9 新特性

三、java 10 新特性

四、Java 11 新特性

五、Java 12-16 新特性

六、java 17 新特性

一、java 8 新特性

  1. Lambda表达式

    1. 匿名内部类: 使用条件：当需要实现的接口有且仅有一个抽象方法时，我们就可以将实现接口的代码替换为 (方法的参数名)->方法的实现逻辑

      如：实现Runnable的匿名内部类：

      本来我们要想实现一个Runnable匿名内部类并且创建一个线程，我们需要完整的实现run方法再创建线程：

      public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("不使用lambda表达式");
            }
        });
        thread.start();
    }
}

      由于只需要实现一个方法，因此可以使用lambda表达式，run方法没有参数因此lambda表达式也不需要参数，可以写为下面的代码大幅缩减代码的编写量

      public class Main {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {System.out.println("使用lambda表达式")});
        thread.start();
    }
}

      并且匿名内部类会单独编译成一个class文件，而lambda表达式不会。但是lambda表达式只支持接口，不能支持抽象类。

      当参数只有一个时，也可以省略()只留参数名字，并且实现语句只有一句时也可以省略{}。

      举个例子，我们创建一个接口

      public interface Interface {
    void method(int i);
}

      实现它，直接省略()和{}，当然，只有参数有且仅有一个时才可以省略()，实现语句有且仅有一条时才能省略{}

      public class Main {
    public static void main(String[] args) {
        Interface inter = i -> System.out.println(i);
        inter.method(1);
    }
}

      总结：lambda表达式仅能用于接口不能用于抽象类，并且接口中必须有有且仅有一个方法需要实现才可以使用。在使用时，使用的形式如([参数名1，参数名2.....]) -> {实现语句}，当参数有且仅有一个时可以省略()，当实现语句有且仅有一个时可以省略{}

  2. 基于lambda表达式的函数式接口（@FunctionalInterface）

    1. Supplier供给型函数时接口 仅有一个需要实现的get()方法用于获取需要的对象,返回值是泛型类，如下：当需要一个新的学生对象时调用get方法即可

      public class Main {
​
    public static void main(String[] args) {
        Supplier<Student> studentSupplier = () -> new Student();
        studentSupplier.get().supplier();
    }
​
    public static class Student {
        public void supplier(){
            System.out.println("学生类供给式函数式接口");
        }
    }
}

    2. Consumer消费型函数式接口 仅有一个需要实现的accept(T)方法用于获取需要的对象,返回值是void型，传入的参数用于消费

      public class Main {
​
    public static void main(String[] args) {
        Consumer<Student> studentConsumer = student -> System.out.println(student+"已被消费");
        studentConsumer.accept(new Student());
    }
​
    public static class Student {
    }
}

      还有一个默认实现了的andThen(Consumer)方法,如果这个方法传入的Consumer参数是空就会抛异常，如果不为空就会在执行完accept后执行，同一个消费型函数时接口对象只能同时调用一次accept方法，但是可以多次调用andThen方法，他们会顺序执行,且该方法只会在accept方法执行完成后执行，单独调用不会执行

      public class Main {
​
    public static void main(String[] args) {
        Consumer<Student> studentConsumer = student -> System.out.println(student+"已被消费");
        studentConsumer
                .andThen(student -> System.out.println("消费完成1！"))
                .andThen(student -> System.out.println("消费完成2!"))
//                .accept(new Student()) 连续调用报错
                .accept(new Student());
    }
​
    public static class Student {
    }
}

    3. Function函数型函数式接口 仅有一个需要实现的apply(T)方法，返回值是泛型类R

      public class Main {
​
    public static void main(String[] args) {
    //举例：接收的T类型为Integer类型，返回的R类型为String类型
        Function<Integer,String> studentFunction = (num) -> String.valueOf(num);
        System.out.println(studentFunction.apply(1));
    }
}

      默认实现的compose(Function)方法，此方法在调用时会先将传入apply的参数进行操作然后再执行apply方法，andThen(Function)方法会在最后在对apply方法处理后的返回值进行处理

      public static void main(String[] args) {
        Function<Integer,String> studentFunction = (num) -> String.valueOf(num);
        //compose方法先将传入的参数转化为Integer类型，然后将Integer类型通过apply方法转化为String类型，最后通过andThen方法将String类型转化为Integer类型
        //即 String -> Integer -> String -> Integer
        System.out.println(
                studentFunction
                        .andThen((String i)-> i.length())
                        .compose((String str)->str.length())
                        .apply("lbw nb")
        );
        //"lbw nb" -> 6 -> "6" -> 1
    }

      identity将传入的参数原样返回，个人认为没什么用，感兴趣的可以自己看一下

    4. Predicate断言型函数式接口 仅有一个需要实现的方法test(T)，返回值为boolean

      public static void main(String[] args) {
        Predicate<Integer> stringPredicate = (num) -> num >= 17;
        Integer num = 17;
        if(stringPredicate.test(num)){
            System.out.println("十七张牌你能秒我，我直接把这个电脑吃掉");
        }else {
            System.out.println("全体起立");
        }
    }

      and(Predicate)方法，和test同时满足时才为true

      public static void main(String[] args) {
        Predicate<Integer> integerPredicate = (grade) -> grade >= 60;
        //and方法，如果和test同时满足
        if(integerPredicate
                .and((Integer grade) -> grade >= 90)
                .test(70)){
            System.out.println("90分，高手");
        }
    }

      or(Predicate)放啊，和test有一个满足为true

      public static void main(String[] args) {
        Predicate<Integer> integerPredicate = (num) -> num == 0;
        //or(Predicate)方法，和grade有一个满足即可
        if(integerPredicate
                .or((Integer i) -> i > 0)
                .test(17)){
            System.out.println("让我猜一猜，这个数是一个非负数");
        }
    }

      negate，将test方法结果取反

      public static void main(String[] args) {
        Predicate<Integer> integerPredicate = (num) -> num == 0;
        //negate方法，会将test方法的结果取反
        System.out.println(integerPredicate
                .negate().test(0));
    }

  3. 判空包装类Optional类：处理空指针异常

    of(T)方法传入一个参数包装，如果参数为null会报异常，ofNullable(T)如果传入参数为null，不会报异常

    ifPresent(Consumer)方法，如果包装的不为null，实现消费型函数式接口来消费传入的参数

    public static void main(String[] args) {
        method("字符串");
        method(null);
    }

    public static void method(String str) {
        Optional
                .ofNullable(str)
                .ifPresent(s-> System.out.println(s));
    }

    get()方法获取包装的对象,如果包装的是空，get方法会报异常

    public static void main(String[] args) {
        System.out.println(method("字符串"));
        System.out.println(method(null));
    }

    public static String method(String str) {
        return Optional
                .ofNullable(str)
                .get();
    }

    orElse(T)方法，如果包装的是空，就传入参数T并返回T

    public static void main(String[] args) {
        System.out.println(method("字符串"));
        System.out.println(method(null));
    }

    public static String method(String str) {
        return Optional
                .ofNullable(str)
                .orElse("重新包装");
    }

    orElseGet(Supplier)，如果包装的是空，就传入supplier然后经过操作后再返回一个值

    public static void main(String[] args) {
        System.out.println(method("字符串"));
        System.out.println(method(null));
    }

    public static String method(String str) {
        return Optional
                .ofNullable(str)
                .orElseGet(()-> "重新包装");
    }

    orElseThrow(Exception)如果包装的是空，会抛出传入的异常

    还有一些其他的方法，感兴趣的可以自己学习

还有一些其他的不常用改进，感兴趣的可以再自行查阅

二、java 9 新特性

  1. 模块机制

  2. JShell交互式编程 在命令行窗口中输入jshell，就可以在命令行窗口中进行java代码编写,vars用于看变量的定义，methods用于看方法的定义，感兴趣的话其他的命令可以自行学习

  3. 接口中的私有方法 我们知道，java8中的接口只能有常量、抽象方法、静态方法和default方法，如果我们在接口中的default方法和静态方法中需要频繁的使用一些代码，但这些代码我们又不想让子类看到，怎么办呢？在java9中给接口增加了私有方法，让我们可以实现代码的复用同时又不让子类看到,私有方法在接口中必须实现。

  4. 集合类新增工厂方法 在java9之前，我们要想给集合类里面提前加一些数据，必须要先进行集合类的定义和初始化，然后才能一个个添加如：

    public class Main {
    public static void main(String[] args) {
        HashMap<Integer,String> hashMap = new HashMap();
        hashMap.put(1,"1");
        hashMap.put(2,"2");
    }
}

    现在增加了工厂方法，可以直接通过of方法来提前添加，但是注意提前添加的元素无法进行修改，对其他的集合也是这样

    public class Main {
    public static void main(String[] args) {
        Map<Integer,String> map = Map.of(1,"1",2,"2",3,"3");
    }
}

  5. 改进 stream API

    1. of改进

      将集合进行过滤和去重后收集，此时of中传入null会报错

    public class Main {
    public static void main(String[] args) {
        List<Integer> list = Stream.of(1,2,3,4)
                .filter(t->t.equals("3"))
                .distinct()
                .collect(Collectors.toList());
    }
}

    改进后使用ofNullable可以允许传入null,但是每次只能一个传入一个

    public class Main {
    public static void main(String[] args) {
       Stream
                .ofNullable(null)
                .forEach(System.out::println);
    }
}

    1. iterate limit改进更加类似于for循环 往流中不断的加入一些元素

      public class Main {
    public static void main(String[] args) {
        Stream
                .iterate(0,i->i+1)
                .limit(20)
                .forEach(System.out::println);
    }
}

      改进后可以直接限制次数

      public class Main {
    public static void main(String[] args) {
        Stream
                .iterate(0,i -> i < 20,i -> i+1)
                .forEach(System.out::println);
    }
}

    2. 新增对数据的截断操作

      takewhile 当满足条件时在进行操作

      public class Main {
    public static void main(String[] args) {
        Stream
                .iterate(0, i -> i < 20, i -> i + 1)
                .takeWhile(i -> i < 10)
                .forEach(System.out::println);
    }
}

      dropwhile 当满足条件时不操作

      public class Main {
    public static void main(String[] args) {
        Stream
                .iterate(0, i -> i < 20, i -> i+1)
                .dropWhile(i -> i < 10)
                .forEach(System.out::println);
    }
}

  6. try-with-resource

    在java9之前，我们要将需要关闭的资源的定义和初始化全部放入try()中才可以，java9中我们可以先定义和初始化，再将需要关闭的资源的变量名放入到try()中去。

  7. optional类的改进

    1. ifPresentOrElse(Consumer,Runnable)可以同时处理为空和不为空的两个情况了,如果不为空执行Consumer，否则执行runnable

      public static void main(String[] args) {
        method("字符串");
        method(null);
    }

    public static void method(String str) {
        Optional
            .ofNullable(str)
            .ifPresentOrElse(s-> System.out.println(s),()-> System.out.println("传入参数为空"));
    }

    2. or(Supplier)如果为空，就用一个option替换掉这个optional

      public static void main(String[] args) {
        method("字符串");
        method(null);
    }

    public static void method(String str) {
        Optional
            .ofNullable(str)
            .or(()->Optional.ofNullable("替换的包装"))
                .ifPresent(s-> System.out.println(s));
    }

  8. 泛型的改进

    我们定义了如下抽象类

    public abstract class Test<T> {
    private T t;
    public Test(T t){
        this.t = t;
    }
    public void method(){
        System.out.println(t);
    }
}

    在java9之前的版本中，无法自动识别传入的参数的类型并报错，但是java9中java会自动推断类型不会报错

    public class Main {
    public static void main(String[] args) {
        Test<String> test = new Test<>("aaa") {};
        test.method();
    }
}

还有一些其他的不常用改进，感兴趣的可以再自行查阅

三、java 10 新特性

  1. 局部变量类型推断

    var类型推断，使用var在定义变量时替代变量类型，只能用于在定义时初始化的变量且仅适用于局部变量

    public class Main {
    public static void main(String[] args) {
        var a = "aaa";
        System.out.println(a.toUpperCase());
    }
}

还有一些其他的不常用改进，感兴趣的可以再自行查阅

四、Java 11 新特性

  1. 用于Lambda的形参局部变量语法

    public class Main {
    public static void main(String[] args) {
        Consumer<String> consumer = (var str) -> {
            System.out.println(str);
        };
        consumer.accept("形参");
    }
}

  2. 针对String 的方法改进

    1. 判断字符串中是否全部为空格 isBlank()方法

    2. 将字符串重复拼接n次并返回 repeat(n)方法

    3. 根据换行符判断字符串分为几部分 .lines().count() .lines()方法会将字符串根据换行符分段为流，conut()可以计数

    4. 去除首尾空格，strip() 是trim()的增强版，trim()无法去除unicode空白字符，而strip可以

五、Java 12-16 新特性

  1. 新switch语法(14正式开放) switch可以有返回值并且写法更简洁,但这种写法必须要包含所有返回值，否则报错，因此要写default

    public class Main {
    public static void main(String[] args) {
        System.out.println(grade(77));
    }

    public static String grade(int score){
        score /= 10;
        return switch (score){
            case 10,9 -> "优秀";
            case 8,7 -> "良好";
            case 6 -> "及格";
            default -> "不及格";
        };
    }
}

    如果我们最后在case中还要进行一些操作再进行返回，要使用yield关键字

    public class Main {
    public static void main(String[] args) {
        System.out.println(grade(95));
    }

    public static String grade(int score){
        score /= 10;
        return switch (score){
            case 10,9 -> {
                System.out.println("点名表扬");
                yield "优秀";
            }
            case 8,7 -> "良好";
            case 6 -> "及格";
            default -> {
                System.out.println("打电话叫家长");
                yield "不及格";
            }
        };
    }
}

  2. 三引号(15正式开放) 字符串在编写时不需要对特殊字符进行转义，而是全部认为是字符，但是不能连续出现三个"

    public class Main {
    public static void main(String[] args) {
        String str = "111";
        String a = """
                dasd <a href = str.length '' '
                """;
        System.out.println(a);
    }
}

  3. 空指针改进：可以更明确的指出空指针的异常原因。比如再类型转换时如果为空，会明确告诉你由于传入的参数为空因此无法类型转换，而在改进之前只会告诉你空指针异常，原因需要你自己找寻。

  4. 记录类型（Record）,参数会自动实现set、get、hashcode等方法(java16开放)

    写一个学生类

    public record Student(String id, String name,int age) {
}
调用自动实现的方法

public class Main {
    public static void main(String[] args) {
        Student student = new Student("123","张三",19);
        System.out.println(student.age());
        System.out.println(student.toString());
        System.out.println(student);
    }
}

六、java 17 新特性

  1. 密封类型 sealed 关键字修饰类，仅让被允许的子类继承

    我们让A被修饰，让B去继承A

    public sealed class A permits B {
}
public final class B extends A {
}

    1. 密封类型可以基于普通类、抽象类、接口，也可以是继承自其他抽象类的子类或者是实现其他接口的类等。

    2. 必须有子类，且不能是匿名内部类

    3. sealed不能与final、non-sealed同时出现

    4. 继承的子类必须为final、sealed或是non-sealed的

学习参考： 青空の霞光的个人空间-青空の霞光个人主页-哔哩哔哩视频

                   青空の霞光-CSDN博客

java新手，欢迎大家学习、交流和批评指正。

Aayasu
关注
专栏目录
AI架构师必知必会系列：强化学习在金融领域的应用
AI天才研究院
12-05 373
在金融领域，如何制定最优决策以实现收益最大化和风险最小化一直是一个核心问题。传统的金融决策方法主要依赖于统计模型和专家经验,但在面对日益复杂多变的金融市场时,这些方法往往难以适应和优化。近年来,随着人工智能技术的快速发展,强化学习作为一种智能决策方法受到了金融领域的广泛关注。
Java编程规范
生活在别处
07-12 2703
文章目录前言编程规范命名规范【强制】命名不能以下划线或美元符号开头或者结尾。【强制】命名不允许使用拼音与英文混合的方式。【强制】类目使用UpperCamelCase风格。【强制】方法名、参数名、成员变量、局部变量都统一使用lowerCamelCase风格。【强制】常量命名应该全部大写，单词间使用下划线隔开。【强制】抽象类命名使用Abstract或Base开头；异常类命名使用Exception结尾；测试类命名以它要测试的类目开始，以Test结尾。【强制】定义数组时，类型和[]紧挨。【强制】POJO类中的任何布
JDK17 - 开发者视角，从 JDK8 ~ JDK17 都增加了哪些新特性
CYK_byte的博客
01-02 1万+
本文只是站在开发者视角，来看看升级哪些咱们程序员常用的功能~经过统计，空指针异常是导致 Java 应用程序失败的最常见原因，因此 Google 公司 引入了Optional 类以检查空值的方式来避免空指针异常，使程序员写出更干净的代码.Optional 类（Java.util.Optional）是一个容器类，可以保存类型T值，表示这个值存在。或者，也可以只保存 null，表示这个值不存在。也就是说，以前用 null 表示一个值不存在，现在 Optional 就可以更好的表达这个概念，避免空指针异常.
Java8 ~ Java17 新特性
adolph09的博客
04-19 749
主要特性：函数式接口就是有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。可以隐式转化为 Lambda 表达式。 通过方法引用，可以使用方法的名字来指向一个方法。使用一对冒号来引 "::" 用方法。构造方法引用使用Class:new 静态方法引用使用方式：Class::staticMethod 实例方法引用使用方式：instance::method Java 8 新增了接口的默认实现，通过 default 关键字表示。 Java 8 支持了重复注解。在 Java 8 之前想实现重复注
java基础之java 新特性（8-17）
weixin_46375204的博客
10-20 188
有且仅有一个抽象方法的接口。实例化——>中间操作——>终止操作。
【Java】从java8到java17各版本新特性详解
一个天蝎座的程序猿
03-22 3126
下面这张图是 Oracle 官方给出的 Oracle JDK 支持的时间线，可以看出，JDK 17的支持时间最长，可以延续到2029年9月。考虑到技术更新的速度，这次免费商用8年的时间可谓是经过精心考虑，旨在让用户放心地升级到JDK 17（不过JDK 8的支持时间更长，可以延续到2030年12月）。从JDK诞生到现在，仅有几个版本得到了长期支持，主要包括JDK 7、JDK 8、JDK 11以及即将发布的JDK 17，它将是继Java 8之后最重要的LTS版本，是Java社区八年努力的成果。
Java 17 VS Java 8: 新旧对决，这些Java 17新特性你不容错过
qq_43842093的博客
02-26 3143
Java是一门非常流行的编程语言，由于其跨平台性、可移植性以及强大的面向对象特性而备受青睐。Java最初由Sun Microsystems公司于1995年推出，随着时间的推移，Java发展迅速，版本不断更新。本篇博客将重点介绍Java 17与Java 8的对比，以及Java 17的新特性。
JDK8-17新特性总结
长安不及十里的博客
07-01 4267
最近写项目用到了Spring3.0，JDK8不行了，一看原来JDK已经更新到了22了，下面是我总结的一些新特性。
微信答题小程序-答题app小程序源码+每日签到+排位赛+群比赛+道具商店+JAVA技术.zip
10-05
该压缩包文件“微信答题小程序-答题app小程序源码+每日签到+排位赛+群比赛+道具...不过，值得注意的是，由于“仅供学习交流使用，不提供技术支持”，在实际使用或学习过程中遇到问题，可能需要自行解决或寻求社区帮助。
新员工拿到了Offer阿里巴巴最新Java面试经验
m0_67698950的博客
03-28 128
如果需要获取到这个（java面试知识点整理）文档的话，关注转发+评论，然后后台私信【java】即可免费获取文中资料 1.一面 前不久阿里来了一个面试的居然拿到了Offer，约好了晚上19:00,结果等到了19：30电话才过来，面试官连连说抱歉，说刚刚在开一个比较紧急的会议，然后闲聊了几句，电面氛围也没之前那么紧张了，然后让自我介绍一下进入正题。 巴拉巴拉介绍了一下个人经历，和最近做的事情，面试官对我最近做的一个跨境项目在比较感兴趣，让我详细说一下这个架构设计：其实跟主流的系统架构差不多，在上..
全网最全-Java简历优化-优质项目经历
热门推荐
成功最快的秘诀: 抱团取暖 。
10-16 24万+
该项目要求仿照目前比较流行的“今日头条” app，内容则以技术类文章为主，为终端学习用户提供精准的.感兴趣的技术文章，为技术类的自媒体人提供首运营的平台。该项自运用Spring Boot快速并发框架构建顽自工程，并结合Spring Cloud全家桶技术，实现后端个人中心、自媒体、管理中心等微服务。该项目是一个多平台联合使用工程，本人负责真中文章为主线的核心业务。
探索Java的新特性：从Java 8到Java 17
阿里渣渣java研发组-群主
05-29 872
随着时间的推移，Java不断演进，每个新版本都会引入新的特性和改进。本文将探讨从Java 8到Java 17的一些关键新特性，帮助开发者更好地理解和利用这些变化。从Java 8到Java 17，Java不断引入新的特性和改进，使得编写更简洁、高效和可维护的代码成为可能。作为开发者，了解和掌握这些新特性，将有助于你在实际项目中更好地利用Java的强大功能。Java 8是一个重要的里程碑，引入了许多显著的特性，使得编写代码更加简洁和高效。从Java 12到Java 17，每个版本都引入了一些增量改进和新特性。
Java8——17程序逻辑控制
小金是个小菜鸡
06-15 91
程序逻辑结构主要分为三种：顺序、分支、循环结构。 顺序结构有时候是以{}为一个界限的 分支结构： 分支结构就是一种判断结构，有两类语法支持：if、switch if 分支语句： switch分支语句：不能判断布尔表达式，可以进行整数、字符、String、枚举等的判断； switch(整数|字符|枚举|String){ case 内容 ：{ 内容满足时执行; [break;] } case 内容 ：{ 内容满足时执行;
JAVA8~17新特性
weixin_72388638的博客
07-12 835
你还会继续使用java8吗？
JavaSE学习笔记——Java8-17新特性
hongjianxiang的博客
03-06 287
Java学习笔记之Java新特性
Java 8 要过时了？从JDK8飞升到JDK17，一次性给你讲明白
yygr的博客
12-02 6646
这么多新版本的 JDK，而且2022年还会推出 JDK 18 和 JDK 19，为什么 Spring 选择了 JDK 17呢。主要是因为他是一个 Oracle官宣可以免费商用的LTS版本，所谓 LTS，是 Long Term Support，也就是官方保证会长期支持的版本。上面这张图是 Oracle 官方给出的 Oracle JDK 支持的时间线。可以看得到，JDK 17 最多可以支持到 2029 年 9 月份。
Java8-17新特征总结
木子Teng的博客
08-20 553
Java8-17新特征
JDK8-17新特性
最新发布
m0_50460160的博客
06-15 379
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码(将代码像数据一样进行传递)。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。如果接口中只声明一个抽象方法，则此接口称为函数式接口；因为只有给函数式接口提供实现类的对象时才可以使用lambda表达式;有形参，返回值是boolean的结果。有形参，但是返回值为void。lambda表达式是一个。lambda表达式作为。
Java 开发工具 JDK8 和 JDK17 介绍及安装 (超级详细)
qq_63519395的博客
05-08 6534
JDK 17 和 JDK 8
信息量留存蚁群遗传算法：优化求解的新策略
"利用信息量留存的蚁群遗传算法是一种结合了蚁群算法与遗传算法的混合优化方法，旨在提高算法的收敛速度和避免过早收敛。该算法首先将问题空间划分为多个子空间，并在这些子空间中均匀选取初始种群，确保种群的多样...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Aayasu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值