【Day02-多态、抽象类、接口】

已于 2024-08-28 11:31:58 修改
阅读量537 收藏 10
点赞数 25
文章标签： java 开发语言 学习 经验分享 笔记
于 2024-08-28 11:30:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Doshaxin/article/details/141596577
版权

 1.多态        

        1.1 么是多态？

                多态是在继承或者实现情况下的一种现象，表现为：对象多态、行为多态。

        1.2 多态的具体代码体现

         1.3 多态的前提

  1.                 有继承/实现关系
  2.                 有方法的重写
  3.                 存在父类引用指向子类对象

         1.4 多态的注意事项 

                多态是对象、行为的多态，Java中的属性(成员变量)不谈多态。 

/*
多态
    是在继承/实现情况下的一种现象, 表现为对象多态和行为多态
    对象多态：子类对象可以多态创建一个Person类，它的对象可以是他子类中的任意一个Student(),Teacher()
    ps:父类 对象名 = new 对象类；new什么对象名就是什么
    行为多态：指的是子类重写了父类的方法，执行类方法时，执行的时重写的类方法
    ps:父类中没有定义的方法，在子类存在，但是多态不能使用子类的自有的方法
多态的前提
    1. 有继承/实现关系
    2. 有方法的重写
    3. 存在父类引用指向子类对象

多态的注意事项
    多态是对象、行为的多态； 变量则不涉及多态
	
代码执行:
    编译看左，运行看右
*/
public class Demo {
    public static void main(String[] args) {
        //使用多态的形式创建Student对象
        People p1 = new Student();
        p1.run();//后空翻跑步
//        p1.study();虽然子类定义了study方法，但是在多态形式下，不能调用子类独功能；
        p1.drink();//喝口水：只是继承来的方法，行为多态存在父类引用指向子类对象
        //使用多态的形式创建Teacher对象
        People p2 = new Teacher();
        p2.run();//颤颤巍巍跑步
    }
}

//定义父类People, 内含跑步run方法
class People {
    public void run() {
        System.out.println("正常人跑步");
    }
    public void drink() {
        System.out.println("喝口水");
    }
}
//定义子类Student, 内含跑步run方法
class Student extends People {
    public void study() {
        System.out.println("我正在学习");
    }
    @Override
    public void run() {
        System.out.println("后空翻跑步");;
    }
}
//定义父类Teacher, 内含跑步run方法
class Teacher extends People {
    @Override
    public void run() {
        System.out.println("颤颤巍巍跑步");
    }
}

         1.5 多态的好处与弊端

  • 在多态形式下，等号左右两边松耦合，更便于修改和维护
  • 定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利

/*
多态的好处
    1. 在多态形式下，等号左右两边松耦合，更便于修改和维护
    2. 在多态下, 定义方法时, 可以使用父类类型作为形参, 那么该方法可以接收该父类下所有子类的对象
*/
public class Demo {
    public static void main(String[] args) {
        //好处1: 在多态形式下，等号左右两边松耦合，更便于修改和维护
        //创建一个老师对象,调用5次跑步的方法=======有一天需求改了========>创建一个学生对象,调用5次跑步的方法
        Teacher teacher = new Teacher();
        teacher.run();
        teacher.run();
        teacher.run();
        teacher.run();
        teacher.run();
        //又得改成Student()
        Student student = new Student();
        student.run();
        student.run();
        student.run();
        student.run();
        student.run();
        //用多态的话就避免了这种情况
        Person person = new Student();//需要什么对象改成什么对象
        person.run();
        person.run();
        person.run();
        person.run();
        person.run();
        //好处2: 在多态下, 定义方法时, 可以使用父类类型作为形参, 那么该方法可以接收该父类下所有子类的对象
        Person p1 = new Student();
        Person p2 = new Teacher();
        login(p1);//登陆成功，请开始学习
        login(p2);//登陆成功，请开始备课
    }

    //好处2: 在多态下, 定义方法时, 可以使用父类类型作为形参, 那么该方法可以接收该父类下所有子类的对象
    //创建一个run方法,接收一个老师对象,然后调用对象的run方法=======有一天需求改了========>接收一个学生对象,然后调用对象的run方法
    public static void run(Teacher teacher){
        teacher.run();
    }
    public static void run(Student student) { student.run(); }//这样写也很麻烦，需要new一个新对象，然后再用对象调用

    public static void login(Person person) {
        //验证用户账号和密码（省略）
        //跳转到不同的页面
        person.jump();
    }
}

class Person{
    public void run(){}
    public void jump() {
        System.out.println("登陆成功");
    }
}

class Student extends Person{
    @Override
    public void run() {
        System.out.println("学生跑的快");
    }

    public void jump() {
        System.out.println("登陆成功，请开始学习");
    }
}

class Teacher extends Person{
    @Override
    public void run() {
        System.out.println("老师跑的慢");
    }

    public void jump() {
        System.out.println("登陆成功，请开始备课");
    }
}
/*
多态的弊端
    不能直接使用子类特有的功能
    解决方案: 强制类型转换

多态中的转型
    子-->父 (小到大 自动转换): 也称为向上转型, 父类引用指向子类对象 Person p = new Student();
    父-->子 (大到小 强制转换): 也称为向下转型, 父类引用转为子类对象 Student s = (Student)p;

强转风险
    强转是存在风险的, 如果转为父类引用记录的真实子类对象,那么不会报错(否则会报ClassCastException)
    如果想规避这个风险,可以在强转前,使用instanceof关键字, 判断变量对应的类型
*/
public class Demo {
    public static void main(String[] args) {
        //传入一个老师对象
        run(new Teacher());
    }

    public static void run(Person person){
        //调用老师的run()方法
        person.run();
        //为了防止坏B使坏，我们可以先判断一下传来的类是不是Teacher
        if (person instanceof Teacher){
            //需求: 想再调用一下老师的teach()方法
            Teacher teacher = (Teacher) person;
            teacher.teach();
        } else {
            System.out.println("哈哈，被我识破了吧");
        }
    }
}

class Person{
    public void run(){}
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("学生跑的快");
    }

    public void study(){
        System.out.println("学生在学习~~~~");
    }
}

class Teacher extends Person {
    @Override
    public void run() {
        System.out.println("老师跑的慢");
    }

    public void teach(){
        System.out.println("老师在上课~~~~");
    }
}

         1.6 总结

        1.7 final 关键字

        1、final修饰的类、方法、变量各有什么特点？

                修饰类：该类被称为最终类, 类不能再被继承

                修饰方法：该方法被称为最终方法, 方法不能被重写

                修饰变量：该变量只能被赋值一次, 赋值完毕之后不能再修改

        2、final修饰基本类型和引用类型的变量有啥区别？

                final修饰基本类型的变量，变量存储的数据不能被改变

                final修饰引用类型的变量，变量存储的地址不能被改变

                但地址所指向对象中的内容是可以被改变的。

/*
final关键字是最终的意思，可以修饰（类、方法、变量）
    修饰类：该类被称为最终类, 类不能再被继承
    修饰方法：该方法被称为最终方法, 方法不能被重写
    修饰变量：该变量只能被赋值一次, 赋值完毕之后不能再修改
        成员变量: 声明时赋完值,或者在构造方法结束之前完成赋值
        局部变量: 变量只能被赋值一次

final修饰变量的注意事项
    基本类型变量: 变量记录的数据不能再被改变
    引用类型变量: 变量记录的地址不能再被改变, 但是地址对应的堆内存中的内容可以改变
*/
public class Demo {
    public static void main(String[] args) {
        final int age;
        age = 20;//局部变量: 变量只能被赋值一次
//        age = 18;//Variable 'age' might already have been assigned to
    }
}

class Father {
    public void run() {
        System.out.println("爸爸在跑");
    }
}

final class Son extends Father {
    String name;
    final String school = "12";
//    school = "12";//Variable 'school' might not have been initialized 声明时赋完值,或者在构造方法结束之前完成赋值
    @Override
    public void run() {//修饰方法，就不能被重写
        int age = 10;
        System.out.println(age + "岁的儿子在跑");
    }
}
//class uncle extends Son{//Cannot inherit from final 'd_final.Son'修饰类就不能被继承
//
//}

2.抽象类

        2.1 什么是抽象类

  • 在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。
  • abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

        2.2 抽象类的特点

  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
  • 类该有的成员（成员变量、方法、构造器）抽象类都可以有。
  • 抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
  • 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
/*
抽象类和抽象方法
    在Java中有一个关键字叫：abstract，它就是抽象的意思，可以用它修饰类、成员方法。
        abstract修饰类，这个类就是抽象类
        abstract修饰方法，这个方法就是抽象方法，抽象方法没有方法体

抽象类的特点
    1. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
    2. 类该有的成员（成员变量、方法、构造器）抽象类都可以有。
    3. 抽象类最主要的特点：抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
    4. 一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
*/
public class Demo {
    public static void main(String[] args) {
        Person person = new Student();
        person.run();
//        new Person();//'Person' is abstract; cannot be instantiated 抽象类是无法创建对象的
    }
}

//需求1: 将Person类声明为抽象类
abstract class Person {
    //成员变量
    private String name;

    //成员方法
    public void eat(){
        System.out.println("吃饭");
    }

    //需求2: 将run方法修改为抽象方法
    public abstract void run();
}

class Student extends Person{

    @Override
    public void run() {
        System.out.println("后空翻跑步");
    }
}

class Teacher extends Person{

    @Override
    public void run() {
        System.out.println("拉爆博尔特");
    }
}

        2.3 使用抽象类的场景和好处

多个类中只要有重复代码（ 包括相同的方法签名 ），我们都应该抽取到父类中去，此时，父类中就有可能存在只有方法签名的方法，这时，父类必定是一个抽象类了， 我们抽出这样的抽象类，就是为了更好的支持多态。 （可以减少编写重复代码的繁琐） 

/*
抽象类的应用场景和好处
    1、将所有子类中重复的代码，抽取到抽象的父类中，提高了代码的复用性(先编写子类，再编写抽象类)
    2、我们不知道系统未来具体的业务时，可以先定义抽象类，将来让子类去继承实现，提高了代码的扩展性 (先编抽象类，再编写子类)

需求
    某宠物游戏，需要管理猫、狗的数据。
        猫的数据有：名字；行为是：喵喵喵的叫~
        狗的数据有：名字；行为是：汪汪汪的叫~
*/
public class Demo {
    public static void main(String[] args) {
        Animal an1 = new Cat();
        Animal an2 = new Dog("雪豹");
        an1.setName("小馋猫");
        an1.cry();
        an2.cry();
    }
}

//动物
abstract class Animal {
    private String name;

    public Animal() {
    }

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public abstract void cry();
}

//猫
class Cat extends Animal {
    public Cat() {
        super();
    }

    public Cat(String name) {
        super(name);
    }

    @Override
    public void cry() {
        System.out.println(super.getName() + "，喵喵叫");
    }
}

//狗
class Dog extends Animal {

    public Dog(String name) {
        super(name);
    }

    @Override
    public void cry() {
        System.out.println(super.getName() + "，你不要给我汪汪叫");
    }
}

        2.4 模板方法设计模式

        一个功能的完成需要经过一系列步骤,这些步骤是固定的,但是中间某些步骤具体行为是待定的,在不同的场景中行为不同

        值得注意的是：如果使用模板方法之后，建议用 final 关键字进行修饰，这样可以有效避免子类重学模板方法，致使模板方法失效。 

/*
设计模式
    对于某类问题,前人总结出类的解决问题的套路

模板方法设计模式
    一个功能的完成需要经过一系列步骤,这些步骤是固定的,但是中间某些步骤具体行为是待定的,在不同的场景中行为不同

使用思路
    1、定义一个抽象类(Person作为父类)，提供模板方法
    2、模板方法中，需要让子类自己实现的地方，定义为抽象方法
    3、子类(Teacher Student)只需要继承该抽象类，重写抽象方法即可完成些完成的功能

多学一招:
    建议使用final关健字修饰模板方法
        模板方法是给对象直接使用的，不能被子类重写
        一旦子类重写了模板方法，模板方法就失效了
*/
public class Demo {
    public static void main(String[] args) {
        Person person = new Teacher();
        person.work();
    }
}
abstract class Person {
    public final void work() {//为了避免子类重写方法，影响代码执行，如果不加会执行Student类中的重写方法work
        System.out.println("吃饭");
        doWork();
        System.out.println("睡觉");
    }
    public abstract void doWork();
}
class Student extends Person {
//    @Override
//    public void work() {
//        System.out.println("捣蛋鬼别捣蛋");
//    }

    @Override
    public void doWork() {
        System.out.println("学习");
    }
}

class Teacher extends Person {

    @Override
    public void doWork() {
        System.out.println("教课");
    }
}

 3.接口

       3.1 认识接口

/*
接口
    Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口

定义格式
    public interface 接口名 {
        成员变量（接口中的成员变量都是常量, 默认是被public static final修饰的）
        成员方法（接口中的成员方法都是抽象方法, 默认是被public abstract修饰的）
        注意: 接口中不能有构造方法和代码块
    }

注意事项
    1. 接口不能直接创建对象
    2. 接口是用来被类实现（implements）的，实现接口的类称为实现类。
    3. 一个类可以实现多个接口，实现类实现多个接口，必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。
        修饰符 class 实现类 implements 接口1, 接口2, 接口3 , ... {}
*/
public class Demo {
    public static void main(String[] args) {
        //面向接口编程，创建对象，调用方法  接口 变量 = new 实现类()
        UserInterface ui = new UserInterfaceImpl();
        ui.save();
    }
}

//接口
public interface UserInterface {
    //定义成员变量，默认会有 public static final
    String name = "顶真";

    //定义成员方法，默认会有 public abstract
    void save();//保存用户顶真
}

//实现类
public class UserInterfaceImpl implements UserInterface{
    @Override
    public void save() {
        System.out.println("保存用户" + UserInterface.name );
    }
}

        接口其实和多态差不多，只是多态是类的多态，接口则是创建一个接口，在JDK 8 之前接口中只能定义一些成员变量和成员方法（抽象的，需要被重写），但在JDK 8 之后接口新增了三个特性，使得接口内可以定义其他内容。          

        3.2 接口的好处

                接口的好处：一句话带过就是解耦合（让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现）。可以看看代码，帮助与理解什么是解耦合。

/*
接口特点、好处
   让程序可以面向接口编程，这样程序员就可以灵活方便的切换各种业务实现。(解耦合)
*/

//使用这个类  模拟一个调用这角度的类
public class Demo {
    public static void main(String[] args) {
        UserService ui = new UserServiceImpl1();
        //这种还不是最大程度的解耦合只是帮助理解，可以根据登录的方式不同直接改上边使用的实现类
        ui.register();
        ui.login();
    }
}

//接口
public interface UserService {
    void register();

    void login();
    
}

//这是一个用户操作类,可以完成用户的注册、登录功能
class UserServiceImpl1 implements UserService{

    // 注册
    @Override
    public void register() {
        System.out.println("手机号/验证码登录");
    }
    // 登录
    public void login() {
        System.out.println("登陆成功");
    }
}

public class UserSeviceImpl2 implements UserService{
    @Override
    public void register() {
        System.out.println("账号/密码登陆");
    }

    @Override
    public void login() {
        System.out.println("登录成功");
    }
}

         3.3 接口的其他细节

                方法签名冲突是指：在一个类/接口继承的两个类/接口中，两个类/接口有相同的方法（方法名、形参、返回值都一样），这样会导致方法冲突。

完球了
关注
  • 25
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
day12-多态-抽象类-接口
weixin_43704154的博客
12-03 157
1.多态 1.1多态的概述（记忆） 什么是多态 ​ 同一个对象，在不同时刻表现出来的不同形态 多态的前提 要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象 1.2多态中的成员访问特点（记忆） 成员访问特点 成员变量 ​ 编译看父类，运行看父类 成员方法 ​ 编译看父类，运行看子类 代码演示 动物类 public class Animal { ...
day02-多态-Final-抽象类-接口【JAVA】
uhb1223的博客
08-10 79
学习面向对象高级的第二天
Java----多态+抽象类+抽象方法+接口
你好牛蛙！
02-08 2450
Java基础创作日记 Day05 时间：2021年2月7日下午 阴 昨天的前天的总结少了点东西，今天补充上 文章目录抽象+接口抽象方法抽象类接口 抽象+接口 抽象方法 当我们创建一个父类，父类的一些方法需要后代进行重写，此时父辈不需要写入任何代码，此时我们就可以把这些方法不写方法体，设置为抽象方法 语法： abstract void 方法名(); 抽象类 含有抽象方法的类必须要用abstract修饰，用abstract修饰的类叫做抽象类，抽象类可以不含有抽象方法 语法：abstract class 类名.
day09-多态，抽象类以及接口
UesugiSakuyad的博客
03-04 106
1:final关键字(掌握) (1)是最终的意思，可以修饰类，方法，变量。 (2)特点： A:它修饰的类，不能被继承。 B:它修饰的方法，不能被重写。 C:它修饰的变量，是一个常量。 (3)面试相关： A:局部变量 a:基本类型 值不能发生改变 b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的 B:初始化时机 a:只能初始化一次。 b:常见的给值 定义的...
day02-面向对象-多态&抽象类&接口
最新发布
qq_58478983的博客
08-27 770
多态概述、多态的好处与弊端、抽象类的概述、抽象类的场景和好处、模板方法设计模式、接口概述、接口特点和好处、接口新特性、接口注意事项、总结
Day02-多态-抽象类-接口-final
qq_25574081的博客
03-25 71
特点：1.抽象类不能直接创建对象 -因为他是抽象的描述某种事物的，且描述事物的 时候，有些功能只是知道有，但是具体如何完成，不确定，需要由具体的子类完成。==8 -----------新增了默认方法 使用default修饰的方法，带方法体，可以用实现类对象调用 注意：当多个接口中 有重名的默认方法的时候，实现类必须重写！2.强制类型转换 （一旦将多态形式的对象，转成了子类的原始类型，就可以使用子类特有的方法了）
day11-多态&抽象类&接口
wangyosh的博客
03-07 206
1.多态 1.1多态概述 同一个对象，在不同时刻表现出来的不同形态 举例：猫 我们可以说猫是猫：猫 cat = new 猫(); 我们也可以说猫是动物：动物 animal = new 猫(); 这里猫在不同的时刻表现出来了不同的形态，这就是多态 多态的前提和体现 有继承/实现关系 有方法重写 有父类引用指向子类对象 Animal.java package com.itheima_01; public class Animal { public void eat() { Sys
【JavaEE】Day02-多态&抽象类&接口
weixin_45876487的博客
12-03 264
多态&抽象&接口 1.多态 1.多态的概念(记忆) 什么是多态 指的是"对象"的多种形态 ​ 同一个对象,在不同时刻表现出来的不同形态 多态的前提 ​ 要有继承或实现关系 ​ 要有方法的重写 ​ 要有父类引用指向子类对象 格式:父类|接口 变量名 = new 子类|实现类 例如: Animal a = new Cat(); Animal a = ne...
2021-07-31 复习 java进阶 day02-多态&抽象类&接口
小虫虫的博客
07-31 135
复习 java进阶 day02-多态&抽象类&接口1.多态1.1多态的概述（记忆）1.2多态中的成员访问特点（记忆）1.3多态的好处和弊端（记忆）1.4多态中的转型（应用）1.5多态的案例（应用）2.抽象类2.1抽象类的概述（理解）2.2抽象类的特点（记忆）2.3抽象类的成员特点（记忆）2.4抽象类的案例（应用）3.接口3.1接口的概述（理解）3.2接口的特点（记忆）3.3接口的成员特点（记忆）3.4接口的案例（应用）3.5类和接口的关系（记忆）*3.6抽象类和接口的区别（记忆）*4.综合案
day02-多态&抽象类&接口
06-11
day02-多态&抽象类&接口
day02-多态&抽象类&接口1
08-04
在测试类AnimalDemo中，我们通过多态的方式实现了对猫和狗的处理： - 使用Animal类型的引用a指向Cat对象，调用eat()方法，实际上执行的是Cat类的eat()方法。 - 为了访问Cat类的特有方法playGame()，我们需要对a进行...
day14-面向对象-多态&final&抽象类
12-12
在这种情况下，我们可以使用多态来将 Person 类的引用指向 Teacher 类或 Doctor 类的对象，从而实现不同的表现形式。 在 Java 中，我们需要注意多态中的成员变量访问原则，即编译时检查父类中是否有该成员变量的...
C++day15-多态 文档
10-28
抽象类的作用主要是作为其他类的基类，提供统一的接口，但不提供具体的实现。这种方式常用于设计模式中的工厂方法、策略模式等，使得具体实现可以延迟到派生类中。 此外，C++11引入了`override`关键字，用于明确...
day10-final、接口、多态.pdf
11-02
"day10-final、接口、多态.pdf" 本文档主要讲解了 Java 语言中的 final 关键字、接口和多态的概念。 首先，final 关键字用于修饰不可改变的内容，可以修饰类、方法和变量。被 final 修饰的类不能被继承，方法不能...
阿里云服务器 篇七：服务器热备份/定时备份
生活在别处
08-24 106
Python 客户端用于百度云（个人云存储）百度云/百度网盘 Python 客户端。它主要用于在 Linux 环境下通过命令行操作百度云盘的 2TB 存储空间。是一个Github开源项目，这是一个百度云/百度网盘Python客户端。: 列出百度 PCS 中的 ‘remotepath’ 目录。: 从本地目录同步到远程目录。: 在百度云中创建一个目录。
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 176
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 607
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
笔记redis
风止的博客
08-22 1101
Redis（Remote Dictionary Server）是用C语言开发的一个基于的数据库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值