抽象类与接口

已于 2024-06-10 21:59:07 修改
阅读量44 收藏
点赞数
分类专栏： JavaSE 文章标签： java
于 2023-07-26 20:48:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71627203/article/details/131947463
版权

文章目录

前言

一、抽象类

1.1 抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象方法：被abstract修饰的方法，没有方法体。

包含抽象方法的类我们称为抽象类。

1.2 抽象类语法结构

在Java中，一个类如果被 abstract 修饰就称之为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

1.3 抽象类的特性

  1. 抽象类是被abstract修饰的，被abstract修饰的方法称为抽象方法，该方法可以没有具体的实现，但是当一个类中含有抽象方法的时候，该类必须使用abstract修饰。
  2. 抽象类当中可以有和普通类一样的成员变量和成员方法。这也就意味着： 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。所以，当普通类继承了抽象类之后，这个普通类一定要重写这个抽象类当中所有的抽象方法。
  3. 抽象方法不能是 private 的。
  4. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写，但final修饰的不可以被重写。
  5. 抽象类不能直接实例化对象，这也就意味着抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰。
  6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

1.4 抽象类代码示例

abstract class Shape{

		public Shape(){
		//用来让继承的子类替它进行实例化
		}
		
    public abstract void draw();

    public void test(){

    }
}

class Rest extends Shape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}

class Circle extends Shape{
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}

class Flower extends Shape{
    @Override
    public void draw() {
        System.out.println("花朵");
    }
}
public class TestDemo {
    public static void drawMap(Shape shape){
        shape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Rest());
        drawMap(new Circle());
        drawMap(new Flower());
    }
}

结果如下在这里插入图片描述

二、接口

2.1 接口的定义

1.使用Interface来定义一个接口。
2.接口当中的成员变量默认是public static final的，成员方法默认是public abstract的，一般情况下可以直接省略。
3.接口中不可以直接出现普通方法，除非在普通方法前面用default修饰，这样的方法可以被具体实现。
4.如果接口当中的当普通方法被static修饰，那么这样的方法也可以被具体实现。
5.接口不能通过new关键字来进行实例化，在类和接口之间，需要通过关键字implement来实现接口，该类中需要实现接口中的所有方法。
6.接口也可以产生向上转型和动态绑定。

2.2 接口使用

2.2.1 代码示例（一）

public interface IShape{
    int a = 10;
    void draw();
    default public void test(){
        System.out.println("test()");
    }

    public static void test2(){
        System.out.println("stctic");
    }
}

class Rect implements IShape{
    @Override
    public void draw() {
        System.out.println("矩形");
    }
}

class Circle implements IShape{
    @Override
    public void draw() {
        System.out.println("圆形");
    }
}

class Flower implements IShape{
    @Override
    public void draw() {
        System.out.println("花朵");
    }
}
public class Test {
    public static void drawMap(IShape iShape){
        iShape.draw();
    }
    public static void main(String[] args) {
        drawMap(new Rect());
        drawMap(new Circle());
        drawMap(new Flower());
    }
}

结果如下在这里插入图片描述

2.2.2 接口使用代码示例（二）

public interface IUSB {
    void openDevice();
    void closeDevise();
}

class Mouse implements IUSB{

    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevise() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("鼠标点击");
    }
}

class KeyBoard implements IUSB {

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

    @Override
    public void closeDevise() {
        System.out.println("关闭键盘");
    }

    public void inPut(){
        System.out.println("键盘输入");
    }
}

class Computer{
    public void powerOn() {
        System.out.println("打开笔记本电脑");
    }

    public void powerOff() {
        System.out.println("关闭笔记本电脑");
    }

    public void useDevise(IUSB usb){
        usb.openDevice();
            if(usb instanceof Mouse){
                Mouse mouse = (Mouse) usb;
                mouse.click();
            }else if(usb instanceof  KeyBoard){
                KeyBoard keyBoard = (KeyBoard) usb;
                keyBoard.inPut();
            }
            usb.closeDevise();
    }
}

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.powerOn();
        computer.useDevise(new Mouse());
        computer.useDevise(new KeyBoard());
        computer.powerOff();
    }
}

结果如下在这里插入图片描述

2.2.3 接口使用代码示例（三）

public interface IFiying {
    void fly();
}

public interface IRunning{
    void run();
}

public interface ISwimming {
    void swim();
}

public abstract class Animal {

    public String name;
    public int age;

    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
    public abstract void eat();
}

public class Bird extends Animal implements IRunning,IFiying{
    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name + "正在吃鸟食");
    }

    @Override
    public void fly() {
        System.out.println(name + "正在用翅膀飞翔");
    }

    @Override
    public void run() {
        System.out.println(name + "正在用鸟腿跑步");
    }
}

public class Dog extends Animal implements IRunning,ISwimming{

    public Dog(String name,int age){
        super(name,age);
    }
    @Override
    public void eat() {
        System.out.println(name + "正在吃狗粮");
    }

    @Override
    public void run() {
        System.out.println(name + "正在奔跑");
    }

    @Override
    public void swim() {
        System.out.println(name + "正在狗刨");
    }
}

public class Test {
    public static void test(Animal animal){
        animal.eat();
    }

    public static void test1(IFiying iFiying){
        iFiying.fly();
    }

    public static void test2(IRunning iRunning){
        iRunning.run();
    }

    public static void test3(ISwimming iSwimming){
        iSwimming.swim();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("小狗",1);
        Bird bird = new Bird("小鸟",2);

        test(dog);
        test(bird);
        System.out.println("================");
        test1(bird);
        System.out.println("================");
        test2(dog);
        test2(bird);
        System.out.println("================");
        test3(dog);
    }
}

结果如下
在这里插入图片描述
在这里插入图片描述

2.2.4 接口使用代码示例（四）

class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三",12);
        Student student2 = new Student("王五",5);
        System.out.println(student1.compareTo(student2));
    }
}

结果如下在这里插入图片描述

2.2.5 接口使用代码示例（五）

class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public int compareTo(Student o) {
        if(this.age > o.age){
            return 1;
        } else if (this.age > o.age) {
            return -1;
        }else {
            return 0;
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student("张三",12);
        Student student2 = new Student("王五",5);
        System.out.println(student1.compareTo(student2));
    }
}

结果如下在这里插入图片描述

2.2.6 接口使用错误代码示例

class Student{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("张三",10);
        students[1] = new Student("王五",12);
        students[2] = new Student("李四",5);

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

结果如下在这里插入图片描述

2.2.6 接口使用正确代码示例

class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public int compareTo(Student o) {
        return this.age - o.age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("张三",10);
        students[1] = new Student("王五",12);
        students[2] = new Student("李四",5);

        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

结果如下在这里插入图片描述

2.2.7 接口使用代码示例（六）

class Student implements Comparable<Student>{
    public String name;
    public int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
       return this.age - o.age;
    }
}

public class Test {

    public static void bubbleSort(Comparable[] comparable){
        for (int i = 0; i < comparable.length - 1; i++) {
            for (int j = 0; j < comparable.length - 1 - i; j++) {
                if(comparable[j].compareTo(comparable[j + 1]) > 0){
                    Comparable tmp = comparable[j];
                    comparable[j] = comparable[j + 1];
                    comparable[j + 1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] =  new Student("张三",10);
        students[1] = new Student("李武",14);
        students[2] = new Student("王五",1);
        bubbleSort(students);
        System.out.println(Arrays.toString(students));
    }
}

结果如下在这里插入图片描述

2.2.8 接口使用代码示例（七）

class Student implements Cloneable {
    public int age;

    public Student(int age){
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
        Student student1 = new Student(10);
        Student student2 = (Student) student1.clone();
        System.out.println(student1);
        System.out.println(student2);
    }
}

结果如下在这里插入图片描述

2.3 接口特性

  1. 接口类型是一种引用类型，但是不能直接new接口的对象。
  2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract，其他修饰符都会报错。
  3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现。
  4. 重写接口中方法时，不能使用默认的访问权限。
  5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量。
  6. 接口中不能有静态代码块和构造方法。
  7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class。
  8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类。
  9. jdk8中：接口中还可以包含default方法。。

2.4 抽象类和接口的区别（※）

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用, 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。在这里插入图片描述

三、Object 类

3.1 什么是Object 类？

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

3.2 获取对象信息

3.2.1 父类获取对象信息

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person("张三",12);
        System.out.println(person);
    }
}

结果如下在这里插入图片描述在这里插入图片描述

3.2.2 子类重写toString( )获取对象信息

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person("张三",12);
        System.out.println(person);
    }
}

结果如下在这里插入图片描述

3.3 对象比较equals方法

在Java中，== 进行比较时：
如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同；
如果 == 左右两侧是引用类型变量，比较的是引用变量地址是否相同；
如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的；

3.3.1 对象比较equals方法代码示例（一）

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",12);
        System.out.println(person1);

        Person person2 = new Person("张三",12);
        System.out.println(person2);

        System.out.println(person1 == person2);
        System.out.println("=============");
        System.out.println(person1.equals(person2));

    }
}

结果如下在这里插入图片描述

3.3.1 对象比较equals方法代码示例（一）

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age && Objects.equals(name, person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",12);
        System.out.println(person1);

        Person person2 = new Person("张三",12);
        System.out.println(person2);

        System.out.println(person1 == person2);
        System.out.println("=============");
        System.out.println(person1.equals(person2));
        System.out.println("=============");

        Person person3 = person2;
        System.out.println(person3.equals(person2));

    }
}

结果如下在这里插入图片描述

3.4 hashcode方法

3.4.1 原hashcode方法调用

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",12);
        Person person2 = new Person("张三",12);

        System.out.println(person1.hashCode());
        System.out.println(person2.hashCode());
    }
}

在这里插入图片描述

3.4.1 重写hashcode方法调用

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

   @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public class Test {
    public static void main(String[] args) {
        Person person1 = new Person("张三",12);
        Person person2 = new Person("张三",12);

        System.out.println(person1.hashCode());
        System.out.println(person2.hashCode());
    }
}

结果如下在这里插入图片描述

3.4.2 学习小贴士

1、hashcode方法用来确定对象在内存中存储的位置是否相同。 2、事实上hashCode()
在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的 散列码，进而确定该对象在散列表中的位置。

四、深拷贝代码示例

class Money implements Cloneable{
    public double money = 19.9;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student implements Cloneable {
    public int age;

    public Money m;

    public Student(int age){
        this.age = age;
        this.m = new Money();
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student str = (Student) super.clone();
        str.m = (Money) this.m.clone();
        return str;
    }
}
public class Test {
    public static void main(String[] args) throws CloneNotSupportedException{
        Student student1 = new Student(10);
        Student student2 = (Student) student1.clone();
        System.out.println(student1);
        System.out.println(student2);
        System.out.println("================");
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);
        System.out.println("================");
        student2.m.money = 99.8;
        System.out.println(student1.m.money);
        System.out.println(student2.m.money);//浅拷贝
        System.out.println("================");
    }
}

结果如下
在这里插入图片描述

Mo_吉托的莫。
关注
专栏目录
抽象类与接口详解
weixin_53066120的博客
12-05 8367
抽象类使用 abstract 关键字来进行声明。// ...抽象类可以包含属性、方法和构造函数，但不能被实例化。接口使用 interface 关键字进行声明。在上面的例子中，Shape 接口定义了 calculateArea() 和 calculatePerimeter() 两个抽象方法。
Java中的抽象类和接口
热门推荐
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-15 4万+
各位铁汁们大家好呀！今天让我们继续学习java，看看java中的抽象类和接口到底是什么？ 里面也会讲到多态呀，一起来看看吧😉
C#-抽象类与接口
qq_43733614的博客
08-31 2906
抽象类和接口这两种类型用于完全不同的目的。抽象类主要用作对象的基类，贡献某些主要的特性，例如共同的目的和结构。接口则主要是用于类，为这些类去添加不同的方法（行为）。
抽象类与接口的异同
lniiiiii的博客
12-18 1812
一、概述 对于面向对象的编程来说，抽象其特征之一。而在Java中，可以通过两种形式来体现OOP的抽象：抽象类与接口。接口在许多方面都与抽象类很相似，但是它的目的是指明相关或者是不相关类的对象的共同行为。所以说，这两者有很多相似的地方，但同时也有着很多不同的地方。它们的不可以随意的互换使用，需要明确它们的异同点。 二、背景 1、抽象类 在继承的层次结构中，每个新的子类都使类变得更加明确和具体。如果从一个子类向父类追溯，类就会变得更通用，但也会更加不明确。类的设计应该确保...
抽象类与接口的异同点
Aure219的博客
05-11 1万+
抽象类与接口的异同点 文章目录抽象类与接口的异同点不同点：相同点：从设计理念层面分析eg：方案1：方案2： 不同点： 1.关键字不同： ​ ① 继承抽象类的关键字是extends，而实现接口的关键字是implements； ​ ②定义抽象类的关键字是abstract class，而定义接口的关键字是interface; 2.权限修饰不同：抽象方法可以有public、protected和default这些修饰符（缺省情况下默认为public），而接口方法只能是public ; 3.抽象类中
C#抽象类与接口的区别及应用场合
河西~石头
10-16 2562
本文通过代码的逐个解析来体验抽象类与接口的区别以及应用。
Java抽象类与接口详解
jakelihua
01-09 1969
抽象类是一个包含抽象方法的类，它不能被实例化。抽象方法是一种没有方法体的方法，它只包含方法的签名。抽象类可以包含普通的方法，也可以包含抽象方法，而普通方法可以有方法体。// 抽象方法// 普通方法// 抽象方法// 默认方法。
接口与抽象类的区别
DavidLiu的博客
12-01 3万+
a、抽象类不能被实例化只能被继承； b、包含抽象方法的一定是抽象类，但是抽象类不一定含有抽象方法； c、抽象类中的抽象方法的修饰符只能为public或者protected，默认为public； d、一个子类继承一个抽象类，则子类必须实现父类抽象方法，否则子类也必须定义为抽象类； e、抽象类可以包含属性、方法、构造方法，但是构造方法不能用于实例化，主要用途是被子类调用。 接口：Java中接口使用interface关键字修饰，特点为: a、接口可以包含变量、方法；变量被隐士指定为public st.
抽象类与接口的区别
newoneobjectddd的博客
03-18 4549
接口与抽象类的区别
java抽象类与接口实例java抽象类与接口实例
06-22
java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例...
PHP抽象类与接口的区别详解
01-02
对于面向对象开发，抽象类与接口这两个东西是比较难理解的；就算是对于有一定经验的程序员来说也如此。下面根据自己的理解来讲述一下这两个东西，如有什么不对的，还望不吝赐教。 抽象类：是基于类来说，其本身就是...
抽象类与接口（学习笔记）
12-21
**抽象类与接口的区别** 1. **抽象程度**：抽象类是部分抽象的，可以包含抽象和非抽象方法；接口则是完全抽象的，只包含常量和抽象方法。 2. **构造方法**：抽象类可以有构造方法，用于初始化子类；接口则不允许有...
实验5：Java抽象类与接口.doc
10-01
Java 抽象类与接口实验报告 一、实验目的及要求 本实验的目的是掌握 Java 中的抽象类和接口的概念及其应用。通过本实验，学生将了解抽象类和接口的定义、特点及使用场景，并掌握如何使用抽象类和接口来描述不同的...
Java抽象类与接口实验报告
10-19
Java抽象类与接口实验报告
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
最新发布
h2345678的博客
10-29 1260
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1044
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
java_方法递归调用
HHppGo的博客
10-27 509
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1230
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
抽象类与接口的区别详解
"本文详细探讨了抽象类与接口之间的区别，包括它们各自的定义、特性以及在实际编程中的应用。" 在面向对象编程中，抽象类和接口都是用来实现多态性和代码重用的重要机制，但它们有着本质的区别。 一、抽象类 抽象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Mo_吉托的莫。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值