java抽象类、内部类、枚举类

已于 2024-07-17 17:02:10 修改
阅读量1.2k 收藏 17
点赞数 37
分类专栏： java入门 文章标签： java 开发语言
于 2024-06-28 23:45:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62798969/article/details/140033545
版权

目录

abstract抽象类

抽象类细节 

抽象类小练习

抽象类最佳实践——模板设计模式

接口

接口细节

接口与继承⭐

接口的多态特性 

内部类⭐

局部内部类 

 匿名内部类⭐⭐

成员内部类

静态内部类 

内部类练习题

枚举类（enumeration)

枚举小练习

enum细节

abstract抽象类

  • 对于父类方法不确定性问题，父类有方法要声明，但不需实现，由其子类实现，可将方法定义为抽象方法，有抽象方法的类需修饰为抽象类 
  • 用abstract修饰一个类，这个类就是抽象类：访问修饰符 abstract class 类名{}
  • 用abstract修饰一个方法，这个类方法是抽象方法，抽象方法没有方法体：访问修饰符 abstract 返回类型 方法名(参数列表);
  • 抽象类的价值更多作用在于设计，设计者设计好后，让子类继承并实现抽象类
  • 抽象类在框架和设计模式中应用较多（考官爱考！）

抽象类细节 

  1. 抽象类不能被实例化
  2. 抽象类可以没有抽象方法 ，有抽象方法的类一定是抽象类
  3. abstract只能修饰类和方法
  4. 抽象类本质还是类，可以有任意成员（非抽象方法、构造器、静态属性等）
  5. 抽象方法没有方法体
  6. 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它也是一个抽象类
  7. 抽象方法不能用private, final, static来修饰，因为这些关键字都和重写相矛盾（私有方法不能被子类覆盖）⭐⭐ 

抽象类小练习

很简单，试试吧~

package com.lili.abstract_;

public class AbstractExercise01 {
    public static void main(String[] args) {
        CommonEmployee lulu = new CommonEmployee("lulu", 11, 6000);
        lulu.work();
        Manager lili = new Manager("lili", 42, 10000, 6000);
        lili.work();
    }
}
package com.lili.abstract_;

public abstract class Employee {
    private String name;
    private int id;
    private double salary;

    public Employee(String name, int id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public abstract void work();
}

package com.lili.abstract_;

public class CommonEmployee extends Employee{
    public CommonEmployee(String name, int id, double salary) {
        super(name, id, salary);
    }

    @Override
    public void work() {
        System.out.println("普通员工" + getName() + "工作中...");
    }
}

package com.lili.abstract_;

public class Manager extends Employee{
    private double bonus;

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public Manager(String name, int id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.println("经理" + getName() + "工作中...");
    }
}

抽象类最佳实践——模板设计模式

job() 方法有动态绑定机制（绑定运行类型，见java入门第七天）

package com.lili.abstract_;

public abstract class Template {
    public abstract void job();

    public void calculateTime() {
        long start = System.currentTimeMillis();
        job(); //方法有动态绑定机制（绑定运行类型）
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间：" + (end - start));
    }
}

package com.lili.abstract_;

public class CalSum extends Template{
    @Override
    public void job() {
        long sum = 0;
        for (long i = 0; i < 800000; i++) {
            sum += i;
        }
    }
}

package com.lili.abstract_;

public class CalMul extends Template{
    @Override
    public void job() {
        long res = 1;
        for (long i = 1; i <= 100000; i++) {
            res *= i;
        }
    }
}

package com.lili.abstract_;

public class TestTemplate {
    public static void main(String[] args) {
        CalSum cal1 = new CalSum();
        cal1.calculateTime();
        CalMul cal2 = new CalMul();
        cal2.calculateTime();
    }
}

接口

  • 接口就是给出一些没有实现的方法，封装起来，某个类需要使用时，再具体实现。
  • 在接口中，抽象方法可以省略abstract关键字。

interface 接口名{

        //属性

        //方法

} 

class 类名 implements 接口名{

        //属性

        //方法       

        实现接口的抽象方法

}

在jdk7.0之前，接口中所以方法都没有方法体；

jdk8.0之后，接口中可以有静态方法、默认方法（需要用default关键字修饰），既可以具体实现方法。

接口细节

  1. 接口不能被实例化
  2. 接口中的所有方法都是public(可省略)，接口中的抽象方法可省略abstract修饰
  3. 一个普通类实现接口，必须将接口中的所有方法都实现 （快捷键alt+enter）
  4. 抽象类实现接口时，可以不用实现接口的抽象方法
  5. 一个类可以实现多个接口
  6. 接口中的属性只能是final的，接口属性都是public static final修饰
  7. 接口名.属性名
  8. 接口不能继承类，但能继承多个别的接口
  9. 接口的修饰符只能是public或默认，与类一样

answer:

接口属性修饰符为public static final

语法正确

输出：

23   23   23

接口与继承⭐

  1. 当子类继承了父类，子类就自动拥有了父类的功能，如果子类需要扩展功能，可以通过接口的方式扩展
  2. 可以理解为实现接口是对java单继承机制的一种补充
  3. 继承的价值在于解决代码的复用性和可维护性
  4. 接口的价值在于设计好各种规范，让其他类去实现这些方法
  5. 接口比继承更加灵活
  6. 接口在一定程度上实现代码解耦（接口规范性+动态绑定）

接口的多态特性 

  • 接口的多态体现在接口类型的变量可以指向实现了接口的类的对象实例（类的多态体现在父类类型的变量可以指向继承父类的子类的对象实例）
  • 接口多态参数（接口类型的形参可以接收实现接口的类实参）
  • 接口多态数组（接口类型的数组可以存储实现接口的类型实例）

package com.lili.interface_;

public interface Usb {
    void start();
    void end();
}

package com.lili.interface_;

public class Phone implements Usb {

    @Override
    public void start() {
        System.out.println("手机连接成功...");
    }

    @Override
    public void end() {
        System.out.println("手机断开连接...");
    }

    public void call() {
        System.out.println("电话呼叫中...");
    }
}

package com.lili.interface_;

public class Camera implements Usb{
    @Override
    public void start() {
        System.out.println("相机连接成功...");
    }

    @Override
    public void end() {
        System.out.println("相机断开连接...");
    }
}

package com.lili.interface_;

import com.lili.override_.Person;

public class InterfacePolyArr {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Camera camera = new Camera();
        Usb[] usbs = {phone, camera};
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].start();
            usbs[i].end();
            if(usbs[i] instanceof Phone) { //判断运行类型是否是Phone
                ((Phone) usbs[i]).call();
            }
        }
    }
}
  • 接口多态传递现象

接口小练习 

 

 answer：

有错误

错误在于x不明确，编译报错

想调用父类的x就使用super.x，想调用接口的x就使用A.x（接口的属性修饰符为public static final）!

内部类⭐

  • 一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）
  • 类的五大成员：属性、方法、构造器、代码块、内部类
  • 内部类的最大特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

内部类分类 （4种）

  • 定义在外部类局部位置上（比如方法中、代码块内）
  1. 局部内部类（有类名）
  2. 匿名内部类（没有类名，非常非常非常非常之重要！）
  • 定义在外部类的成员位置上 
  1. 成员内部类（没有static修饰）
  2. 静态内部类（用static修饰） 

局部内部类 

  1. 定义在外部类的局部位置上，如方法或代码块内
  2. 局部内部类可以直接访问外部类的所有成员，包括私有的
  3. 外部类要访问局部内部类方式：在其作用域内创建对象再访问
  4. 局部内部类地位与局部变量相同，不能用访问修饰符修饰，可以使用final修饰
  5. 局部内部类的作用域为定义它的方法体或代码块内 
  6. 如果外部类和局部内部类的成员重名时，遵循就近原则，若想访问外部类成员，就用（外部类名.this.成员名）去访问。理解：外部类.this就是外部类的对象，哪个对象在调用就是哪个对象。
package com.lili.innerclass;

public class LocalInnerClass {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.m1();
    }
}

class Outer01 {
    private int n1 = 100;

    public void m1() {
        System.out.println("外部类的m1()被调用...");
        class Inner01 {
            private int n1 = 800;

            public void m2() {
                System.out.println("局部内部类的m2()被调用...");
                //局部内部类可以直接访问外部类的所有成员，包括私有的
                //外部类和局部内部类的成员重名时，遵循就近原则
                System.out.println("局部内部类的n1 = " + n1);
                //若想访问重名外部类成员，就用（外部类名.this.成员名）访问
                System.out.println("外部类的n1 = " + Outer01.this.n1);
            }
        }
        //外部类要访问局部内部类方式：在其作用域内创建对象再访问
        Inner01 inner01 = new Inner01();
        inner01.m2();
    }

    public Outer01() {
    }

    {
        System.out.println("代码块被执行...");
        class Inner02 {
            public int n3 = 600;
        }
    }
}

 匿名内部类⭐⭐

  • 定义在外部类局部位置上，没有类名
  • 匿名内部类本质是一个类，同时还是一个对象⭐

基本语法：

new 类或接口(参数列表) {

        类体

};

annoymous--匿名的

  • 当需要定义一个类来继承父类或实现接口，而这个类又只想使用一次时，可以使用匿名内部类
  • 匿名内部类的类名由系统给出，对象.getClass()可以看到运行类型（系统给出的匿名内部类的类名）
  • 匿名内部类只能使用一次

匿名内部类使用细节

1. 匿名内部类本质是一个类，同时还是一个对象，调用匿名内部类的方法有2种

2. 匿名内部类可以直接访问外部类的所有成员，包括私有的

3. 不能直接添加访问修饰符，地位是局部变量

4. 作用域：定义它的方法或代码块中

5. 外部其他类不能访问匿名内部类

6. 如果外部类和匿名内部类的成员重名时，遵循就近原则，若想访问外部类成员，就用（外部类名.this.成员名）去访问。

匿名内部类的最佳实践

当作实参直接传递

package com.lili.innerclass;

public class AnnoymousInnerClass {
    public static void main(String[] args) {
        f1(new IA() {
               @Override
               public void sayHello() {
                   System.out.println("你好！");
               }
           }
        );
    }

    public static void f1(IA ia) {
        ia.sayHello();
    }
}


interface IA {
    void sayHello();
}

匿名内部类小练习

package com.lili.innerclass;

public class InnerClassExercise02 {
    public static void main(String[] args) {
        CellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("懒猪起床了");
            }
        });
        CellPhone.alarmClock(new Bell() {
            @Override
            public void ring() {
                System.out.println("小伙伴上课了");
            }
        });
    }
}

interface Bell {
    void ring();
}

class CellPhone {
    public static void alarmClock(Bell bell) {
        bell.ring();
    }
}

成员内部类

  • 定义在外部类的成员位置上 ，且没有static修饰
  • 可以直接访问外部类的所有成员，包括私有的
  • 可以添加任意访问修饰符，因为其地位是成员
package com.lili.innerclass;

public class MemberInnerClass {
    public static void main(String[] args) {
        new Outer().m1();
    }
}

class Outer {
    private int age = 21;
    public String name = "lulu";
    class Inner {  //成员内部类
        public void f1(){
            //可以直接访问外部类的所有成员，包括私有的
            System.out.println("name = " + name + " age = " + age);
        }
    }
    public void m1(){
        Inner inner = new Inner();
        inner.f1();
    }
}

外部其他类使用成员内部类的两种方式：

①Outer.Inner inner1 = outer1.new Inner();等号右边相当于对象.属性

②在外部类中编写一个方法返回内部类的实例

如果外部类和成员内部类的成员重名时，遵循就近原则，若想访问外部类成员，就用（外部类名.this.成员名）去访问。

静态内部类 

  • 定义在外部类的成员位置上 ，有static修饰
  • 可以直接访问外部类的所有静态成员，包括私有的，但不能访问非静态成员
  • 可以添加任意访问修饰符
  • 作用域为整个类

 外部其他类访问静态内部类的2种方式：

①Outer2.Inner2 inner2 = new Outer2.Inner2(); 等号右边相当于类名.属性

②在外部类中编写一个方法返回内部类的实例 Outer2.Inner2 inner21 = Outer2.getInner2();

  • 如果外部类和静态内部类成员重名，就近原则，访问外部类成员就用（外部类名.成员名）去访问。注意，没有this了！

内部类练习题

看看下段代码会输出什么？ 

new Test()会执行构造器，s1指向一个对象，s1的a = 10，s2指向又一个对象，s2的a = 5，并输出一个5 ；r也指向一个新的Inner对象，r的a = 5，输出一个5；

所以答案是输出2个5

枚举类（enumeration)

  • 枚举是一组常量的集合
  • 常量一般全大写
  • 枚举有2种：

①自定义类实现枚举

实现步骤：

1.构造器私有化，防止直接new

2.不定义setter方法，只定义getter方法，防止枚举值被修改

3.对枚举对象使用public final static修饰，实现底层优化

②使用enum关键字实现枚举

1.使用enum替代class

2.如果有多个常量对象，用逗号间隔

3.枚举对象必须放在枚举类的行首

4.使用enum关键字开发一个枚举类时，默认会继承Enum类，而且是一个final类（javap反编译）

5.如果使用无参构造器创建常量对象，则还可以省略实参列表和小括号（），只写常量名

 

  • 因为用enum关键字时，会隐式的继承Enum类 ，因此可以使用Enum类的相关方法。

枚举小练习

package com.lili.enumeration_;

public class EnumExercise {
    public static void main(String[] args) {
        Week[] weeks = Week.values();
        System.out.println("==所有的星期信息如下==");
        for (Week week:weeks){
            System.out.println(week);
        }
    }
}

enum Week {
    MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期三"),
    THURSDAY("星期四"),FRIDAY("星期五"),SATURDAY("星期六"),
    SUNDAY("星期日");
    private String desc;

    Week(String desc) {
        this.desc = desc;
    }

    @Override
    public String toString() {
        return desc;
    }
}

enum细节

  • 使用enum关键字后，就不能再继承其他类了，因为它已经隐式继承了Enum类（java是单继承机制）
  • enum实现的枚举类，本质还是一个类，可以实现接口
package com.lili.enumeration_;

public class EnumExercise02 {
    public static void main(String[] args) {
        Music.DAOXIANG.playing();
        Music.CRAZYOVERYOU.playing();
    }
}

class A{
}

//1.使用enum关键字后，就不能再继承其他类了
//enum Music extends A{
//}

interface IPlaying{
    void playing();
}

//2.enum实现的枚举类，本质还是一个类，可以实现接口
enum Music implements IPlaying{
    DAOXIANG("稻香"),CRAZYOVERYOU("Crazy Over You");
    private String name;

    Music(String name) {
        this.name = name;
    }

    @Override
    public void playing() {
        System.out.println("播放音乐" + this.toString() + "...");
    }

    @Override
    public String toString() {
        return name;
    }
}
Lili_1i1i
关注
专栏目录
java内部枚举类_内部类和枚举类
weixin_36332616的博客
02-15 4808
内部类：内部类的定义 :在一个类的内部又定义了一个类，里面的这个类就是内部类。内部类可以定义在外部类的成员位置(与成员变量的位置相同)或局部位置(意思是，把类写在外部类的方法里面)。什么时候使用内部类 :一个具体的事物里面还有一个具体的事物。比如汽车中有发动机。1、成员内部类1.将内部类，定义在了外部类的成员位置。2.成员内部类，可以使用成员修饰符：public、static等。但是一般也不写，因...
Java枚举和Java内部类
yishengqianan的博客
07-06 748
Java枚举是一个特殊的类，一般表示一组常量。Java 枚举类使用 enum 关键字来定义，各个常量使用逗号 ，来分割。每个枚举都是通过Class在内部实现的，而且所有的枚举值都是public static final 的 可以使用 for 语句来迭代枚举元素 枚举类型相当于特殊的类，经过编译之后同样产生一个class文件。枚举类型中可以定义方法（包括构造 方法）、属性、静态的方法和属性、继承接口、重载覆盖等，类似于class。 枚举类型的定义: enum 定义的枚举类默认继承了 java.lang.En
java 内部枚举类_Java内部类，枚举
weixin_34378986的博客
02-15 2453
模式:模板模式:简单工厂模式:适配器模式:interface ICellPhone{void sendMsg();}class Android implements ICellPhone{public void sendMsg(){System.out.println("我爱你");}}class ITCAST implements ICellPhone{public void sendMsg()...
抽象类，枚举类，内部类
serendipity_xr的博客
11-04 686
一.抽象类 抽象类是用类做功能描述，但是没有具体的执行 。 声明 使用 abstract 关键来修饰的类 就是抽象类 抽象类可以有普通类的所有成员,还可以有抽象方法,必须使用abstract关键字修饰。 抽象类不能自己直接实例化自己,它可以使用匿名对象写法来重写抽象类中的抽象方法。 抽象类可以被子类继承，子类可以拥有父类的所有非私有非静态的成员，但必须重写父类中的所有抽象方法。 在实际开发中 尽量少使用抽象类。要想父类中的方法没有具体的实现，就使用接口来做。 接口和抽象类的区别 接口只有静态常量、静态
Java基础——接口、枚举类
Yc317900的博客
08-15 966
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的is-a关系，而接口实现则是 "能不能"的has-a关系。接口的本质是契约、标准、规范，就像我们的法律一样。制定好后大家都要遵守。接口的定义，它与定义类方式相似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。引用数据类型：数组，类，枚举，接口，注解。
JAVA的抽象类，接口，枚举，内部类
weixin_59680226的博客
08-08 854
抽象类是不能被实例化的类，它用于定义一组相关的类的共同特性和行为。抽象类可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。其他类可以通过继承抽象类来扩展其功能，并实现抽象方法。抽象类一般用于定义抽象的概念和通用的方法，而具体实现则需要由子类完成。接口是一种完全抽象的类，它只包含方法的声明而没有方法的实现。接口可以看作是一组约定，定义了一组类应该实现的方法。其他类可以通过实现接口来达到多重继承的效果，一个类可以实现多个接口。
Java编写抽象类、内部类代码出现的报错
weixin_42120773的博客
02-07 830
抽象类有这么几个要求：抽象类必须被继承，抽象方法必须被重写，抽象方法不能直接实例化。 在编写抽象类代码的时候，我遇到过这样的报错：abstract methods do not specify a body. 检查之后发现，尽管抽象类里边的抽象方法代码已经被注释掉了，但是{}还放在那里，这个是不应该有的，也是这次引起报错的原因。 继承类中重写抽象方法时可以有方法体。 内部类是Java中很重...
java枚举类详解
weixin_43604021的博客
08-09 3603
枚举类基础
Java 枚举类中可以定义抽象方法
听海边涛声
06-05 708
Java 枚举类中可以定义抽象方法，但该枚举类中必须包含至少一个常数，且所有常数都包含类体，在类体中实现了枚举类定义的抽象方法
java抽象类和接口定义与用法详解
08-25
Java 抽象类和接口定义与用法详解 Java 抽象类是一种特殊的类，它提供了一个模板，所有的子类都是在此模板的基础之上添加和修改完善功能而创建出来的。抽象类定义了抽象方法，即没有具体实现的方法，子类必须实现...
Java枚举类的使用与注解
01-20
1. 枚举类可以直接实现接口，并在枚举类内部定义接口的抽象方法。 2. 或者，每个枚举实例可以分别实现接口中的抽象方法，这样每个实例的行为可能不同。 五、注解（Annotation）概述： 注解是一种元数据，提供了将...
java 枚举抽象方法_枚举系列(五)：包含抽象方法的枚举类
weixin_33283826的博客
02-16 556
假设有一个Operation枚举类，它的四个枚举值PLUS，MINUS，TIMES，DIVIDE分别代表加，减，承，除四种运算。为此，定义下面的Operation枚举类。public enum Operation{PLUS, MINUS, TIMES, DIVIDE;//为枚举类定义一个方法，用于实现不同的运算double eval(double x, double y){switch(this)...
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 378
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
Java安卓开发之Fragment开发（通俗易懂版）——第8章
一个脚本小子的博客
10-13 680
FragmentManager中的getSupportFragmentManager()方法不支持Activity，不论是旧版的FragmentManager还是新版的，因此我们要把继承Activity类改成继承AppCompatActivity类。
确保Spring Boot定时任务只执行一次方案
2301_76419561的博客
10-14 467
确保Spring Boot定时任务只执行一次有多种方法，你可以根据实际需求选择最适合的方法。如果你需要更复杂的任务调度或周期性执行，@Scheduled注解和接口是更合适的选择。而对于一次性的初始化任务或应用程序启动任务，注解和实现接口则更为简洁明了。
SpringBoot智能物流管理系统开发指南
最新发布
2401_85762266的博客
10-18 796
在概念模式的设计中，E-R模型法是最常见的设计方法。B/S架构的运行方式是在远程的服务器上把开发的软件系统部署在远程的服务器上，在部署好软件系统之后就可以实现在任何接入互联网的电脑上访问部署好的软件系统。6、网络上的客户端和服务器可以用来编程任何独立的编程环境，也有中国，GB2312，BIG5，日文写作，一般基金，用于支持多国语言，并且可以嵌入在数据表和其他软件shift_jis访问柱可以用作的名称。编程语言，如C, C ++，Python和Java的，的Perl，PHP，埃菲尔铁塔，Ruby和Tcl的。
【SpringBoot的启动、处理请求整体流程（二）】
m0_50149847的博客
10-13 900
同时，如果文章有错误，也欢迎批评指正。本篇文章继之后，可以先阅读第一篇文章。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 993
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
spring task的使用场景
qq_40603125的博客
10-13 335
spring任务调度框架约定的时间。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Lili_1i1i

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

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

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

打赏作者

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

抵扣说明：

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

余额充值