Java进阶 1-3 枚举（switch的新特性）

已于 2024-01-10 17:11:23 修改
阅读量3.4k 收藏 22
点赞数 23
分类专栏： Java 文章标签： java
于 2024-01-10 15:28:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w_pab/article/details/135390867
版权

目录

新特性：switch的箭头语法

新特性：switch中的case null

新特性：将switch作为表达式使用

在枚举中的实际应用

新特性：模式匹配

智能转型

模式匹配

违反里式替换原则

守卫

支配

sealed的使用

本笔记参考自： 《On Java 中文版》

        在Java中，“模式匹配”经历过好几个版本的功能扩充。这些扩充和switch关键字密切相关。如果对Java最新的特性感兴趣，可以查看Java增强建议（JEP）。

新特性：switch的箭头语法

        switch的箭头语法在JDK 14加入到了Java之中。现在，我们可以通过这种新的语法来使用switch：

【例子：新的switch语句】

import static java.util.stream.IntStream.range;

public class ArrowInSwitch {
    static void arrows(int i) {
        switch (i) {
            case 1 -> System.out.println("......"); // 可以是一条语句
            case 2 -> { // 也可以是语句块
                // ...
            }
            default -> System.out.println();
        }
    }

    public static void main(String[] args) {
        range(0, 4).forEach(i -> arrows(i));
    }
}

        这种语法与传统的switch语法的一个区别在于，它舍弃了原本需要写在每个case后面的break。这使得句式整体看上去更加简洁了。

        注意：不能在同一个switch中同时使用冒号和箭头。

新特性：switch中的case null

        JDK 17的一项预览功能，允许我们在switch语句中使用case null（这原本是非法的）。

import java.util.function.Consumer;

public class CaseNull {
    // 原本只能先进行非空判断：
    static void old(String s) {
        if (s == null) {
            System.out.println("null");
            return;
        }

        switch (s) {
            case "X" -> System.out.println("X");
            default -> System.out.println("default");
        }
    }

    // 预览功能允许我们在switch语句中为null新增一条分支语句
    static void checkNull(String s) {
        switch (s) {
            case "X" -> System.out.println("X");
            case null -> System.out.println("null");
            default -> System.out.println("default");
        }

        // 冒号语法也可以使用null了：
        switch (s) {
            case "X":
                System.out.println("X");
                break;
            case null:
                System.out.println("null");
                break;
            default:
                System.out.println("default");
        }
    }

    // 用于测试：
    static void test(Consumer<String> cs) {
        cs.accept("X");
        cs.accept("Y");
        try {
            cs.accept(null);
        } catch (NullPointerException e) {
            System.out.println(e.getMessage());
        }
    }

    public static void main(String[] args) {
        test(CaseNull::old);
        test(CaseNull::checkNull);
    }
}

        程序执行的结果是：

        由于在JDK 17时该功能还是预览状态（JDK 21时已经成为正式特性，见JEP 441），因此若使用的是JDK 17，需要在编译时添加以下选项：

 --enable-preview -source 17

        值得一提的是，default并不会覆盖null这一情况，因此下面的方法在使用时可能引发报错：

static void defaultOnly(String s) {
    switch (s) {
        case "X" -> System.out.println("X");
        default -> System.out.println("default");
    }
}

        可以使用例子中的test()方法对其进行测试，会得到如下结果：

    switch无法如其设计时预计的那样覆盖所有的可能值，这是Java为了向后兼容做出的让步。

        除此之外，switch语句还支持通过逗号合并多种模式。这意味着我们可以做到合并null和default，这样就不会出现上面的这种报错了：

case null, default -> System.out.println("null|default");

        JDK 21对这一特性进行了些许调整，因此下面的语句在JDK 21中是不合法的（或许是处于安全性的考虑）：

新特性：将switch作为表达式使用

        JDK 14添加的这项新功能，允许我们将switch作为表达式使用。现在，switch语句也可以返回值了：

【例子：有返回值的switch语句】

public class SwitchExpression {
    static int colon(String s) {
        var result = switch (s) {
            case "i":
                yield 1;
            case "j":
                yield 2;
            case "k":
                yield 3;
            default:
                yield 0;
        };

        return result;
    }

    static int arrow(String s) {
        var result = switch (s) {
            case "i" -> 1;
            case "j" -> 2;
            case "k" -> 3;
            default -> 0;
        };

        return result;
    }

    public static void main(String[] args) {
        for (var s : new String[]{"i", "j", "k", "z"})
            System.out.format(
                    "%s %d %d%n", s, colon(s), arrow(s));
    }
}

        程序执行的结果是：

        如例子所示，现在我们可以通过yield关键字从switch语句中返回一个值。需要注意一点，break不能和yield并用。这是合理的，因为可以假定，当我们使用yield的时候，一定存在一个需要返回值的变量。

        不过yield不能这样用：

很显然，yield必须存在于case语句中。

        一个case想要包含多条语句，就需要使用大括号。在此之上，若需要返回值，那么即使使用箭头语法，我们也需要在case语句中添加yield。像这样：

在枚举中的实际应用

        之前也曾举过“信号灯”的例子（笔记 1-1），现在我们可以使用表达式的形式重写一遍之前的代码：

【例子：重写“信号灯”变化】

public class EnumSwitch {
    enum Signal {
        GREEN,
        YELLOW,
        RED
    }

    static Signal color = Signal.RED;

    public static void change() {
        color = switch (color) {
            case RED -> Signal.GREEN;
            case GREEN -> Signal.YELLOW;
            case YELLOW -> Signal.RED;
        };
    }

    public static void main(String[] args) {
        for (int i = 0; i < 7; i++) {
            change();
            System.out.println(color);
        }
    }
}

        程序执行的结果是：

        编译器会对使用了枚举的switch进行检测。因此若我们没有考虑某条路径，编译器就会报错：

因此，使用枚举可以使我们的switch语句更加安全。

新特性：模式匹配

        JEP 394对instanceof的功能进行了增强。虽说官方的名称是“instanceof的模式匹配”，但更准确的说法应该是“模式匹配辅助”。

智能转型

        下面的例子将要展示的，是其中用于支持模式匹配的一个特性，它在其他的一些语言中被称为“智能转型”。

【例子：用于支持模式匹配的特性】

public class SmartCasting {
    // 旧的写法：
    static void dumb(Object x) {
        if (x instanceof String) {
            String s = (String) x;
            if (s.length() > 0) {
                System.out.format(
                        "%d %s%n", s.length(), s.toUpperCase());
            }
        }
    }

    // 新的写法（省略了类型转换）：
    static void smart(Object x) {
        if (x instanceof String s && s.length() > 0) {
            System.out.format(
                    "%d %s%n", s.length(), s.toUpperCase());
        }
    }

    // 错误的写法：
    static void wrong(Object x) {
        // 在这里，“或”这一逻辑并不成立
        // 编译器不允许这一写法，因此s会被视作无法解析的符号
        // if (x instanceof String s || s.length() > 0) {
        // }
    }

    public static void main(String[] args) {
        dumb("dumb");
        smart("smart");
    }
}

        程序执行的结果是：

        smart()展示了这一特性的实际应用：一旦确定了类型，我们就可以跳过转型的步骤。在这里，x instanceof String s会自动为我们创建一个新的变量s（s的正式名称应该是【模式变量】）。

    这个特性可以被作为模式匹配的构建块使用。

        还需注意一点，模式变量的作用域与一般而言的作用域并不完全重合。JEP 394中说明，模式变量的作用域设计来自于流的概念，只有当编译器确定该变量能够被安全赋值时，模式变量才会成立（这也解释了为什么在上述例子中无法使用【||】，因为编译器无法保证程序能够运行到那里）。

        这个特性会导致一些看起来十分费解的极端情况：

【例子：奇怪的作用域范围】

public class OddScoping {
    static void f(Object o) {
        if (!(o instanceof String s)){
            System.out.println("这个变量不是String类型");
            throw new RuntimeException();
        }

        // s在（看起来）超出作用域的地方发挥了它的作用
        System.out.println(s.toUpperCase());
    }

    public static void main(String[] args) {
        f("Ab aB");
        f(null);
    }
}

        程序执行的结果是：

        如果不抛出异常，就会引发报错：

        若不抛出异常，就意味着当if语句内部处理完类型不匹配的情况后，程序将会调用类型未知的变量s。编译器无法保证变量s的类型，因此此处的s实际上无法被使用。

    因此，也可能会因为这个特性的使用而造成一些费解的Bug。

模式匹配

        正如之前所述，“智能替换”是为模式匹配服务的。与继承的多态类似，模式匹配也能够实现基于类型的行为。但与继承不同的是，模式匹配不会要求所有的类型具有相同的接口，或是处于相同的继承结构中。

违反里式替换原则

||| 里式替换原则：所有引用基类的地方必须能透明地使用其子类的对象。

        在里式替换原则中，子类全部具有相同相同的基类，并且只会使用公共基类中定义的方法。例如：

【例子：遵守里式替换原则的情况】

        该例子在JDK 17时还处于预览模式，但JDK 21时已经成为正式特性。

import java.util.stream.Stream;

// 符合里式替换原则：子类和接口拥有的方法完全一致
// 定义一个接口：生命具有的行为
interface LifeForm {
    String move();

    String react();
}

// 子类：蠕虫
class Worm implements LifeForm {
    @Override
    public String move() {
        return "Worm::move()";
    }

    @Override
    public String react() {
        return "Worm::react()";
    }
}

// 子类：长颈鹿
class Giraffe implements LifeForm {
    @Override
    public String move() {
        return "Giraffe::move()";
    }

    @Override
    public String react() {
        return "Giraffe::react()";
    }
}

public class NormalLiskov {
    public static void main(String[] args) {
        Stream.of(new Worm(), new Giraffe())
                .forEach(lifeForm -> System.out.println(
                        lifeForm.move() + " " + lifeForm.react()));
    }
}

        程序执行的结果是：

        这种做法存在一个漏洞：“蠕虫”和“长颈鹿”终究是不同的生物。它们独特的行为（像蠕虫的爬行或长颈鹿的奔跑）难以在基类中进行描述。

    Java的集合库就遇到了这样的问题，他们的解决方式是添加一些“可选”的方法，让子类自行决定是否实现（然而，最终得到的成果并不尽人意）。

        当然，在实际使用Java中可以发现，Java也会允许我们写出如下的这种代码：

【例子：在继承结构中扩展子类】

public class Pet {
    void feed() {
    }
}

class Dog extends Pet {
    void walk() {
    }
}

class Fish extends Pet {
    void changeWater() {
    }
}

        这种程序的设计思路来源于SmallTalk：利用已有的类增加方法，实现代码的复用。然而，这种借鉴是存在局限性的，因为Java是一门基于静态类型的语言，而SmallTalk是动态的。

    SmallTalk具有动态类型检查，这意味着在进行类型相关的一些操作时，SmallTalk更不容易引发安全问题。

        模式匹配的存在允许Java编写出违反里式替换原则，并且更加安全的代码。下面的例子会为每一个可能的类型进行检测，并且进行不同的处理：

【例子：更加安全的模式匹配】

import java.util.List;

public class PetPatternMatch {
    static void careFor(Pet p) {
        switch (p) { // 选择器表达式p
            case Dog dog -> dog.walk();
            case Fish fish -> fish.changeWater();
            // case Pet必须存在，用于覆盖所有的可能值
            case Pet sp -> sp.feed();
        }
    }

    static void petCare() {
        List.of(new Dog(), new Fish())
                .forEach(p -> careFor(p));
    }
}

        语句switch p中的p被称为选择器表达式。

        在模式匹配出现之前，switch语句只接受基本类型和对应的包装类。换言之，模式匹配扩展了switch语句可以持有的类型范围。

    这种做法和动态绑定的不同之处在于，switch将对不同类型的操作交由case语句处理。

        事实上，在上面的例子中关于基类Pet的case语句（case Pet）并不是必要的。为了安全性，编译器会要求我们使用Pet覆盖所有的可能值。如果要解释这种行为，是因为Pet也可能被其他的文件使用，甚至在其他文件中存在未知的子类。

        换言之，我们可以密封基类接口（使用sealed关键字做到这一点），来证明其的安全性：

【例子：通过密封接口优化程序】

import java.util.List;

// 密封的接口：
sealed interface Pet {
    void feed();
}

final class Dog implements Pet {
    @Override
    public void feed() {
    }

    void walk() {
    }
}

final class Fish implements Pet {
    @Override
    public void feed() {
    }

    void changeWater() {
    }
}

public class PetPatternMatch2 {
    static void careFor(Pet p) {
        // sealed关键字可以确保Pet接口只在本文件内使用
        // 因此可以保证不会出现未发现的Pet子类
        switch (p) {
            case Dog d -> d.walk();
            case Fish f -> f.changeWater();
        }
    }

    static void petCare() {
        List.of(new Dog(), new Fish())
                .forEach(p -> careFor(p));
    }
}

        由于模式匹配并不受到继承结构的束缚，因此我们可以做到这种事：

【例子：传入不同的类型】

import java.util.List;

// 使用record关键字生成类：
record XX() {
}

public class ObjectMatch {
    // 使用Object作为参数
    static String match(Object o) {
        return switch (o) {
            case Dog d -> "是只狗";
            case Fish f -> "是条鱼";
            case Pet sp -> "既不是狗，也不是鱼";
            case String s -> "String：" + s;
            case Integer i -> "Integer：" + i;
            case String[] sa -> String.join("，", sa);
            case XX xx -> "XX：" + xx;
            case null, default -> "剩下的东西";
        };
    }

    public static void main(String[] args) {
        List.of(new Dog(), new Fish(), new Pet(),
                        "句子", Integer.valueOf(3),
                        Double.valueOf("1.145"),
                        new String[]{"黑", "化", "肥"},
                        new XX())
                .forEach(s -> System.out.println(match(s)));
    }
}

        程序执行的结果是：

        不过，如果使用Object作为switch的选择器表达式，编译器会强制要求我们使用default覆盖所有可能值。

守卫

        守卫用于细化匹配条件，使得switch语句不再只是匹配类型这么简单。要完成一次模式匹配，首先需要满足case对于类型的限制，然后再满足守卫条件。守卫可以是任何布尔表达式，它通过when关键字和case的类型判断相连接：

【例子：使用守卫进行精细的匹配】

        同样的，这个特性也是JDK 17中的预览特性，在JDK 21中实现时有了细微的调整（原本使用&&连接守卫条件，但现在改成了when）。

import java.util.List;

sealed interface Shape {
    double area();
}

record Circle(double radius) implements Shape {
    @Override
    public double area() {
        return Math.PI * radius * radius;
    }
}

record Rectangle(double side1, double side2)
        implements Shape {
    @Override
    public double area() {
        return side1 * side2;
    }
}

public class Shapes {
    static void classify(Shape s) {
        System.out.println(
                switch (s) {
                    case Circle c when c.area() < 100.0 
                            -> "小的圆形：" + c;
                    case Circle c 
                            -> "大的圆形：" + c;
                    case Rectangle r when r.side1() == r.side2() 
                            -> "正方形：" + r;
                    case Rectangle r 
                            -> "长方形：" + r;
                });
    }

    public static void main(String[] args) {
        List.of(
                new Circle(5.0),
                new Circle(25.0),
                new Rectangle(12.0, 12.0),
                new Rectangle(12.0, 15.0)
        ).forEach(t -> classify(t));
    }
}

        程序执行的结果是：

        我们还可以编写更为复杂的守卫条件：

case Circle c when 
        c.area() > 20.0 &&
        c.area() < 100.0 -> c;

在这个特性还是预览状态的时候，我们需要使用圆括号将复杂的守卫条件括起来。不过在实装的时候，这些都不需要了。

支配

        在switch中，case语句的顺序很重要。若基类的case出现在更前面，子类的case就不会有机会被执行。此时基类支配了子类：

        特别是在使用守卫的时候，顺序会变得更加敏感。尽管编译器能够对类型的支配性做出反映，但它无法判断出现在守卫条件中的逻辑错误。

    若在同一个模式上有多个守卫，那么更具体的模式必须出现在更加泛化的模式之前。

        下面的例子展示了当守卫条件中存在逻辑错误时会发生什么：

【例子：有问题的守卫条件】

import java.util.List;

record Person(String name, int age) {
}

public class People {
    static String categorize(Person person) {
        return switch (person) {
            case Person p when p.age() > 40
                    -> p + "处于中年";
            case Person p when
                    p.name().contains("D") || p.age() == 14
                    -> p + "名字中有D，或者年龄是14";
            case Person p when p.age() >= 100 // 注意这个守卫条件，它被p.age() > 40支配了
                    -> p + "年龄已经超过了一个世纪";
            case Person p
                    -> p + "是其他的人";
        };
    }

    public static void main(String[] args) {
        List.of(
                new Person("A", 15),
                new Person("D", 42),
                new Person("BC", 14),
                new Person("E", 1),
                new Person("F", 101)

        ).forEach(p -> System.out.println(categorize(p)));
    }
}

        程序执行的结果是：

        很显然，下面的语句并不可达：

case Person p when p.age() >= 100

这条语句已经被第一个case的守卫条件支配了。

sealed的使用

        在之前的例子中，sealed关键字的出现十分频繁。对于模式匹配而言，sealed是一个很好的辅助，因为其自动生成的代码就是final的。正如下面的这个例子一样：

【例子：sealed的使用】

import java.util.List;

sealed interface Transport {
};

record Bicycle(String id) implements Transport {
};

record Glider(int size) implements Transport {
};

record Surfboard(double weight) implements Transport {
};

// 编译器会检测类型，因此若有类型未被包含在模式匹配中，编译器就会报错
// record Skis(int length) implements Transport {
// };

public class SealedPatternMatch {
    static String exhaustive(Transport t) {
        return switch (t) {
            case Bicycle b -> "Bicycle " + b.id();
            case Glider g -> "Glider" + g.size();
            case Surfboard s -> "Surfboard" + s.weight();
        };
    }
}

         然而，编译器不会检测null。这是Java为了兼容旧的switch代码做出的调整。

Java进阶 1-2 枚举
w_pab的博客
01-04 1202
常量特定方法 职责链模式的枚举实现 状态机模式的枚举实现 多路分发 1、使用枚举类型实现分发 2、使用常量特定方法实现分发 3、使用EnumMap实现分发 4、使用二维数组实现分发
Java进阶学习笔记20——枚举
CCH2024的专栏
05-26 246
Java进阶学习笔记
Java枚举类型在switch语句正确使用方法详解
08-18
主要介绍了Java枚举类型在switch语句正确使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java中switch枚举类型enum的用法
DreamDlee的博客
05-13 2896
语句和枚举类型是 Java 编程中一种常见的编程模式。它能够提高代码的类型安全性、可读性、扩展性和可维护性，使得代码更加清晰、易懂和易于维护。枚举类型是一种特殊的类，用于表示一组固定的常量值。同时，枚举类型的常量值在代码中直观易懂，使得代码更加易读和易于维护。语句是一种常用的控制流程语句，用于根据表达式的值选择执行不同的代码块。枚举类型的参数，然后根据不同的颜色常量值执行不同的代码块。枚举类型中添加一个新的常量即可，而不需要修改已有的代码。语句和枚举类型，可以使代码更加清晰、易读和类型安全。
Java switch 大升级！告别 break 和穿透 Bug，代码更简洁安全
最新发布
郑龙飞
05-01 579
现在，你可以将分支逻辑更优雅地嵌入到 Stream API、Optional 链式调用以及各种数据转换操作中，代码更加整洁。表达式（从 Java 14 开始引入，Java 12 是预览版）以及后续版本中增强的。返回一个值，而不是退出包含它的方法。这是一个需要用到分支逻辑的典型例子。当逻辑比较复杂，需要在代码块里执行多条语句时，就用。包裹），并且你希望从这个代码块中返回一个值时，你就。表达式经历了一次超给力的进化！功能，为我们日常的决策逻辑带来了前所未有的。• 返回的是一个（通常是）不可变的值。
Java_笔记_switch新特性
SisinRyu的博客
10-17 235
Java_笔记_switch新特性
Java枚举与Switch
随便写写
12-27 532
/** * @Author Tiam * @Date 2021/12/27 18:00 * @Description: 枚举类的使用 */ public enum Enum_ { //注意分割符,最后一个以分号结尾. MONDAY("星期一"), TUESDAY("星期二"), WEDNESDAY("星期三"), THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六"), SUNDAY("星期日");
java中的枚举用法，枚举中switch、方法使用
张刚的博客
01-09 1147
java中枚举写法和应用场景 枚举中方法的使用 枚举中switch的用法
Java进阶高手课-Java基础编程提升
06-20
"Java进阶高手课-Java基础编程提升"这个课程旨在帮助开发者深化对Java基础知识的理解，并通过实际项目实战提升编程技能。在这个课程中，你将深入探讨以下关键知识点： 1. **Java语法基础**：包括数据类型（如基本...
Java基础进阶系列-03之JMH分析if条件判断语句与switch性能差异
IceStreamLab
10-11 1039
文章目录背景说明JMH 微基准测试 验证性能效率引入依赖场景代入测试代码重构一，try{}catch()重构二，使用guava重构三，静态Map索引 解决问题的本质就是回归源码和阅读说明文档 背景说明 我们知道switch-case结构，当case值是“密集”时，底层指令会优化为tableswitch结构，执行效率上要比“稀疏”时的lookupswitch好。 Java 虚拟机规范 基于JDK8->3.10 编译switch章节 编译器会使用tableswitch和lookupswitch指令来生成
：实用 FRIDA 进阶 --- objection ：内存漫游、hook anywhere、抓包
墨鱼菜鸡
07-11 4987
转载：实用FRIDA进阶：内存漫游、hook anywhere、抓包：https://www.anquanke.com/post/id/197657 frida github 地址：https://github.com/frida/frida objection github：https://github.com/sensepost/objection...
枚举类型在switch语句中的用法
06-21
枚举类型在switch语句中的用法枚举类型在switch语句中的用法
Java的switch枚举使用
Daylight629博客
11-21 1295
【代码】Java的switch枚举使用。
「Java基础入门」Java中switch怎么使用枚举
BASK2312的博客
06-06 5879
在Java开发中，switch语句是一种常用的流控制语句，用于根据不同的条件执行不同的代码块。因此，熟练掌握枚举类型的相关操作，是我们开发高效、优质代码所必不可少的基本技能。希望大家能够通过学习和实践，巩固这些基础知识，并在日常工作中充分发挥它们的应用价值，为自己的开发工作提升整体效率与质量。针对这个问题，我们可以按照上述方法进行处理，将枚举的值转化成枚举类型，来避免编译错误。看上去没有问题，但是因为switch中需要的是一个常量，但是枚举中又是不可以加final关键字，所以会出现这种情况：（
【java12】java12新特性之switch表达式
热门推荐
morris
07-02 1万+
Java12引入了对switch语句的增强，允许在switch语句中使用表达式来代替传统的语句列表。这样可以使得代码更加简洁和易读。switch表达式也是作为预览语言功能的第一个语言改动被引入新版Java中来的，这是一种引入新特性的测试版的方法。通过这种方式，能够根据用户反馈进行升级、更改，如果没有被很好的接纳，则可以完全删除该功能。预览功能的没有被包含在JavaSE规范中。也就是说：这不是一个正式的语法，是暂时进行测试的一种语法。
Java的Switch的新特性
weixin_50083448的博客
09-12 298
介绍java语言下switch的最新写法
Java7 switch新特性
weixin_30739595的博客
03-26 109
在Java7之前，switch只能匹配整数值，和字符；而Java7添加了字符串的匹配特性。 代码如下： 1 package blog; 2 3 4 public class Main { 5 public static void show(String str) { 6 switch (str) { 7 ca...
Java switch-case扩展 (case穿透、JDK12 switch新特性)
weixin_52337823的博客
06-26 777
case穿透是指在switch-case中，执行完当前case语句，因为省略了break语句，导致无法跳出switch，所以继续向下执行下一条case语句的情况。对switch的语法进行了扩展，这个特性可以大大简化代码，并且避免因为遗忘break语句引发bug。
Java 枚举 结合switch的用法
扛麻袋的少年的博客
08-28 8039
因有个判断需要处理不同系统类型跳转不同 系统。 考虑用switch + 枚举的方式。 具体使用案例如下： package com.b2b.common.constant; import com.base.utils.base.StringUtils; /** * 系统类型枚举 * @author shijing */ public enum SystemType { ERP(0,"ERP"), ORDER_PLATFORM(1,"订货平台"), PERSONAL(
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值