Java复习笔记-12

最新推荐文章于 2024-11-07 13:06:59 发布
最新推荐文章于 2024-11-07 13:06:59 发布
阅读量40 收藏
点赞数
文章标签： java 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/puputt/article/details/132434144
版权

面向对象

类和接口强转问题

在java中，类和类之间如果有继承关系，那么就可以在编译阶段强转。在运行阶段需要类型必须匹配，否则抛出异常ClassCastException

在类和接口之间，在编译阶段java直接放弃检查，需要程序员自己判断。

public class TestDemo {
    public static void main(String[] args) {
        // 探讨引用数据类型强制类型转换的问题
        // 在Java中，类和类之间支持的是单继承
        // 因此可以形成一颗继承结构树
        // 所以比较容易确定两个类之间是否有继承关系
        A a = new B1();

        // 在编译期间会检查对象的声明类型和要强转的类型之间是否有继承关系
        // 在编译期间，a对象的声明类型是A类
        // a对象要强转的类型是B1，发现B1类和A类之间有继承关系.
        // 这里由于a对象的类型A类是B1的父类，所以需要强转才能编译通过
        // 在运行阶段，发现a的实际类型是B1，要强转的类型也是B1,类型匹配，可以强转。
//        B1 b1 = (B1) a;
//        System.out.println(b1);


        /*
        * a对象的声明类型是A类
        * 要强转的类型是B2，发现B2继承了A，所以编译阶段强转可以通过。
        * 到了运行阶段，发现a的实际类型是B1，要强转的类型是B2，所以类型不匹配，抛出异常，不可以强转。
        * */
//        B2 b2 = (B2) a;
        // ClassCastException:引用数据类型的类型转换异常
//        System.out.println(b2);

        // a对象在编译阶段的声明类型是A类，要强转的类型是C类。
        // A类和C类之间没有继承关系，所以编译不通过。
//        C c = (C)a;

        /*
        * 在Java中，因为接口之间是多继承以及多实现的。
        * 所以形成一个网状结构
        * 在编译期间，不容易确定两个节点之间是否有关系
        * java为了提高编译效率，在编译期间放弃检查
        * 也就意味着，在编译期间，任何一个接口都可以强转
        * */
        D d = (D)a;
        System.out.println(d);
    }
}


class A {
    int i = 10;
}

class B1 extends A{



}

class B2 extends A{

}

class C{

}

interface D{

}

1 接口的新特性

在jdk1.8之前，接口中全部都是抽象方法。jdk1.8之后可以有静态方法，默认方法，私有方法，私有静态方法。

@FunctionalInterface//函数式接口
public interface MyInterface {

    void update();


    default boolean defaultMethod1(){
        return true;
    }

    // jdk8中可以使用default修饰实体方法
    default void defaultMethod(){
        System.out.println("默认方法");
        // 调用私有方法
        this.privateMethod();
    }

    // jdk8中可以使用static修饰实体方法
    static void method(){
        System.out.println("static方法");
        MyInterface.privateStaticMethod();
    }

    // jdk9中可以定义私有的实体方法
    private void privateMethod(){
        System.out.println("私有的实体方法");
    }

    private static void privateStaticMethod(){
        System.out.println("私有的静态方法");
    }

}

2 lambda表达式

lambda表达式是JDK1.8之后的特性，要使用这个表达式，要求接口中只能有一个抽象方法。

可以使用@FunctionalInterface 来标记一个函数式接口。

//表示这个接口是一个函数式接口
// 这个注解表示这个接口中只能有一个抽象方法
    // 是一个标记注解(用不用都可以)
    // 如果一个接口中只有一个抽象方法，可以使用JDK1.8的特性-->lambda表达式
@FunctionalInterface
public interface MyInterface {

lambda表达式本质上是在替换匿名内部类的语法，让程序员编写代码更加简单。

lambda表示是面向函数式编程，面向接口中的那一个唯一的抽象方法编程

lambda表达式基本语法

(参数) -> {方法体}

lambda表达式可读性比较差

2.1 无参无返回值

@FunctionalInterface
public interface MyInterface {
    // 无参无返回值
    void hello();
}

public class TestDemo {

    public static void main(String[] args) {
        // 匿名内部类实际上是接口的实现类或者类的子类
//        MyInterface myInterface = new MyInterface() {// 匿名内部类 目前这个没有名字的类是MyInterface接口的实现类
            @Override
            public void hello() {
                System.out.println("hello...");
            }
        };
        myInterface.hello();
        // 使用lambda替换匿名内部类 -- 面向函数式编程 -- 面向接口中唯一的抽象方法编程
//        MyInterface myInterface = () -> {
//            System.out.println("hello...");
//        };
        // 方法体只有一行，可以省略{}
        MyInterface myInterface = () -> System.out.println("hello");
        myInterface.hello();
        demo(()-> System.out.println("hahaha"));
        demo(new MyInterfaceImpl());
    }
    
    public static MyInterface demo(MyInterface myInterface){
        
        return () -> System.out.println("111");
    }
}

2.2 有参无返回值

  • 参数只有一个
@FunctionalInterface
public interface MyInterface {
    // 无参无返回值
//    void hello();
    // 有参无返回值
    void compareStr(String str);
}

    private static void demo2() {
        // 匿名内部类
//        MyInterface myInterface = new MyInterface() {
//            @Override
//            public void compareStr(String str) {
//                System.out.println("hello".equals(str));
//            }
//        };
//
//        myInterface.compareStr("hell");
        // (参数) -> {方法体}
//        MyInterface myInterface = (String str) -> {
//            System.out.println("hello".equals(str));
//        };
        // 方法体只有一条语句，可以省略{}
//        MyInterface myInterface = (String str) -> System.out.println("hello".equals(str));
        // 如果形参只有一个，那么可以省略数据类型和()
        MyInterface myInterface = str -> System.out.println("hello".equals(str));
        myInterface.compareStr("hello");
    }
  • 参数有多个
@FunctionalInterface
public interface MyInterface {
    // 无参无返回值
//    void hello();
    // 有参无返回值
//    void compareStr(String str);
    void max(int num1,int num2);
}

    private static void demo3() {
        // 匿名内部类
//        MyInterface myInterface = new MyInterface() {
//            @Override
//            public void max(int num1, int num2) {
//                System.out.println("最大值是" + Math.max(num1,num2));
//            }
//        };

        // lambda表达式
//        MyInterface myInterface = (int num1,int num2) -> System.out.println("最大值是" + Math.max(num1,num2));
        // 如果形参数量大于1个，可以省略数据类型
        // 形参名可以随意起名
        MyInterface myInterface = (a,b) -> System.out.println("最大值是" + Math.max(a,b));
        myInterface.max(15,17);
    }

2.3 有参有返回值

@FunctionalInterface
public interface MyInterface {
    // 无参无返回值
//    void hello();
    // 有参无返回值
//    void compareStr(String str);
//    void max(int num1,int num2);

    // 有参有返回值
//    int add(int num1,int num2);
//    boolean compareStr(String str);

    // 定义一个方法，获得Teacher对象中的任意一个属性的数据
    Object getPropertyValue(Teacher teacher);
}

    private static void demo6() {
        // 匿名内部类
//        MyInterface myInterface = new MyInterface() {
//            @Override // Object o = teacher.getName();
//            public Object getPropertyValue(Teacher teacher) {
//                return teacher.getName();
//            }
//        };

        // lambda表达式
//        MyInterface myInterface = t->t.getName();

        MyInterface myInterface = Teacher::getName;
        Teacher teacher = new Teacher();
        teacher.setId(10);
        teacher.setName("冲田老师");
        System.out.println(myInterface.getPropertyValue(teacher));


    }

    private static void demo5() {
        // 匿名内部类
//        MyInterface myInterface = new MyInterface() {
//            @Override
//            public boolean compareStr(String str) {
//                return "hello".equals(str);
//            }
//        };
//        MyInterface myInterface = str->"hello".equals(str);
        // 使用  对象::方法名
//        MyInterface myInterface = "hello"::equals;
//        System.out.println(myInterface.compareStr(null));
    }

    private static void demo4() {
//        MyInterface myInterface = new MyInterface() {
//            @Override
//            public int add(int num1, int num2) {
//                return Integer.sum(num1,num2);
//            }
//        };

        // lambda表达式
//        MyInterface myInterface = (int a,int b) -> {
//            return a + b;
//        };
        // 方法体中有返回值类型，并且语句只有一行，可以省略{return}
        // 这种写法使用的比较多
//        MyInterface myInterface = (a,b) -> a + b;
        // 重写的方法的形参数量和类型以及返回值类型 与 要调用的方法的形参数量和类型和返回值类型一样，就可以使用下面的写法
        // lambda究极形态  数据类型::方法名
//        MyInterface myInterface = Integer::sum;// return Integer.sum(a,b);
//        // Integer是一个包装类 对应的基本数据类型是int
//        System.out.println(myInterface.add(1, 2));
    }

3 内部类

3.1 概述

将一个类写在其他类的内部，可以写在其他类的成员位置或者局部位置，这时写在其他类内部的类称之为内部类。其他类称之为外部类。

内部类分为:

  • 局部内部类/方法内部类
  • 成员内部类
  • 静态内部类
  • 匿名内部类(重要)

3.2 局部内部类

局部内部类也称之为方法内部类，它是定义在方法中的内部类。

public class TestDemo3 {
    public static void main(String[] args) {
        new Outer1().m();
    }
}

class Outer1{//外部类

    public void m(){
        System.out.println("Outer~~~");

        // 局部内部类/方法内部类
        class Inner1{

            public void m(){
                System.out.println("Inner~~~~");
            }
        }

        Inner1 inner1 = new Inner1();
        inner1.m();
    }
}
  • 局部内部类可以使用外部类的所有的属性和方法
class Outer1{//外部类

    int i = 5;
    static int j = 10;

    public static void m1(){
        System.out.println("外部类的m1方法");
    }

    public void m2(){
        System.out.println("外部类的m2方法");
    }

    public void m(){
        System.out.println("Outer~~~");

        // 局部内部类/方法内部类
        class Inner1{

            public void m(){
                System.out.println("Inner~~~~");
                System.out.println(i);
                System.out.println(j);
                m1();
                m2();
            }
        }

        Inner1 inner1 = new Inner1();
        inner1.m();
    }
}

  • 如果局部内部类和外部类出现了相同名称的变量，优先使用内部类的(就近原则)

  • 如果局部内部类和外部类出现了相同名称的变量，调用外部类属性的语法:外部类.this.属性名

  • 可以继承其他类也可以实现接口

3.3 成员内部类

成员内部类是在类中方法外的内部类。

  • 可以使用外部类中的一切属性和方法
  • 在成员内部类中不可以定义静态变量和静态方法
  • 可以定义非静态变量和非静态方法
  • 可以定义静态常量
  • 创建格式
创建格式 ：外部类.内部类 对象名 = new 外部类().new 内部类();

public class TestDemo3 {
    public static void main(String[] args) {
//        new Outer1().m(); 局部内部类

        // 成员内部类  创建格式 ：外部类.内部类 对象名 = new 外部类().new 内部类();
        Outer2.Inner2 inner2 = new Outer2().new Inner2();
        inner2.m();
    }
}


class Outer2{
    int i = 8;
    static int x = 10;

    //成员内部类
    // 可以使用外部类中的一切属性和方法
    // 不可以定义静态变量和静态方法
    class Inner2{
        // 采用就近原则
//        int i = 10;
        // 可以定义静态常量
        static final int j = 10;
        public void m(){
            System.out.println(i);
            System.out.println(j);
            System.out.println(x);
        }

    }
}

3.4 静态内部类

被static修饰的类就是静态内部类,外部类不能被static修饰

  • 不能使用外部类的非静态属性和非静态方法
  • 可以定义一切的属性和方法
  • 使用格式
外部类.内部类 对象名 = new 外部类.内部类();

public class TestDemo3 {
    public static void main(String[] args) {
//        new Outer1().m(); 局部内部类

        // 成员内部类  创建格式 ：外部类.内部类 对象名 = new 外部类().new 内部类();
//        Outer2.Inner2 inner2 = new Outer2().new Inner2();
//        inner2.m();


        // 静态内部类
        // 使用格式: 外部类.内部类 对象名 = new 外部类.内部类();
        Outer3.Inner3 inner3 = new Outer3.Inner3();
        inner3.m();
        // 调用静态内部类的静态方法
        // 格式:外部类.内部类.静态方法名();
        Outer3.Inner3.m1();
    }
}

class Outer3{

    static int i = 3;

    // 静态内部类
    // 不能使用外部类的非静态属性和非静态方法
    // 可以定义一切的属性和方法
    static class Inner3{
        int i1 = 4;
        static int j = 8;
        public void m(){
            System.out.println(i);
        }

        public static void m1(){
            System.out.println("m1是静态方法");
        }
    }
}

3.5 匿名内部类

匿名内部类就是一个没有名字的内部类，实际上是实现了对象的接口或者是继承了对应的类的内部类。

任何一个接口都可以存在匿名内部类，任何一个可以被继承的类都可以存在匿名内部类。

最终类不能使用匿名内部类。

        MyInter myInter = new MyInter() { //匿名内部类 这里表示的是MyInter接口的实现类
            @Override
            public void m() {
                System.out.println("m方法");
            }
        };
        myInter.m();

        B b = new B(){ //匿名内部类 表示是抽象类B的子类

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

        A a = new A(){
            // 匿名内部类  这个类是A的子类

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

class A {
    public void m2(){

    }
}

// 抽象类
abstract class B{
    public abstract void m1();
}



interface MyInter{
    void m();
}

4 JDK5部分特性

JDK5是java中的一个重要版本，出现了很多好用的特性。

例如；增强for循环、自动封箱拆箱、泛型、静态导入、可变参数、枚举、动态代理、注解

4.1 静态导入(了解)

导入已经有的静态方法。

// 静态导包 表示导入Arrays类中的sort方法 比如导入的是静态方法
import static java.util.Arrays.sort;

// *代表通配符 表示导入java.util包下的所有的类,但是不包括子包下的类
import java.util.*;

4.2 可变参数

可变参数就是用 数据类型… 声明的参数,特点是参数的个数不限。

可变参数只能定义一个

如果有多个参数，可变参数必须放在参数列表的末尾。

可变参数本质上就是一个数组

可变参数是一个语法糖。

public static void main(String[] args) {
//        int[] arr = {1,2,3,4,5};
//        System.out.println(add(arr));
        System.out.println(add(1, 2, 3, 4, 5, 6));

    }

    // 用  数据类型... 声明一个可变参数
    // 定义一个求和方法，求不同数字的和
    public static int add(int a,int b,int... array){
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        return sum;
    }

4.3 枚举

枚举中的值都是固定的内容，不会多也不会少，不允许类外随便修改。

4.3.1 上古时代枚举类(了解)
// 定义一个季节的枚举类
class Season{
    // Season对象只能够创建4个，只能是春夏秋冬，那么构造方法就不能暴露在外面。否则外面可以随意创建
    // 所以使用private修饰
    private Season(){}
    
    // 这时可以在本类中创建
    // static保证外面通过类名可以使用
    // final保证外面类中无法修改值
    // public保证可以在任意地方访问
   public static final Season spring = new Season();
   public static final Season summer = new Season();
   public static final Season autumn = new Season();
   public static final Season winter = new Season();
   
}
4.3.2 枚举类定义

枚举类声明格式：

enum 枚举类名{
   枚举的常量，枚举的常量
}

package cn.javasm.demo6;

/**
 * @version 0.1
 * @className: TestDemo
 * @author: gfs
 * @description
 * @date: 2023/8/22 17:39
 * @since jdk11
 */
public class TestDemo {
    public static void main(String[] args) {
//        从jdk5开始，允许switch-case语句中使用枚举常量
        Season season = Season.SUMMER;
        switch (season) {
            case SPRING:
                Season.SPRING.play();
                break;
            case SUMMER:
                System.out.println("夏天去水上乐园");
                break;
            case AUTUMN:
                Season.AUTUMN.play();
                break;
            case WINTER:
                System.out.println("冬天打雪仗");
                break;
        }
    }
}

// 定义一个枚举类
enum Season {
    // 枚举常量要求必须在枚举类有效代码的首行
    // 这里的SPRING =  public static final Season SPRING = new Season(7){};
    SPRING(3) {//匿名内部类

        @Override
        public void play() {
            System.out.println("春天放风筝");
        }
    },
    SUMMER(4) {
        @Override
        public void play() {
            System.out.println("夏天玩水");
        }
    },
    AUTUMN(5) {
        @Override
        public void play() {
            System.out.println("秋天摘果子");
        }
    },
    WINTER(6) {
        @Override
        public void play() {
            System.out.println("冬天滑雪");
        }
    };
    // 枚举类也是一个类，可以定义属性和方法
    private int month;

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    // 枚举中的构造方法必须使用private修饰


    private Season(int month) {
        this.month = month;
    }

    // 枚举中可以提供抽象方法
    public abstract void play();

}
puputt
关注
JAVA复习笔记
准备23考研。不定期更新考研知识
07-26 2104
待补充
java复习笔记--尚硅谷
qq_34676998的博客
09-12 1155
第一章 Java概述 1.1 Java历史 Java诞生于SUN（Stanford University Network），09年SUN被Oracle（甲骨文）收购。 Java之父是詹姆斯.高斯林(James Gosling)。 1996年发布JDK1.0版。 目前最新的版本是Java12。我们学习的Java8。 1.2 Java语言最主要的特点 特点一：面向对象 两个基本概念：类、对象 三大特性：封装、继承、多态 特点二：健壮性 吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、
Java复习笔记-Java安装与调试（一）
Keep coding! 知乎同名账号:https://www.zhihu.com/people/66-64-1-50
09-26 1010
Java的运行环境安装与环境变量配置。Java程序在Microsoft windows 11中安装与调试。
Java复习笔记-Java安装与调试（二）
Keep coding! 知乎同名账号:https://www.zhihu.com/people/66-64-1-50
09-28 861
在 Microsoft Windows 11 中安装 Java 调试编译运行环境，同时使用 IDE，VScode。
【JAVA】java复习笔记--多态详解
热门推荐
GengMS的博客
02-24 2万+
java基础之多态 定义： 多态指的是同一个方法调用，由于对象不同可能会有不同的行为。现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人的“休息”方法，张三是睡觉，李四是玩游戏，程序员是敲代码，数学教授是做数学题; 同样是调用人“吃饭”的方法，中国人用筷子吃饭，西方人用刀叉吃饭。 多态要点： 多态是方法的多态，不是属性的多态（多态与属性无关） 多态的存在要有3个必要条件：继承...
Java学习笔记-12
qq_36527349的博客
10-22 131
1.什么时候用断言（assert）？ 断言在软件开发中是一种常用的调试方式，很多开发语言中都支持这种机制。一般来说，断言用于保证程序最基本、关键的正确性。检查断言通常在开发和测试时开启。为了保证程序的执行效率，在软件发布后断言检查通常是关闭的。断言是一个包含布尔表达式的语句，在执行这个语句假定该表达式为true；如果表达式的值为false，那么系统会报告一个AssertionError。断言的使用...
java学习笔记12
weixin_44816758的博客
10-30 190
io流 File提供的功能都是操作文件外部的能力,没有办法操作文件内部的内容 IO流: 流: 一连串流动的数据,以先入先出的方式进行流动,管道 以程序为中心 程序与 网络|文件|服务器|数组… 分类: 按照流向: 输入流 输出流 操作单元分: 字节流 :万能流:任何内容都可以转为字节,可以传输文本,图片… 字符流 :只能操作 纯文本数据 按照功能: 节点流 : 包裹源头,实现基本功能 功...
Java学习笔记12
a3026836480的博客
08-26 120
GC(垃圾回收) GC算法 GC算法有标记清除法、标记整理、复制算法、引用计数器 堆里面的分区：Eden、from、to、老年区 引用计数法 复制算法 每次垃圾回收(GC)会将Eden活的对象放入移入幸存区from，两个幸村区中谁空谁就是to。 当一个对象经过15次(默认值)垃圾回收(GC)还没死，就会进入养老区。 (-XX:MaxTenuringThreshold=999) 通过该命令设置进入养老区的时间 From和To区会发生变化 ...
Java基础每日复习笔记-JavaSE高级阶段.2020-10-13-211312.edf
03-09
Java基础每日复习笔记-JavaSE高级阶段.2020-10-13-211312.edf
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 678
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring循环依赖解决方式
qq_36400213的博客
11-04 829
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 293
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
GEMM优化（待更新）
qq_62704693的博客
11-03 783
来源参考：深入浅出GPU优化系列：GEMM优化（一） - 知乎深入浅出GPU优化系列：GEMM优化（二） - 知乎深入浅出GPU优化系列：GEMM优化（三） - 知乎。
JAVA学习-练习试用Java实现“数组排序”
weixin_69763181的博客
11-03 304
这个程序首先导入了'java.util.Arrays'和'java.util.Scanner'，然后定义了一个'main'方法。程序使用'Scanner'类来读取用户的输入，并将其分割成一个字符串数组。然后，它将字符串数组转换成整数数组，并使用'Arrays.sort'方法对整数数组进行排序。以下是一个Java程序，它使用内置的'Arrays.sort'方法对用户输入的整数数组进行排序。编写一个Java程序，对用户输入的整数数组进行排序（可以使用内置的Arrays.sort方法，也可以自己实现排序算法）。
greendao使用封装
白高林的专栏
11-07 305
greenDAO
Java项目实战II基于Spring Boot的秒杀系统设计与实现（开发文档+数据库+源码）
2401_86524610的博客
11-03 540
在互联网电商蓬勃发展的今天，秒杀活动已成为各大电商平台吸引用户、提升销量的重要手段。然而，秒杀活动带来的瞬时高并发访问量对系统的性能和稳定性提出了严峻挑战。传统的系统架构往往难以承受如此巨大的压力，容易出现系统崩溃、数据不一致等问题。基于Spring Boot的秒杀系统，正是为了解决这些问题而设计的。该系统利用Spring Boot框架的简洁性、高效性和可扩展性，结合分布式架构、缓存技术、消息队列等先进技术，构建了一个能够应对高并发访问、保证数据一致性和系统稳定性的秒杀平台。
【JAVA】Java基础—面向对象编程基础：类与对象的概念
最新发布
thinking_chou的专栏
11-07 910
类是一个用户定义的数据类型，它包含了属性和方法。属性用于描述对象的特征，方法用于描述对象的行为。类与对象是Java编程的核心概念。类是对象的蓝图，定义了对象的属性和方法；对象是类的实例，具有独立的状态和行为。通过类与对象，我们可以更好地模拟现实世界中的事物，使得程序设计更加清晰和模块化。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值