11-Java多态抽象接口

最新推荐文章于 2021-11-01 16:26:00 发布
最新推荐文章于 2021-11-01 16:26:00 发布
阅读量205 收藏 2
点赞数 1
分类专栏： Java语言学习 java全栈架构 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41200424/article/details/81322413
版权

1.多态（polymorphic）概述

       #事物存在的多种形态

2.多态前提

       #a.要有继承关系

       #b.要有方法重写

       #c.要有父类引用指向子类对象

3.案例演示

        代码体现多态

class Animal{
    public void set(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal {
    public void eat(){
        System.out.println("猫吃鱼")
    }
    public static void main(String[] args){
        Cat c = new Cat();
        c.eat();
        Animal a = new Cat();//多态：父类引用指向子类对象
        a.eat();
    }
}

多态的中的成员访问特点之成员变量

class Father{
    int num = 10;
}
class Son extends Father{
    int num = 20;
    public static void main(String[] args){
        Father f = new Son();
        System.out.println(f.num);
    }
}

输出10；编译看左边，运行看左边

多态中的成员访问特点之成员方法

成员方法，编译看左边，运行看右边

class Father{    
    int num = 10;
    public void print(){
        System.out.println("father");
    }
    public static void main(String[] args){
        Father n = new Son();
        n.print();
    }
}

class Son extends Father{
    int num = 20;
    public void print(){
        System.out.println("son");
    }
}

多态中的成员访问特点之静态成员方法

静态方法

        编译看左边，运行看左边（静态和类相关，算不上重写，所有，访问还是左边的）

        只有非静态的成员方法，编译看左边，运行看右边

class Father{    
    int num = 10;
    public void print(){
        System.out.println("father");
    }
    public static void method(){
        System.out.println("static in father");
    }
    public static void main(String[] args){
        Father n = new Son();
        n.method();
    }
}

class Son extends Father{
    int num = 20;
    public void print(){
        System.out.println("son");
    }
    public static void method(){
        System.out.println("static in son");
    }
}

超人故事

class SuperMan{
    public static main(String[] args){
        Person p = new SuperMans();//父类引用指向子类对象
        System.out.println(p.name);
        p.tan();
        //p.fly();//报错
        //向上转型和向下转型，后面讲
    }
}
class Person{
    String name = "John";
    public void tan(){
        System.out.println("谈生意");
    }
}
class SuperMans extends Person{
    String name = "superMan";
    public void tan(){
        System.out.println("谈几个亿的大单子");
    }
    public void fly(){
        System.out.println("飞出去救人");
    }
}

多态中向上转型和向下转型

案例演示，修改上面的代码

Person p = new SuperMans();//向上转型

SuperMans sm = (SuperMans) p;//向下转型 

大家可以试着修改一下上面的代码

*多态的好处与弊端

A.多态的好处

提高了代码的维护性（继承保证）

提高了代码的扩展性（由多态保证）

B：案例演示

多态的好处

可以当作形式参数，可以接受任意子类对象

多态的弊端

不能使用子类的特有属性和行为

class Animal{
    public void eat(){
        System.out.println("动物吃饭");
    }
}
class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }

    public static void main(String[] args){
        methed(new Cat());
        methed(new Dog());

    }
    public static void method(Animal c){//开发中好处的体现，当参数的时候好处多
      //  c.eat();
//关键字instanceof 判断前边的引用是否是后边的数据类型
        if( a instanceof Cat){
            Cat c = (Cat) a;
            c.eat();
            c.catcjMouse();
        }else if(a instanceof Dog){
            Dog d = (Dog) a;
            d.eat();
            d.lookHome();
        }else{
            a.eat();
        }
    }
}
class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
    public void lookHome(){
        System.out.println("狗看家");
    }

抽象类的概述及其特点

A:抽象类概述

抽象就是看不懂的

B:抽象类特点

抽象类和抽象方法必须用abstract关键字修饰

abstract class 类名 {}

public abstract void eat();

抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口

抽象类不能实例化那么，抽象类如何实例化呢？

按照多态的方式，由具体的子类实例化，其实这也是多态的一种，抽象类多态。

抽象类的子类

要么是抽象类

要么重写抽象类中的所有抽象方法

案例演示

abstract class Animal{
//抽象类
    public abstract void eat();
//抽象方法
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");//继承抽象类必须重写
    }
}
class Abstract{
    public static void main(String[] args){
        Animal a = new Cat();
        a.eat();
    }
}

抽象类特点

抽象类的成员特点

A.抽象类的成员特点

a.成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量？不能修饰成员变量

b:构造方法：有。

用于子类访问父类数据的初始化。

c:成员方法：既可以是抽象的，也可以是非抽象的。

案例演示

abstract class Demo{//成员变量不可以抽象
    int num1 = 10;
    final int num2 = 20;
    public Demo (){//构造器
    System.out.println("父类空参构造");
    }
    public void print(){
        System.out.println("爱你哟");
    }
    public abstract void method();
}
class Test extends Demo{
    public void method (){
        System.out.println("啦啦啦,啦啦啦，我是卖报的小行家");
    }
}

葵花宝典

案例演示：抽象类的作用

class kuihuabaodian{
    public static void main(String[] args){
        岳不群 a = new 岳不群();
        a.自宫();
    }
}
abstract class kuihua{
    public abstract void 自宫();
}
class 岳不群 extends kuihua{
    public void 自宫(){
        System.out.println("用牙签");
    }
}
class 林平之 extends kuihua{
    public void 自宫(){
        System.out.println("用指甲刀");
    }
}
class 东方不败 extends kuihua{
    public void 自宫{
        System.out.println("用锤子，惨不忍睹");
    }
}

抽象类练习猫狗案例

a.案例演示

具体事物：猫、狗

共性：姓名、年龄、吃饭

猫的特性：抓老鼠

狗的特性：看家

class Test_Animal{
    public static void main(String[] args){
        Cat c = new Cat("加菲",8);
        System.out.pritnln(c.getName() + "..." + c.getAge());
        c.eat();
        c.catchMouse();
        Dog c = new Dog("巴特",2);
        System.out.pritnln(c.getName() + "..." + c.getAge());
        c.eat();
        c.look();

    }
}
abstract class Animal {
    private String name;
    private int age;
    public Animal(){}//空参
    public Animal(String name,int age){
        this.name=name;
        this.age =age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age
    }
    public int getAge()
    {
        return age;
    }
    public abstract void eat();//吃饭
}
class Cat extends Animal{
    public Cat(){}//空参
    public Cat(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}
class Dog extends Animal{
    public Dog(){}//空参
    public Dog(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("狗吃肉");
    }
    public void look(){
        System.out.println("狗看家");
    }
}

抽象类练习老师案例

案例演示 

具体事物：高中老师，大学老师

共性：姓名、年龄、讲课

具体事务：高中生，大学生

共性：姓名、年龄、学习

class Test_Animal{
    public static void main(String[] args){
        BaseTeacher bt = new BaseTeacher("加菲",18);
        bt.teach();
        CollegeTeacher c = new CollegeTeacher("巴特",22);
        System.out.pritnln(c.getName() + "..." + c.getAge());
        c.teach();
    }
}
abstract class Teacher {
    private String name;
    private int age;
    public Teacher(){}//空参
    public Teacher(String name,int age){
        this.name=name;
        this.age =age;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        this.age = age
    }
    public int getAge()
    {
        return age;
    }
    public abstract void teach();//讲课
}
class BaseTeacher extends Teacher{
    public BaseTeacher(){}//空参
    public BaseTeacher(String name,int age){
        super(name,age);
    }
    public void teach(){
        System.out.println("我的姓名是："+this.getName+"我的年龄是:"+this.getAge+"讲的内容是"+"高中课程");
    }
}
class BaseTeacher extends Teacher{
    public BaseTeacher(){}//空参
    public BaseTeacher(String name,int age){
        super(name,age);
    }
    public void teach(){
        System.out.println("我的姓名是："+this.getName+"我的年龄是:"+this.getAge+"讲的内容是"+"大学课程");
    }
}

抽象类练习员工案例

A.案例演示

假如我们在开发一个系统时需要队程序员类进行设计，程序员包含3个属性：姓名、工号以及工资。

经理，除了含有程序员的属性外，另外还有一个奖金属性。

请使用继承的思想程序设计处程序员类和经理类。要求类中提供必要的方法进行属性访问。

class Test_employee
{
    public static void main(String[] args){
        Coder c = new Coder("德玛西亚","007",8000);
        c.work();
        Manager m = new Manager("苍老师","9527",3000,20000);
        m.work();
    }
}
abstract class Employee{
    private String name;
    private String id;
    private double salary;//工资
    public Employee(){}//空参构造
    public Employee(String name,String id ,double salary){
        this.name=name;
        this.id=id;
        this.salary=salary;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setId(String id){
        this.id=id;
    }
    public String getId(){
        return id;
    }
    public void setSalary(double salary){
        this.salary=salary;
    }
    public double getSalary(){
        return salary;
    }
    public abstract void work();
}
class Coder extends Employee{
    public Coder(){}
    public Coder(String name,String id,double salary){
        super(name,id,salary);
    }
    public void work(){
        System.out.println("我的姓名是："+this.getName()+",我的工号是："+this.getId()+"我的工资是："+this.getSalary+"我的工作内容是敲代码");
    }
}
class Manager extends Employee{
    private int bonus;//奖金
    public Manager(){}
    public Manager(String name,String id,double salary,int bonus){
        super(name,id,salary);
        this.bonus=bonus
    }
    public void work(){
        System.out.println("我的姓名是："+this.getName()+",我的工号是："+this.getId()+"我的工资是："+this.getSalary+"我的工作是管理程序员"+"，我的奖金是"+bonus);
    }
}

抽象类中的面试题

a:一个抽象类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？

答：可以，这么做目的只有一个，就是不让其他类创建本类对象，交给子类完成

b:abstract不能和哪些关键字共存

static:被abstract修饰方法没有方法体，被static修饰的可以用类名.调用，但是类型.调用抽象方法是没有意义的

final：被abstract修饰的方法强制子类重写，被final修饰的不让子类重写，所以他俩是矛盾

private:被abstract修饰的是为了让子类看到并强制重写，被private修饰不让子类访问，所以他俩是矛盾的

接口的概述及其特点

a:接口概述

从狭义的角度讲就是之java中的interface

从广义的角度讲对外提供规则的都是接口

B:接口的特点

接口用关键字interface表示

interface 接口名 {}

类实现接口用implements表示

class 类名 implements 接口名{}

接口不能实例化

那么接口如何实例化呢？

按照多态的方法来实例化

接口的子类

可以是抽象类，但是意义不大

可以是具体类，要重写接口中的所有抽象方法

案例演示

    接口特点

interface Inter{
    public abstract void print();
}

class Demo implements Inter{
    public void print(){
        System.out.println("print");
    }
}
class Test{
    public static void main(String[] args){
        Inter i = new Demo();
        i.print();
    }
}

接口的成员特点

成员变量：只能是常量，并且是静态的并公共的

                  默认修饰符：public static final

                  建议：自己手动给出

构造方法：接口没有构造方法

成员方法：只能是抽象方法

                  默认修饰符：public abstract

                  建议：自己手动给出

案例演示

接口成员特点

class Test{
    public static void main(String[] args){
        Demo d = new Demo();
        d.print();
        System.out.println(Inter.num);
    }
}
interface Inter{
    public static final int num = 10;//默认加前三个关键字，可以互相交换位置
    //public Inter(){} 接口中没有构造方法
   // public void print(){}//接口中不能定义非抽象方法
    abstract void print();
}
class Demo extends Object implements Inter{//一个类不写继承任何类，默认继承Object类
    public void print(){
       // num = 20 ;//报错，无法为最终变量分配值
        System.out.println(num);
    }
}

类与类，类与接口，接口与接口的关系

类与类：继承关系，只能但几次，可以多层继承

类与接口：实现关系，可以单实现，也可以多实现。并且还可以在继承一个类的同时实现多个接口

接口与接口：继承关系，可以单继承，也可以多继承

案例演示：类鱼类，类与接口，接口与接口的关系

class Test{
    public static void main(String[] args){
    }
}
Interface InterA{
    public abstract void printA();
}
Interface InterB{
    public abstract void printB();
}
//interface InterC implements InterB{
//}一个接口不能实现一个接口
interface InterC extends InterB,InterA{}
//一个接口可以继承多个接口
class Demo implements InterA,InterB{
    public void printA(){
        System.out.println("printA");
    }
    public void printB(){
        System.out.println("printB");
    }
}

抽象类和接口的区别

A成员区别

               抽象类

                             成员变量：可以变量，也可以常量

                             构造方法：有

                             成员方法：可以抽象，也可以非抽象

               接口

                             成员变量：只可以常量

                            成员方法：只可以抽象

 B：关系区别

类与类

              继承、单继承

类与接口

              实现，单实现，多实现

接口与接口

               继承，单继承，多继承

设计理念区别

抽象类：被继承体现的是：“is a”的关系，抽象类中定义的是该继承体系的共性功能

接口：被实现体现的是:"like a"的关系，接口中定义的是该继承体系的扩展功能。

猫狗案例加入跳高功能分析及其代码实现

class Test{
    public static void main(String[] args){
        Cat c = new Cat("加菲".8);
        c.eat();
        c.sleep();
        JumpCat jc = new JumpCat("跳高猫",3);
        jc.eat();
        jc.sleep();
        jc.jump();
    }
}

abstract class Animal{
    private String name;//姓名
    private int age;//年龄
    public Animal(){}//空参构造
    public Animal(String name,int age){
        this.name=name;
        this.age = age;
    }
    public void setName(String name){//设置姓名
        this.name = name;
    }
    public String getName(){//获取名字
        return name;
    }
    public void setAge(int age){//设置年龄
        this.age = age;
    }
    public int getAge(){//获取年龄
        return age;
    }
    public abstract void eat();
    public abstract void sleep();
}
interface Jumping{//跳高的接口
    public void jump();
}
class Cat extends Animal{
    public Cat(){}
    public Cat(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void sleep(){
        System.out.println("侧着睡");
    }
}
class JumpCat extends Cat implements Jumping{
public JumpCat(){}
    public JumpCat(String name,int age){
        super(name,age);
    }

    public void jump(){
        System.out.println("猫调高");
    }
}
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

青木落
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的多态抽象和接口
panguixiang5006的博客
12-01 207
Java多态 多态就是同一个对象下在不同时刻表现出来的不同的形态,多态的前提要有继承或实现的关系,要有方法的重写,要有父类引用指向子类对象.
JAVA八 多态抽象接口
一个后端菜鸟的博客
08-10 353
一、多态 继承是多态的基础 重写也是多态的基础 二、抽象类 1、abstract修饰的类是抽象类，抽象类不能new 2.、抽象类可以没有抽象方法 3、由抽象方法的类必须是抽象类 4、子类必须重写父类的抽象方法，否则子类也定义成抽象类 5、抽象类没有方法体 ，被abstract修饰 三、接口 ...
基础语法02：变量，常量，作用域
aty111111的博客
05-31 64
#1.变量 变量是什么：就是可以变化的量 JAVA是一种强类型语言，每个变量都必须声明其类型 JAVA变量是程序中最基本的存储单元，但要素包括其变量名，变量类型和作用域。 type varName [=value] [{,varName[=value]}] //数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量 *注意事项 * 每个变量都有类型，类型可以是基本类型，也可以是引用类型 * 变量名必须是合法的标识符 * 变量声明是一条完整的语句，因此每一个声明都必须以分号结束
Java基础 面向对象中的多态、抽象类abstract、接口interface
qq_45451251的博客
08-11 150
Day09一、多态1 、多态的定义2、在多态中成员变量的访问特点3、父子类之间的类型转换4、多态的好处二、抽象类1、抽象类的定义2、抽象类的特点三、接口1、接口的定义与特点2、类与类、类与接口、接口与接口之间的关系四、作业五、总结 一、多态 1 、多态的定义 2、在多态中成员变量的访问特点 多态中静态方法的访问特点 3、父子类之间的类型转换 多态的向上转型的语法： 父类 对象名称 = ne...
JAVA基础（11）---成员变量和局部变量
11onhook的博客
10-30 184
变量的分类： 按照变量声明的位置（作用的范围）：     成员变量： 声明在类的内部，方法的外部的变量，称为成员变量                局部变量：声明在方法内部，包括方法的参数，成为局部变量 注意：类外面（与类对应的大括号外面），不能有变量的声明。 按照变量的类型：分为基本类型变量和引用类型变量      成员变量和局部变量的区别： 1、从作用范围来说：成员变量在整个类的内...
Java--多态；抽象类；接口
MinggeQingchun的博客
11-01 1331
一、抽象类 1、final关键字 1.1、final修饰的类无法继承。 1.2、final修饰的方法无法覆盖。 1.3、final修饰的变量只能赋一次值。 1.4、final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用 指向的对象内部的数据是可以修改的。 1.5、final修饰的实例变量必须手动初始化，不能采用系统默认值。 1.6、final修饰的实例变量一般和static联合使用，称为常量。 public ...
【IT十八掌徐培成】Java基础第06天-03.多态-类多态-接口多态-同名属性问题.zip
08-07
接口在Java中是一种定义行为的抽象类型，它只包含常量定义和方法声明，不包含具体的实现。当一个类实现了一个接口，它就必须提供接口中所有方法的具体实现。多个类可以实现同一个接口，这样就形成了接口多态。例如，...
设计模式-Java多态
最新发布
02-28
1. **消除类型之间的耦合关系**：通过多态，我们可以将具体类型与抽象类型（接口或抽象类）解耦，使代码更加独立，易于维护和扩展。 2. **可替换性**：子类对象可以替换父类对象使用，不影响程序的正确性，因为子类...
Java-多态与接口综合案例_USB接口设计
12-21
在本案例中，我们定义了一个`USB`接口，它有两个抽象方法：`open()`和`close()`，用于表示USB设备的打开和关闭操作。 接着，我们创建了两个类`Mouse`和`KeyBoard`，它们都实现了`USB`接口。`Mouse`类重写了`open()`...
完整版优质java课件 Java基础入门教程 Java编程技术14 补充--对多态、抽象和接口的理解（共24页）.ppt
12-04
【Java编程技术——多态、抽象和接口的理解】 在Java编程中，多态性、抽象和接口是面向对象编程的三大核心概念，它们为代码的灵活性、可扩展性和复用性提供了基础。以下是对这些概念的详细解释： 1. **多态性...
java 将方法作为传参--多态的实例
08-29
2. 接口的使用：接口是 Java 中的一种抽象概念，用于定义一组方法的集合。我们可以使用接口来定义一个方法的集合，然后让不同的类来实现这个接口。 3. 方法作为参数传递：在 Java 中，我们可以将方法作为参数传递到...
corejava11（3.4 变量和常量）
nbda1121440的专栏
05-14 152
3.4 变量和常量 与每种编程语言一样，变量用于存储值。常量是值不变的变量。在下面的部分中，您将学习如何声明变量和常量。 3.4.1 变量的声明 在Java中，每个变量都有一个类型。通过将类型放在第一位，后跟变量名来声明变量。以下是一些例子： double salary; int vacationDays; long earthPopulation; boolean done; 注意每个声明末尾...
1.Java常量
洋葱的博客
07-26 291
定义常量利用final关键字来定义 注意：1.定义常量时要初始化 2.常量定义了便不可以修改 3.常量一般用字母大写来表示 public class HelloWorld { // 静态常量 public static final double PI = 3.14; // 声明成员常量 final int y = 10; public static void main(String[] args) { ...
Java的多态，interface、abstract
霖林烟雨
08-07 1453
简述： 这是我对Java interface、abstract 以及多态的理解，做的简单实现 实现： Person 类为抽象类，包含两个方法Eat()和Breath() Drive 为接口，包含DriveCar() 和 DriveBus()两个方法 Driver  为具体的实现类，他有Person的性质age，同时也有Person的必须的行为， Eat()和Breath(),同时
01-Java语言基础
青木年华
06-09 3723
###01.01_计算机基础知识(计算机概述)(了解)* A:什么是计算机?计算机在生活中的应用举例     * 计算机（Computer）全称：电子计算机，俗称电脑。是一种能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。由硬件和软件所组成，没有安装任何软件的计算机称为裸机。常见的形式有台式计算机、笔记本计算机、大型计算机等。     * 应用举例           * 1：科学计...
java生成自己项目的API文档
青木年华
09-05 1577
特殊的注释 -文档注释：/** 使用JAVADOC生成API文档 ——解决问题：代码和文档的分离 常用的java注释标签 _@Author 作者 ——@version 版本 ——@param 参数 ——@throws 抛出异常描述 ——@deprecated 废弃。建议用户不再使用 在项目处单机右键——导出——java文件夹——javadoc_修改目标生成文件夹——点击fini...
26-JAVA中的多线程与GUI
青木年华
11-29 1519
###25.01_多线程(单例设计模式)(掌握) * 单例设计模式：保证类在内存中只有一个对象。 * 如何保证类在内存中只有一个对象呢？     * (1)控制类的创建，不让其他类来创建本类的对象。private     * (2)在本类中定义一个本类的对象。Singleton s;     * (3)提供公共的访问方式。  public static Singleton getInstance...
31-管家婆家庭记账软件
青木年华
12-31 1093
管家婆家庭记账软件 项目介绍 项目安排 项目目标 本项目为JAVAEE基础班综合项目，包含了若干个知识点，达到将基础班所学知识综合使用，提高了我们对项目的理解与知识点的运用。 熟练View层、Service层、Dao层之间的方法相互调用操作、 熟练dbutils操作数据库表完成增删改查 通过本项目，让我们了解公司项目开发的流程，充分的掌握项目需求分析、设计与功能的代码实...
15-java正则表达式、数学类、随机类、System类、大数类与时间类
青木年华
08-11 876
###14.01_常见对象(正则表达式的概述和简单使用) * A:正则表达式     * 是指一个用来描述或者匹配一系列符合某个语法规则的字符串的单个字符串。其实就是一种规则。有自己特殊的应用。     * 作用:比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的 * B:案例演示     * 需求：校验qq号码.         * 1:要求必须是5-15...
Java OOP：接口、多态、抽象类与final关键字解析
"接口，多态，抽象类和final关键字是Java编程中面向对象特性的重要组成部分。理解并熟练掌握这些概念对于编写高质量的Java代码至关重要。本文将详细阐述这些概念及其应用。 首先，我们来看一下接口（Interface）。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值