【Java SE】基础知识回顾——【6.接口 | 多态】

最新推荐文章于 2024-08-29 18:44:48 发布
最新推荐文章于 2024-08-29 18:44:48 发布
阅读量901 收藏 9
点赞数 30
分类专栏： Java 基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40639981/article/details/135064978
版权

【Java SE】基础知识回顾——【6.接口 | 多态】

接口

接口的定义以及使用步骤

**
 * @author 270
 * 接口是多个类的公共规范
 * 接口是一种引用类型，最重要的是内容是其中的——>【抽象方法】
 * 定义接口：
 * public interface 接口名称{
 *     //接口内容
 * }
 * 备注：换成了关键字interface之后,编译生成的字节码文件仍然是： .java-->.class
 *
 * 接口可以包含的内容有：
 * 1.常量
 * 2.抽象方法
 * 3.默认方法
 * 4.静态方法
 * 5.私有方法
 *
 * 接口使用步骤：
 * 1.接口不能直接使用，必须有一个"实现类"来"实现"该接口
 * 格式：
 * public class 实现类名称 implements 接口名称{
 *     //...
 *     }
 * 2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
 * 实现：去掉Abstract关键字，加上方法体大括号。
 * 3.创建实现类的对象，进行使用
 *
 * 注意事项：
 * 如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
 */
public class Interface {
    public static void main(String[] args) {
        //【注意】：MyInterfaceAbstract 是接口，不能直接new，要通过实现类来调用
         MyInterfaceAbstractImpl impl = new MyInterfaceAbstractImpl();
         impl.methodAbs1();
         impl.methodAbs4();
    }
}

接口的抽象方法定义

/**
 * @author 270
 * 在任何版本的Java中，接口都能定义抽象方法：
 *格式：
 * public abstract 返回值类型 方法名称（参数列表）；
 *
 * 注意事项：
 * 1.接口中的抽象方法，修饰符必须是 public abstract
 * 2.这两个关键字修饰符虽然不能省略，但是能选择性省略
 * 3.方法的三要素可以随意定义
 * 4.接口内定义的抽象方法是没有方法体的
 */

public interface MyInterfaceAbstract {

    public abstract void methodAbs1();

    public void methodAbs2();

    abstract void methodAbs3();

    void methodAbs4();


}

接口的默认方法定义和使用

接口
package Demo01;

/**
 * @author 270
 * Java允许接口里定义默认方法。
 * 格式：
 * public defalut 返回值类型 方法名称（参数列表）{
 *     方法体
 * }
 *
 * 备注：接口中的默认方法。可以解决接口升级的问题。
 * 接口升级指的是
 * 默认方法会被实现类继承下去的
 *
 */
public interface MyInterfaceDefault {
    /**
     * 抽象方法
     */
    public abstract void methodAbs1();
    //抽象方法

    /**新添加抽象方法,这样实现类也需要再覆盖重写新的方法
    *可以通过改成默认方法就没有这个影响了
     * methodDefault是新添加的默认方法
     * 默认方法不用覆盖重写
    */
    public default void methodDefault(){
        System.out.println("默认方法");

    }

}
实现类1
package Demo01;

/**
 * @author 270
 */
public class MyInterfaceDefaultImpl implements MyInterfaceDefault{
    @Override
    public void methodAbs1() {
        System.out.println("实现了抽象方法，AAA");
    }
}
实现类2
package Demo01;

/**
 * @author 270
 */
public class MyInterfaceDefaultImplB implements MyInterfaceDefault{
    @Override
    public void methodAbs1() {
        System.out.println("实现了抽象方法，BBB");
    }
}
主方法
package Demo01;

/**
 * @author 270
 * 1.接口的默认方法，可以通过接口实现类对象，直接调用
 * 2.接口的默认方法，也可以通过接口实现类进行覆盖重写
 */
public class Interface02 {
    public static void main(String[] args) {
        //创建了实现类对象
         MyInterfaceDefaultImpl Impl = new MyInterfaceDefaultImpl();
         Impl.methodAbs1();
         //通过接口来调用默认方法，其实在实现类中没有写
        //调用默认方法，如果在实现类中没有，会向上找接口
         Impl.methodDefault();
         MyInterfaceDefaultImplB b = new MyInterfaceDefaultImplB();
         b.methodAbs1();
         b.methodDefault();
    }
}

接口的静态方法定义

接口
package Demo01;

/**
 * @author 270
 * 接口当中允许定义静态方法。
 * 格式：
 * public static 返回值类型 方法名称（参数列表）{
 *     方法体
 * }
 * 提示：就是将abstract或者default换成static即可，带上方法体
 */
public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println("接口的静态方法");
    }
}
主方法
package Demo01;

/**
 * @author 270
 * 【注意】：不能通过接口实现类的对象来调用接口中的静态方法。
 * 正确用法：通过接口名称，直接调用静态方法
 */
public class Demo01Interface {
    public static void main(String[] args) {
        MyInterfaceStaticImpl impl = new MyInterfaceStaticImpl();
        MyInterfaceStatic.methodStatic();

    }
}
实现类
package Demo01;

/**
 * @author 270
 *不需要在实现类里覆盖重写默认方法和静态方法（static和default）
 */
public class MyInterfaceStaticImpl implements MyInterfaceStatic{
}

接口的私有方法

接口
package Demo01;

/**
 * @author 270
 * 抽取一个公共方法，解决两个默认方法之间重复代码的问题
 * 但是这个共有方法不应该让实现类使用，应该是私有化的
 *
 * 解决：在接口中定义私有方法
 * 1.普通私有方法，解决多个默认方法之间重复代码问题
 * 格式：
 * private 返回值类型 方法名称（参数列表）{
 *     方法体
 * }
 * 2.静态私有方法，解决多个静态方法之间重复代码问题
 * 格式：
 * private static 返回值类型 方法名称（参数列表）{
 *     方法体
 * }
 */
public interface MyInterfacePrivateB {
    public static void methodStatic1(){
        System.out.println("静态方法1");
        methodCommon();
    }
    public static void methodStatic2(){
        System.out.println("静态方法2");
        methodCommon();
    }

    /**
     * 将methodCommon方法变为私有方法
     * 这样只有接口里的方法能够调用此方法
     * 实现类中的方法无法调用
     */
   private static void methodCommon(){
        System.out.println("AAA");
        System.out.println("BBB");
        System.out.println("CCC");
    }

}

接口当中的常量

package Demo01;

/**
 * @author 270
 * 接口当中定义"成员变量"
 * 但是必须使用public static final三个关键字进行修饰
 * 从效果上来看，这就是接口的【常量】
 * 【格式】
 * public static final 数据类型 常量名称 = 数据值
 *
 *
 * 【注意事项】
 * 1.接口当中的常量，可以省略public static final，注意：不写也照样是这个格式
 * 2.接口当中的常量必须进行赋值，不能不赋值
 * 3.常量的名称一定要大写，所有字母都要大写，并使用下划线进行分隔
 * 4.
 *
 */
public interface MyInterfaceConst {
    //num其实就是常量，一旦赋值无法修改
    //public:指都能使用
    //static：指不同通过实现类实现，可以直接调用
    //final：说明不可改变

    public static final int NUM = 10;
}

接口内容小结

在Java 9+版本中，接口的内容可以有：

  1. 成员变量其实是常量，格式：
    [public] [static] [final] 数据类型 常量名称 = 数据值;
    注意：
    常量必须进行赋值，而且一旦赋值不能改变。
    常量名称完全大写，用下划线进行分隔。

  2. 接口中最重要的就是抽象方法，格式：
    [public] [abstract] 返回值类型 方法名称(参数列表);
    注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类。

  3. 从Java 8开始，接口里允许定义默认方法，格式：
    [public] default 返回值类型 方法名称(参数列表) { 方法体 }
    注意：默认方法也可以被覆盖重写

  4. 从Java 8开始，接口里允许定义静态方法，格式：
    [public] static 返回值类型 方法名称(参数列表) { 方法体 }
    注意：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法

  5. 从Java 9开始，接口里允许定义私有很乏，格式：
    普通私有方法：private 返回值类型 方法名称(参数列表) { 方法体 }
    静态私有方法：private static 返回值类型 方法名称(参数列表) { 方法体 }
    注意：private的方法只有接口自己才能调用，不能被实现类或别人使用。

继承父类并实现多个接口

package Demo01;

/**
 * @author 270
 * 1.接口是没用静态代码块或者构造方法的
 * 2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
 * 格式：public class MyInterface implements MyInterfaceA，MyInterfaceB{
 *     //覆盖所有抽象方法
 *     }
 * 3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
 * 4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
 * 5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写
 * 6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突优先使用父类当中的方法。
 */
public class Demo01Interface {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.method();
    }
}

多态

多态的概述

/** @author 270
* 1.类与类之间是单继承的，直接父类只有一个
* 2.类与接口之间是多实现的，一个类可以实现多个接口。
* 3.接口与接口之间是多继承的
*
* 注意事项：
* 1.多个父接口当中的【抽象】方法如果重复，没关系
* 2.多个父接口当中的【默认】方法如果重复，
*    那么子接口必须进行默认方法的覆盖重写，【必须带有default关键字】
*/

多态的使用与格式

package Demo03Multi;

/**
 * @author 270
 * 代码当中体现多态性，父类引用指向子类对象
 * 格式：
 * 父类名称 对象名 = new 子类名称（）；
 * 或者：
 * 接口名称 对象名 = new 实现类名称（）；
 *
 */
public class Demo01Multi {
    public static void main(String[] args) {
        Fu obj = new Zi();

        //这里优先用子类方法
        obj.method();
        //也可以调用父类独有方法
        obj.methodFu();
    }
}

多态中成员变量&成员方法的使用特点

package Demo04;



/**
 * @author 270
 * 访问成员变量的两种方法
 *
 * 1.直接通过对象名称访问，等号左边是谁就优先用谁，没有则向上查找
 * 2.间接通过成员方法访问
 */
public class Demo01 {
    public static void main(String[] args) {
        Fu obj = new Zi();
        //访问成员变量
        System.out.println(obj.num);
        System.out.println("==============");
        //访问成员方法,子类有这个方法就先调用子类，没有就通过父类来调用
        //子类进行了覆盖重写   即为子
        //没有覆盖重写         则为父
        obj.showNum();
    }


}

package Demo04;

/**
 * @author 270
 * 在多态的代码中，成员方法的使用规则是：
 *  看new的是谁，就优先用谁，没有就向上找
 *
 *  【成员变量口诀】：编译看左边，运行看右边。
 *  比如     Fu obj = new Zi();
 *  编译看Fu类，运行看Zi类
 *  【成员方法口诀】：编译看左边，运行看右边。
 *
 */
public class Demo02MultiMethod {
    public static void main(String[] args) {
        Fu obj = new Zi();
        //成员方法的使用规则是：看new的是谁，就优先用谁
        //所以这里优先用子类
        obj.method();
        //子类没有，所以优先为父类
        obj.methodFu();
    }
}

对象的上下转型

package Demo05;

/**
 * @author 270
 * 向上转型一定是安全的，没有问题的，但是有一个弊端
 * 对象一旦向上转型为父类，那么无法调用子类原本持有的内容
 *
 * 解决方案：用对象的向下转型【还原】
 */
public class Demo01Main {
    //对象的向上转型，就是，父类引用指向子类对象
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
        Cat cat = (Cat) animal;
        cat.catchMouse();
        //下面这行代码是错误的，虽然编译不会报错
        //但是无法运行，因为animal已经被设定成一只猫了
        //会报错：java.lang.ClassCastException
        //类转换异常
        Dog dog = (Dog) animal;


    }
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

用instanceof关键字进行类型判断

/**
 * @author 270
 * 如何才能知道一个父类引用的对象，本来是什么子类
 * 格式：
 * 对象 instanceof 类名称
 * 这将会得到一个boolean值结果，也就是判断前面的对象能不能做后面的实例
 */
 public class Instanceof {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();

        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
        giveMeAPet(new Dog());
    }


    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }
}

笔记本电脑实例

鼠标类
package Demo02Laptop;

public class Mouse implements Usb {
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }
    public  void click(){
        System.out.println("鼠标点击");
    }
}
键盘类
package Demo02Laptop;


public class Keyboard implements Usb {
    //键盘是usb设备

    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }
    public void type(){
        System.out.println("键盘输入");
    }
}
usb接口
package Demo02Laptop;

/**
 * @author 270
 */
public class Computer {
    public void powerOn(){
        System.out.println("电源开机");
    }
    public void powerOff(){
        System.out.println("电源关机");
    }
    //使用Usb的方法
    public void useDevice(Usb usb){
        usb.open();
        usb.close();
        if(usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            //向下转型
            mouse.click();
        }else if(usb instanceof Keyboard){
            Keyboard keyboard = (Keyboard) usb;
            keyboard.type();
            //向下转型
        }
    }


}
主程序
package Demo02Laptop;

public class DemoMain {
    //创建电脑
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        //准备鼠标并 首先向上转型
        Usb usbMouse = new Mouse();
        computer.useDevice(usbMouse);
        //参数是usb类型，正好传进去usbmouse这个usb类型

        //创建一个usb键盘
        Keyboard keyboard = new Keyboard();
        //没有使用多态写法
        computer.useDevice(keyboard);
        //参数是usb，然而参数是usb类型，但是为正确写法，因为这里面也发生了向上转型。

        computer.powerOff();
        System.out.println("===================");

        method(10.0);
        //正确：double---->double
        method(10);
        //正确：int------->double
        //自动类型转换。同usb参数类型写Keyboard
    }
    public static void method(double num){
        System.out.println(num);
    }


}

『命数如织 当为磐石』
关注
  • 30
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java进阶学习6—接口、多态
m0_74270947的博客
11-17 148
接口 多态 I 接口 一、接口概述 1、定义：一个类中所有方法均为抽象方法时， 将该类定义为接口 2、辨析接口与抽象类：抽象类不一定有抽象方法，接口所有方法均抽象方法(也有编写非抽象方法的途径) 3、类型：接口是引用数据类型，比抽象类更抽象 4、接口存在意义：(1)规则的定义(2)程序的扩展性 (类比理解USB接口) 5、格式和特点： (1)通过interface关键字定义，格式：public interface 接口名{} (2)接口不能实例化(不能创建对象) (3)接口和类是
JAVA学习笔记（6）——接口与多态
独孤易郎的博客
05-03 229
一、接口  1.   –与抽象类一样都是定义多个类的共同属性 –使抽象的概念更深入了一层，是一个“纯”抽象类，它只提供一种形式，并不提供实现 –允许创建者规定方法的基本形式：方法名、参数列表以及返回类型，但不规定方法主体 –也可以包含基本数据类型的数据成员，但它们都默认为static和final    （1）接口的作用 –是面向对象的一个重要机制 –实现多继承，同时免除C++中的多继承那样的复杂性...
【Java SE】基础知识回顾——【7.Final | 权限 | 内部类】
qq_40639981的博客
12-19 383
*** 如果一个事物的内部包含另一个事物没那么就是一个类内部包含另一个类* <p>* 分类：* 1.成员内部类* 2.局部内部类（包含匿名内部类）* 成员内部类的定义格式：* 修饰符 class 外部类名称{* 修饰符 class 内部类名称{* //...* }* //...* }*【注意】：内用外，随意访问；外用内，需要借助内部类对象*//***/public class Body {//外部类public class Heart {//成员内部类。
【Java SE】基础知识回顾——【9.Collection类 | 泛型】
qq_40639981的博客
12-21 1003
在前面基础班我们已经学习过并使用过集合ArrayList ,那么集合到底是什么呢?集合：集合是java中提供的一种容器，可以用来存储多个数据。集合和数组既然都是容器，它们有啥区别呢？数组的长度是固定的。集合的长度是可变的。数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，使用集合进行存储。在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。
用于回顾java基础知识 Java学习资
06-24
"用于回顾java基础知识"的标题和描述暗示了我们将探讨的是Java的基础概念，这可能包括语法、类、对象、数据类型、控制结构等核心概念。下面我们将深入这些主题，帮助你巩固Java编程的基础。 1. **Java简介**：Java...
好程序员全网最快Java零基础入门视频教程，java开发自学必备（最新LTS Java 17版本）
07-07
在深入学习这些基础知识后，你将具备编写简单Java程序的能力。随着课程的推进，你还将接触到更多高级主题，如设计模式、Spring框架、数据库连接、Web开发等，进一步提升你的Java开发技能。 通过“好程序员全网最快...
JAVA SE
qq_48916660的博客
06-05 1194
JAVA基础
Java语言程序设计 第六版基础篇 非程序题答案
11-05
- Java平台：理解JVM（Java虚拟机）的概念，以及Java的三个主要平台——Java SE、Java EE和Java ME。 - Java程序结构：学习如何编写Hello, World!程序，理解类、对象、方法的基本概念。 - 关键字与标识符：掌握...
Java面试题大全（2021版）
m0_67401153的博客
07-29 279
编程就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到结果的过程。为了使计算机能够理解人的意图，人类就必须要将需解决的问题的思路、方法、和手段通过计算机能够理解的形式告诉计算机，使得计算机能够根据人的指令一步一步去工作，完成某种特定的任务。这种人和计算机之间交流的过程就是编程。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。字节码采用字节码的好处面向过程优点。...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2816
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
[C++规范] 访问类成员变量的方式：直接访问还是通过成员函数访问？
Loewen丶的小窝
08-26 2709
在面向对象编程（OOP）中，通过成员函数（如`ME_HardwareTypeEnum Type() const;` 和 `int Id() const;`）来访问类的私有或受保护成员（如`m_hardwareType` 和 `m_id`），而不是直接通过公共成员访问，是一种更好的做法。
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 3213
linux上datax 安装以及使用
《深入理解 Java 中的适配器模式》
最新发布
面团到油条的成长日记
08-29 1357
在软件开发的广阔领域中，不同接口之间不匹配的问题时常像个棘手的难题困扰着开发者。而适配器模式就像是一位得力的助手，专门用来解决这类问题。它的关键作用在于把一个类的接口有效地转化为客户端所期望的另一种接口，让原本因接口不相符而不能一起工作的两个类可以共同协作，学习本文希望你能有所收获
操作系统原子操作
zzt_is_me的博客
08-28 1583
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
weixin_39996520的博客
08-28 1167
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 858
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1619
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
死锁及其产生条件
秋夫人
08-26 586
死锁是指两个或多个线程（或进程）互相等待对方释放资源，导致所有相关线程都无法继续执行的情况。这是并发编程中的一个常见问题，可能会导致系统部分或完全停止响应。
Java SE基础知识：继承、抽象与多态
"该文档是关于Java SE基础知识的总结，涵盖了继承、抽象类与接口、多态、权限修饰符、代码块、Object类、Date类、DateFormat类、Calendar类、Math类、System类、BigDecimal类、Arrays类以及包装类的相关知识。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值