内部类- Lambda表达式

最新推荐文章于 2024-05-11 02:58:39 发布
最新推荐文章于 2024-05-11 02:58:39 发布
阅读量159 收藏
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liang1009/article/details/132005733
版权

1.内部类

1.1 内部类-成员内部类【了解】

1.什么是内部类

在一个类中定义一个类。

举例：在一个类A的内部定义一个类B，类B就被称为内部类

2 如何定义一个内部类

  • 格式&举例：

/*
	格式：
    class 外部类名{
    	修饰符 class 内部类名{
    	
    	}
    }
*/

class Outer {
    public class Inner {
        
    }
}

3 内部类的分类

  • 在类的成员位置:成员内部类

  • 在类方法内位置:局部内部类(后面说)

4 外部如何使用普通成员内部类？

格式:外部类名.内部类名 对象名=new 外部对象().new 内部对象()

范例: Outer.Inner oi=new Outer().new Inter();

package com.itheima.test1;
class Outer {

    private int a = 10;

    class Inner {
        int num = 10;

        public void show(){
            System.out.println("Inner..show");
            // 内部类, 访问外部类成员, 可以直接访问, 包括私有
            System.out.println(a);
        }
    }
}

5 成员内部类的访问非静态成员时有什么特点 ？

  1. 内部类可以直接访问外部类的成员，包括私有

  2. 外部类要访问内部类的成员，必须创建对象

package com.itheima.test1;

public class Test1Inner {
    public static void main(String[] args) {
        /*
            创建内部类对象的格式:

                外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();
         */
        Outer.Inner i = new Outer().new Inner();
        System.out.println(i.num);
        i.show();
    }
}

class Outer {

    private int a = 10;
	
    class Inner {
        int num = 10;

        public void show(){
            System.out.println("Inner..show");
            // 内部类, 访问外部类成员, 可以直接访问, 包括私有
            System.out.println(a);
        }
    }
}

1.2 私有成员内部类-静态成员内部类【了解】

1 私有成员内部类的访问特点？

只能在自己所在的外部类中创建对象访问

示例代码：

package com.itheima.test2;

public class Test2Innerclass {
    /*
        私有成员内部类演示
     */
    public static void main(String[] args) {
        // Outer.Inner oi = new Outer().new Inner();//不能在外界进行访问

        Outer o = new Outer();
        o.method();
    }
}

class Outer {
    private class Inner {
        public void show(){
            System.out.println("inner..show");
        }
    }

    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

2 如何创建静态成员内部类对象？

外部类名.内部类名 对象名 = new 外部类名.内部类名();

3.如何访问静态成员内部类中的静态方法？

外部类名.内部类名.方法名();

示例代码

package com.itheima.test3;

public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

1.3 局部内部类【了解】

1.什么是局部内部类

在方法中定义的类

2.局部内部类如何使用？

局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

3.局部内部类的特点

  1. 局部内部类是在方法中定义的类

  2. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

示例代码

package com.itheima.test4;

public class Test4Innerclass {
    /*
        局部内部类:

            编写位置: 方法中
            访问方式: 只能在方法中, 创建对象并访问
     */
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer {

    int a = 10;

    public void method(){

        int b = 20;

        class Inner {
            public void show(){
                System.out.println("show...");
                System.out.println(a);
                System.out.println(b);
            }
        }

        Inner i = new Inner();
        i.show();

    }

}

1.4 匿名内部类【重点】

1.什么是匿名内部类？

特殊的局部内部类

2 匿名内部类的前提

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

3 如何使用匿名内部类？

  • 格式：new 类名 ( ) { 重写方法 }

  • new 接口名 ( ) { 实现方法 }

  • 举例：

new Inter(){
    @Override
    public void method(){}
}

4 匿名内部类的本质

本质：是一个继承了该类或者实现了该接口的子类匿名对象

理解 : 匿名内部类是将(继承\实现)(方法重写)(创建对象)三个步骤,放在了一步进行

package com.itheima.test5;

public class Test5Innerclass {
    /*
        1. 创建实现类, 通过implements关键字去实现接口
        2. 重写方法
        3. 创建实现类对象
        4. 调用重写后的方法.

        匿名内部类:

            前提: 需要存在类\接口
            格式:
                    new 类名 \ 接口名 (){
                        重写方法
                    }
     */
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.show();

        // 匿名内部类的理解: 将继承\实现, 方法重写, 创建对象, 放在了一步进行.
        // 解释: 实现了Inter接口的, 一个实现类对象.
        new Inter() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类中的show方法");
            }
        }.show();

        // 情况: 接口中存在多个方法
        Inter2 i = new Inter2() {
            @Override
            public void show1() {
                System.out.println("show1...");
            }

            @Override
            public void show2() {
                System.out.println("show2...");
            }
        };

        i.show1();
        i.show2();
    }
}

interface Inter {
    void show();
}

interface Inter2 {
    void show1();
    void show2();
}

class InterImpl implements Inter {

    @Override
    public void show() {
        System.out.println("InterImpl  重写的show方法");
    }
}

1.5 匿名内部类的应用场景【重点】

  • 匿名内部类在开发中的使用

    当某个方法的参数类型是一个接口或抽象类 类型

    示例代码：

package com.itheima.test6;

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swim = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("铁汁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

小结

1.什么是内部类

在一个类中定义一个类

2.内部类的分类？

成员内部类和局部内部类

3.如何使用成员内部类？

格式:外部类名.内部类名 对象名=new 外部对象().new内部对象()

范例: Outer.Inner oi=new Outer().new Inter();

4. 成员内部类的访问时有什么特点 ？

  1. 内部类可以直接访问外部类的成员，包括私有

  2. 外部类要访问内部类的非静态成员，必须创建对象

5.私有成员内部类的访问特点？

只能在自己所在的外部类中创建对象访问

6.如何创建静态成员内部类对象？

外部类名.内部类名 对象名 = new 外部类名.内部类名();

7.如何访问静态成员内部类中的静态方法？

静态成员内部类中的静态方法：外部类名.内部类名.方法名();

8.局部内部类的使用方式

  • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用

9.局部内部类的特点

  1. 局部内部类是在方法中定义的类

  2. 该类可以直接访问外部类的成员，也可以访问方法内的局部变量

10.什么是匿名内部类？

没有显式的名字的内部类

11 匿名内部类的前提

存在一个类或者接口，这里的类可以是具体类也可以是抽象类

12 如何使用匿名内部类？

格式：new 类名 ( ) { 重写方法 } new 接口名 ( ) { 重写方法 }

13. 匿名内部类的理解

是一个继承了该类或者实现了该接口的子类匿名对象

14.匿名内部类的应用场景？

当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去，来简化传统的代码

2.Lambda表达式

2.1 Lambda表达式初体验和函数式编程思想【了解】

1.什么是函数式编程的思想？

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

而我们要学习的Lambda表达式就是函数式思想的体现

2.面向对象思想和函数式编程思想对比

面向对象思想强调“必须通过对象的形式来做事情”

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

  • 代码演示

package com.itheima.test1;

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
  }
}

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

2.2Lambda表达式的格式说明和前提条件【重点】

1 Lambda表达式的前提条件

有一个接口，接口中只能有一个抽象方法

2 如何使用Lambda表达式？

  • 组成Lambda表达式的三要素：

形式参数，箭头，代码块

(形式参数) -> {代码块}

  1. 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

  2. ->：由英文中画线和大于符号组成，固定写法。代表指向动作

  3. 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

3 Lambda表达式练习1【应用】

  • 练习描述

    无参无返回值抽象方法的练习

    示例代码

package com.itheima.test2;

public class TestLambda {
    /*
        Lambda表达式的使用前提
            1. 一个接口
            2. 接口中有且仅有一个抽象方法

        练习1：
            1. 编写一个接口（ShowHandler）
            2. 在该接口中存在一个抽象方法（show），该方法是无参数无返回值
            3. 在测试类（ShowHandlerDemo）中存在一个方法（useShowHandler）
                        方法的的参数是ShowHandler类型的
                        在方法内部调用了ShowHandler的show方法
     */
    public static void main(String[] args) {
        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类中的show方法");
            }
        });

        // Lambda实现
        useShowHandler( () -> System.out.println("我是Lambda中的show方法"));
    }

    public static void useShowHandler(ShowHandler showHandler){
        showHandler.show();
    }

}

interface ShowHandler {
    void show();
}

2.3 有参无返回值的Labmda表达式【应用】

package com.itheima.test3;

public class StringHandlerDemo {
    /*
        1.首先存在一个接口（StringHandler）
        2.在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
        3.在测试类（StringHandlerDemo）中存在一个方法（useStringHandler）
                方法的的参数是StringHandler类型的
                在方法内部调用了StringHandler的printMessage方法
     */
    public static void main(String[] args) {
        useStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println("我是匿名内部类" + msg);
            }
        });

        // Lambda实现
        useStringHandler( msg -> System.out.println("我是Lambda表达式" + msg));
    }

    public static void useStringHandler(StringHandler stringHandler){
        stringHandler.printMessage("itheima");
    }
}

interface StringHandler {
    void printMessage(String msg);
}

2.4Labmda表达式-无参数有返回值【应用】

package com.itheima.test4;
import java.util.Random;

public class RandomNumHandlerDemo {
    /*
        1. 首先存在一个接口（RandomNumHandler）
        2. 在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
        3. 在测试类（RandomNumHandlerDemo）中存在一个方法（useRandomNumHandler）
                方法的的参数是RandomNumHandler类型的
                在方法内部调用了RandomNumHandler的getNumber方法
     */
    public static void main(String[] args) {
        useRandomNumHandler(new RandomNumHandler() {
            @Override
            public int getNumber() {
                Random r = new Random();
                int num = r.nextInt(10) + 1;
                return num;
            }
        });

        useRandomNumHandler( () -> {
                Random r = new Random();
                int num = r.nextInt(10) + 1;
                return num;
                // 注意: 如果lambda所操作的接口中的方法, 有返回值, 一定要通过return语句, 将结果返回
                // 否则会出现编译错误
        } );
    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler){
        int result = randomNumHandler.getNumber();
        System.out.println(result);
    }
}

interface RandomNumHandler {
    int getNumber();
}

2.5Labmda表达式-带参数带返回值【应用】

package com.itheima.test5;

public class CalculatorDemo {
    /*
        1. 首先存在一个接口（Calculator）
        2. 在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
        3. 在测试类（CalculatorDemo）中存在一个方法（useCalculator）
            方法的的参数是Calculator类型的
            在方法内部调用了Calculator的calc方法

     */
    public static void main(String[] args) {
        useCalculator(new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });

        useCalculator( ( a,  b) -> {
            return a + b;
        });
    }

    public static void useCalculator(Calculator calculator){
        int result = calculator.calc(10,20);
        System.out.println(result);
    }
}

interface Calculator {
    int calc(int a, int b);
}

2.6Lambda表达式的省略模式【应用】

1.省略的规则

  • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个

  • 如果参数有且仅有一个，那么小括号可以省略

  • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字

代码演示

package com.itheima.test6;

public class Test6 {
  public static void main(String[] args) {
        /*useInter( (double a, double b) -> {
            return a + b;
        });*/

        useInter( (a,b) ->
                a + b
        );
    }

    public static void useInter(Inter i) {
        double result = i.method(12.3, 22.3);
        System.out.println(result);
    }

}

interface Inter {
    // 用于计算 a + b 的结果并返回
    double method(double a, double b);
}

2.7 Lambda表达式的应用场景

当某个方法的参数类型是一个接口或抽象类类型,并且接口或抽象类中只有一个抽象方法

2.8Lambda表达式和匿名内部类的区别【理解】

  • 所需类型不同

    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

    • Lambda表达式：只能是接口

  • 使用限制不同

    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

    • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

  • 实现原理不同

    • 匿名内部类：编译之后，产生一个单独的.class字节码文件

    • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

package com.itheima.test7;

public class Test {
    public static void main(String[] args) {

        // Lambda调用
        /*useInter(() ->
                System.out.println("Lambda执行了")
        );*/

        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类的show方法");
            }
        });

    }

    public static void useInter(Inter i) {
        i.show();
    }
}

interface Inter {
    void show();
}

小结

1.什么是函数式编程思想

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”

2.如何使用Lambda表达式？

  • 组成Lambda表达式的三要素：

形式参数，箭头，代码块

(形式参数) -> {代码块}

  1. 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可

  2. ->：由英文中画线和大于符号组成，固定写法。代表指向动作

  3. 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

3. Lambda表达式的前提条件

有一个接口，接口中只能有一个抽象方法

4.匿名内部类应用场景

当某个方法的参数类型是一个接口或抽象类类型,并且接口或抽象类中只有一个抽象方法

5.Lambda表达式和匿名内部类的区别

  • 所需类型不同

    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类

    • Lambda表达式：只能是接口

  • 使用限制不同

    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类

    • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

  • 实现原理不同

    • 匿名内部类：编译之后，产生一个单独的.class字节码文件

    • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

liang1009
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java8-lambda表达式的基础使用.pdf
07-05
Lambda 表达式是 Java 8 中的一种特殊的匿名内部类，它可以实现接口函数的实现。它的语法是由箭头(left)和逗号分隔的形式参数列表组成的，箭头左侧是函数的参数列表，箭头右侧是函数体代码。 在传统的开发方式下，...
内部类与Lambda表达式
白日梦
09-13 272
一、内部类 1.什么是内部类？ 1.类作为形参和返回值： 抽象类作为形参和返回值：通过多态的形式去传递抽象类作为形参的方法，方法的形参与返回值为抽象类名，则需要的是该抽象类的子类对象。 类名作为形参与返回值：方法的形参与返回值为类名时，则需要的是该类的对象。 接口名作为形参与返回值：方法的形参与返回值为接口名时，则需要的是该接口的实现类对象。 2.内部类的概述： 内部类里面访问特点是在外面的类需要访问里面类的时，是需要创建对象才能调用，里面的类则可以直接使用外面类的成员。 2.内部类的几种形
Java内部类 lambda
qq_36675713的博客
06-03 148
java内部类/嵌套类/lambda表达式
Java基础（9）——从匿名内部类 到 函数式编程Lamda表达式 &amp； List的函数式编程案例_匿名内部类转lambda表达式(1)
最新发布
2401_84562251的博客
05-11 463
FunctionalInterface 注解o1和o2是啥：Returns:a。
Java：Lambda简化匿名内部类
斯文~
06-08 1318
Java：Lambda简化匿名内部类 注意：Lambda表达式只能简化函数式接口的匿名内部类的写法形式什么是函数式接口？ 简化常见函数式接口 简化Comparator接口的匿名形式 Java Arrays类自定义排序
Java基础（13）内部类
敲代码的彭于晏
08-10 109
十三.内部类 一个类中的类被称为内部类 class Outer{ class Inner{//内部类 } } 一.成员内部类 了解 声明在类以内 方法以外的类被称为成员内部类 地位相当于成员变量 语法： class Outer{ int a; class Inner{} ...
Java中的内部类和Lambda表达式
weixin_48548208的博客
07-16 201
定义"在类内部的"的类放在方法内部的"内部类"放在类中方法外的"内部类"匿名内部类,就是"局部内部类"的简化格式new父类/父接口(){//重写方法}注意匿名内部类本质上是一个"实现类父类或父接口的子类的对象"Lambda表达式就是"匿名内部类"的简化格式.依据"可推断可省略"原则,进行优化....
内部类及lambda表达式的日常练习
05-29
在Java编程语言中，内部类和Lambda表达式是两种强大的特性，它们极大地提高了代码的可读性和简洁性。本文将详细探讨这两个主题，并通过提供的文件名列表中的示例代码进行练习解析。 首先，我们来讨论匿名内部类。...
Java Lambda表达式与匿名内部类的联系和区别实例分析
08-25
Java Lambda表达式与匿名内部类的联系和区别实例分析 Java Lambda表达式和匿名内部类是Java中两个重要的概念，它们都是用于实现函数式编程的方式，但它们之间存在一定的联系和区别。在本文中，我们将通过实例分析，...
05.第五节-lambda表达式语法的介绍.mp4
10-25
即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是依然使用匿名内部类解决。 本系列课程从Lambda表达式、方法的引用、Stream API三处着手...
day05_内部类和Lambda表达式.zip
09-12
在Java编程语言中，内部类和Lambda表达式是两种非常重要的高级特性，它们极大地提高了代码的简洁性和可读性。让我们深入探讨这两个概念。 首先，我们来看内部类。内部类，顾名思义，是在一个外部类（也称为外部或...
lambda表达式和 内部类
Carol__a的博客
02-22 564
1.为什么引入lambda表达式 lambda表达式是一个可传递的代码块，可以在以后执行一次或多次。能够让代码稍简洁一些。 2.lambda表达式的语法 lambda表达式形式： 参数，箭头（->） 一个表达式。如果代码要完成的计算无法放在一个表达式中，可以把代码放在{}中，并包含显式的return语句。 即使lambda表达式没有参数，仍然要提供空括号，就像无参方法一样： （）->{for (int i=100;i>=0;i--)System.out.println(i);.
Lambda表达式&内部类
Juli_Baker的博客
04-29 301
Lambda表达式和内部类 避免匿名内部类定义过多 让代码看起来更加简洁 函数式编程 总结 lambda表达式，只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包含； 前提是接口为函数式接口； 多个参数，也可以去掉参数类型，要去掉就都去掉，必须加上括号； 内部类 通过理解内部类的各种写法,来推导Lambda表达式 package DemoTherad.Demo04; //推导lamda表达式 public class TestLamda1 { //3.静态内部类 stat
工具技巧和读文档 | 读函数式编程接口文档 | 匿名内部类 | lambda表达式 |IDEA
你个无聊小demo的博客
01-28 819
工具技巧和读文档 | 读函数式编程接口文档 | 匿名内部类 | lambda表达式 |IDEA
分享一个idea生成lambda表达式的快捷键
qq_44060623的博客
01-14 9902
分享一个idea生成lambda表达式的快捷键 先编写匿名内部类 new Thread(new Runnable() { @Override public void run() { System.out.println(Thread.currentThread().getName()); } }).start(); 在new Runnable()的位置点alt+回车 选中即可自动将内部类转换成λ表达式,分享给和我一样不喜欢写λ表达式的小伙伴. ...
lambda和匿名内部类
xu147258peng的博客
08-17 764
在jdk8里面新加了一个lambda，其优点很多，主要是节约了代码，增加了可读性，它在很多方面和匿名内部类很相似，是高级语言的编写特征之一，结合匿名内部类讲解一下lambda的用法和特性；    注意点:               1.如果形参列表是空的，只需要保蜜()即可。               2.如果没有返回值，只需要在()写执行语句即可。               3.如果接口...
java基础--内部类和Lamda表达式
驰骋翱翔
11-05 1232
内部类是在java内部又定义的内部类，它最大的优势在于，它可以访问外部类所有的数据成员，但外部类不能访问内部类的私有成员，使用最多的是匿名内部类。java 8根据匿名为简化匿名内部类的写作习惯，提出了lamda表达式。
lambda（替代匿名类）
小彭的博客
11-03 6037
jdk1.8匿名内部类之前的写法public class Lambda { public static void main(String[] args) { //匿名内部类 School school = new School() { @Override public void run(String jdk) {
Lambda内部类的使用
爱折腾的Albert
02-21 722
1.1 匿名内部类 无参函数 jdk8之前 new Thread(new Runnable() { @Override public void run() { System.out.println("jdk8 之前"); } }).start(); 使用lambda new Thread(() -> System.out.println("jdk...
内部类lambda表达式 java
11-16
以下是Java中内部类和Lambda表达式的示例代码： 1. 内部类的示例代码： ```java public class OuterClass { private int x = 10; // 成员内部类 public class InnerClass { public void printX() { System....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值