JavaSE知识重构

已于 2022-12-21 15:10:13 修改
阅读量371 收藏
点赞数
分类专栏： Java SE 文章标签： 重构 java
于 2022-12-04 22:07:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43629083/article/details/128178196
版权

JavaSE知识重构

我亦无他，唯手熟尔。

参考：
B站【零基础 快速学Java】韩顺平 零基础30天学会Java

文章目录

final关键字

final可以修饰类、属性、方法和局部变量

需要使用final的需求：

  1. 类不可以被继承
  2. 父类的某个方法不可以被子类覆盖/继承(override)
  3. 类的某个属性值不可以被修改
  4. 某个局部变量不可以被修改

final注意细节

  1. final修饰的属性叫做常量，XXX_XXX_XXX来命名
  2. final修饰的属性在定义时，必须赋初值，并且之后不能修改。
    赋值可以在如下位置：
    • 定义时
    • 在构造器中
    • 在代码块中
  3. 如果final修饰的属性是静态的，则初始化的位置只能是：
    • 定义时
    • 在静态代码块，不能在构造器中赋值
  4. final类不能继承，但可以实例化对象
  5. 如果类不是final类，但含有final方法，则该方法不能重写，但可以被继承。
  6. 如果一个类已经是final类了，没必要再将方法修饰成final方法
  7. final不能修饰构造方法(即构造器)
  8. final、static往往搭配使用，效率高，不会导致类加载（底层编译器做了优化处理）
  9. 包装类(Integer, Double, Float, Boolean等都是final)，String类也是final类。

抽象类

exercise：
1、abstract final class A{}能编译通过嘛？错误，final不能继承
2、abstract public static void test2();能编译通过吗？错误，static关键字和方法重写无关。
3、abstract private void test3();错误，私有的方法不能重写。
模板设计模式：

接口

内部类

类的五大成员：
属性、方法、构造器、代码块、内部类

什么是内部类

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类（inner class），嵌套其他类的类称为外部类（outer class）。
内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系。
定义类在局部位置（方法中/代码块）：（1）局部内部类（2）匿名内部类
定义在成员位置：（1）成员内部类（2）静态内部类
在这里插入图片描述

内部类的特点

  1. 内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。
  2. 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由地访问外部类的成员变量，无论是否为 private 的。
  3. 内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能访问外部类的静态成员变量。

局部内部类的使用

局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

  1. 可以直接访问外部类的所有成员，包括私有的。
  2. 不能添加访问修饰符，因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
  3. 作用域：仅仅在定义它的方法或代码块中。
  4. 局部内部类–访问---->外部类成员 【访问方式：直接访问】
  5. 外部类–>访问—>局部内部类成员 【访问方式：创建对象，再访问（注意：必须在作用域内）】
    注意：
    1 局部内部类定义在方法中/代码块中
    2 作用域再方法体或者代码块中
    3 本质仍然是一个类
  6. 外部其他类–不能访问---->局部内部类（因为 局部内部类地位是一个局部变量）
  7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）去访问
public class LocalInnerClass {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        outer01.outer_02();
        System.out.println("outer01的hashcode = " + outer01);
    }
}

class Outer01{  //外部类
    private int n1 = 100;
    private void outer_f1(){
        System.out.println("外部类实例方法");
    }
    public void outer_02(){  //方法
        // 局部内部类是定义在外部类的局部位置上，通常在方法
        // 不能添加访问修饰符，但是可以使用final修饰
        // 作用域：仅仅在定义它的方法或代码块中
        class Inner01{  //局部内部类（本质仍然是一个类）
            private int n1 = 800;
            public void inner_f1(){
                // 局部内部类可以直接访问外部类的成员
                // 如果外部类和内部类的成员重名，默认遵循就近原则
                // 如果想访问外部类的成员 使用 外部类类名.this.成员 去访问
                // Outer01.this 本质就是外部类的对象
                System.out.println("n1 = " + n1);
                System.out.println("外部类的n1 = " + Outer01.this.n1);
                System.out.println("Outer01.this hashcode = " + Outer01.this);
            }
        }

        Inner01 inner01 = new Inner01();
        inner01.inner_f1();
    }
}

n1 = 800
外部类的n1 = 100
Outer01.this hashcode = chapter10.innerclass.Outer01@1b6d3586
outer01的hashcode = chapter10.innerclass.Outer01@1b6d3586

匿名内部类的使用

1、本质是类
2、内部类
3、该类没有名字
4、同时还是一个对象
说明：匿名内部类是定义在外部类的局部位置，比如方法中，并且没有类名
匿名内部类的基本语法

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

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer02 outer02 = new Outer02();
        outer02.method();
    }
}

class Outer02{
    //基于接口的匿名内部类
    //1.需求： 想使用IA接口,并创建对象
    //2.传统方式，是写一个类，实现该接口，并创建对象
    //3.老韩需求是 Tiger/Dog 类只是使用一次，后面再不使用
    //4. 可以使用匿名内部类来简化开发
    //5. tiger的编译类型 ? IA
    //6. tiger的运行类型 ? 就是匿名内部类  Outer04$1
        /*
            底层 会分配 类名 Outer04$1
            class Outer04$1 implements IA {
                @Override
                public void cry() {
                    System.out.println("老虎叫唤...");
                }
            }
         */
    //7. jdk底层在创建匿名内部类 Outer04$1,马上就创建了 Outer04$1实例，并且把地址
    //   返回给 tiger
    //8. 匿名内部类使用一次，就不能再使用
    public void method(){
        IA tiger = new IA(){

            @Override
            public void fun() {
                System.out.println("老虎叫唤...");
            }
        };
        System.out.println("tiger的运行类型 = " + tiger.getClass());
    }

}

interface IA{
    void fun();
}

tiger的运行类型 = class chapter10.innerclass.Outer02$1

匿名内部类可以访问外部类的所有成员，包含私有的。
不能添加访问修饰符，因为他的地位就是一个局部变量
作用域：仅仅在定义它的方法或者代码块中
外部其他类不能访问匿名内部类（因为匿名内部类地位是一个局部变量）
如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则，如果访问外部类的成员，则可以使用（外部类名.this.成员）去访问。

//基于类的匿名内部类
 //分析
 //1. father编译类型 Father
 //2. father运行类型 Outer04$2
 //3. 底层会创建匿名内部类
 /*
     class Outer04$2 extends Father{
         @Override
         public void test() {
             System.out.println("匿名内部类重写了test方法");
         }
     }
  */
 //4. 同时也直接返回了 匿名内部类 Outer04$2的对象
 //5. 注意("jack") 参数列表会传递给 构造器
 Father father = new Father("tom"){
     @Override
     public void test() {
         System.out.println("匿名内部类重写test方法");
     }
 };
 System.out.println("father 对象的运行类型= " + father.getClass());
//        father.test();

 //基于抽象类的匿名内部类
 Animal animal = new Animal() {

     @Override
     void eat() {
         System.out.println("小狗吃骨头...");
     }
 };
 System.out.println("animal对象的运行类型=" + animal.getClass());
 animal.eat();

接收到的name=tom
father 对象的运行类型= class chapter10.innerclass.Outer02$2
animal对象的运行类型=class chapter10.innerclass.Outer02$3
小狗吃骨头…

public class AnonymousInnerClassDetail {
    public static void main(String[] args) {
        Outer03 outer03 = new Outer03();
        outer03.f1();
        //外部其他类---不能访问----->匿名内部类
        System.out.println("main outer03 hashcode=" + outer03);
    }
}

class Outer03{
    private int n1 = 99;
    public void f1() {
        //创建一个基于类的匿名内部类
        //不能添加访问修饰符,因为它的地位就是一个局部变量
        //作用域 : 仅仅在定义它的方法或代码块中
        Person p = new Person(){
            private int n1 = 88;
            @Override
            public void hi() {
                //可以直接访问外部类的所有成员，包含私有的
                //如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，
                //默认遵循就近原则，如果想访问外部类的成员，则可以使用 （外部类名.this.成员）去访问
                System.out.println("匿名内部类重写了 hi方法 n1=" + n1 +
                        " 外部内的n1=" + Outer03.this.n1 );
                //Outer05.this 就是调用 f1的 对象
                System.out.println("Outer03.this hashcode=" + Outer03.this);
            }
        };
        p.hi();//动态绑定, 运行类型是 Outer03$1

        //也可以直接调用, 匿名内部类本身也是返回对象
        // class 匿名内部类 extends Person {}
        new Person(){
            @Override
            public void hi() {
                System.out.println("匿名内部类重写了 hi方法,哈哈...");
            }
            @Override
            public void ok(String str) {
                super.ok(str);
            }
        }.ok("jack");
    }
}

class Person {//类
    public void hi() {
        System.out.println("Person hi()");
    }
    public void ok(String str) {
        System.out.println("Person ok() " + str);
    }
}

匿名内部类重写了 hi方法 n1=88 外部内的n1=99
Outer03.this hashcode=chapter10.innerclass.Outer03@1b6d3586
Person ok() jack
main outer03 hashcode=chapter10.innerclass.Outer03@1b6d3586

public class InnerClassExercise02 {
    public static void main(String[] args) {
        /*
        1.有一个铃声接口Bell，里面有个ring方法。(右图)
        2.有一个手机类Cellphone，具有闹钟功能alarmClock，参数是Bell类型(右图)
        3.测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印：懒猪起床了
        4.再传入另一个匿名内部类(对象)，打印：小伙伴上课了
         */
        CellPhone cellPhone = new CellPhone();
        //老韩解读
        //1. 传递的是实现了 Bell接口的匿名内部类 InnerClassExercise02$1
        //2. 重写了 ring
        //3. Bell bell = new Bell() {
        //            @Override
        //            public void ring() {
        //                System.out.println("懒猪起床了");
        //            }
        //        }
        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 void alarmClock(Bell bell){//形参是Bell接口类型
        System.out.println(bell.getClass());
        bell.ring();//动态绑定
    }
}

成员内部类使用

成员内部类是定义在外部类的成员位置，并且没有static修饰。
1、可以直接访问外部类的所有成员，包括私有的。
2、可以添加任意访问修饰符（public、protected、默认、private），因为它的地位就是一个成员。
3、作用域：和外部类的其他成员一样，为整个类。
4、成员内部类–访问---->外部类成员（属性）【访问方式：直接访问】
5、外部类–访问---->成员内部类【访问方式：创建对象，再访问】
6、外部其他类–访问---->成员内部类
7、如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果访问外部类的成员，则可以使用（外部类.this.成员）去访问

静态内部类的使用

静态内部类是定义在外部类的成员位置，并且有static修饰
1、可以直接访问外部类的所有静态成员，包括私有的，但不能直接访问非静态成员。
2、可以添加任意访问修饰符（public、protected、默认、private），因为他的地位就是一个成员
3、作用域：同其他成员，为整个类
4、静态内部类–访问---->外部类（比如：静态属性）【访问方式：直接访问所有静态成员】
5、外部类–>访问---->静态内部类【访问方式：创建对象，再访问】
6、外部其他类–>访问---->静态内部类
7、如果外部类和静态内部类的成员重名时，静态内部类访问时，默认遵循就近原则，如果访问外部类的成员，则可以使用(外部类名.成员)去访问

public class StaticInnerClass01 {
    public static void main(String[] args) {
        Outer05 outer05 = new Outer05();
        outer05.m1();

        // 外部其它类 使用静态内部类
        // 方式一
        Outer05.Inner05 inner05 = new Outer05.Inner05();
        inner05.say();

        // 方式2
        // 编写一个方法，可以返回静态内部类的对象实例
        Outer05.Inner05 inner051 = outer05.getInner05();
        inner05.say();
        Outer05.Inner05 inner05_ = Outer05.getInner05_();
        inner05.say();
    }
}


class Outer05{
    private int n1 = 10;
    private static String name = "张三";
    private static void cry(){};

    //Inner05就是静态内部类
    //1. 放在外部类的成员位置
    //2. 使用static 修饰
    //3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
    //4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
    //5. 作用域 ：同其他的成员，为整个类体
    static class Inner05{
        private static String name = "我亦无他，唯手熟尔。";
        // 如果外部类和静态内部类的成员重名时，静态内部类访问的时候
        // 默认遵循就近原则，如果访问外部类的成员，则可以使用（外部类名.成员）
        public void say(){
            System.out.println(name + " 外部类name = " + Outer05.name);
            // 静态内部类直接使用外部类的静态方法
            cry();
        }
    }

    //外部类---访问------>静态内部类 访问方式：创建对象，再访问
    public void m1(){
        Inner05 inner05 = new Inner05();
        inner05.say();
    }

    public Inner05 getInner05(){
        return new Inner05();
    }

    public static Inner05 getInner05_(){
        return new Inner05();
    }
}

枚举和注解

枚举

1、使用enum关键字实现枚举类，默认继承Enum类，而且是一个final类
2、如果使用无参构造器创建枚举对象，则实参列表和小括号可以省略
3、当有多个枚举对象时，使用逗号间隔，最后有一个分号结尾。
4、枚举对象必须放在枚举类的行首

public class Enumeration03 {
    public static void main(String[] args) {
        System.out.println(Season2.AUTUMN);
        System.out.println(Season2.SUMMER);
    }
}
//演示使用enum关键字来实现枚举类
enum  Season2 {//类
    //定义了四个对象, 固定.
//    public static final Season SPRING = new Season("春天", "温暖");
//    public static final Season WINTER = new Season("冬天", "寒冷");
//    public static final Season AUTUMN = new Season("秋天", "凉爽");
//    public static final Season SUMMER = new Season("夏天", "炎热");
    //如果使用了enum 来实现枚举类
    //1. 使用关键字 enum 替代 class
    //2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
    //   SPRING("春天", "温暖") 解读 常量名(实参列表)
    //3. 如果有多个常量(对象)， 使用 ,号间隔即可
    //4. 如果使用enum 来实现枚举，要求将定义常量对象，写在前面
    //5. 如果我们使用的是无参构造器，创建常量对象，则可以省略 ()
    SPRING("春天", "温暖"), WINTER("冬天", "寒冷"), AUTUMN("秋天", "凉爽"),
    SUMMER("夏天", "炎热")/*, What()*/;

    private String name;
    private String desc;//描述

    private Season2() {//无参构造器

    }

    private Season2(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

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

在这里插入图片描述

enum常用方法
  1. toString:Enum 类已经重写过了，返回的是当前对象名,子类可以重写该方法，用于返回对象的属性信息
  2. name：返回当前对象名（常量名），子类中不能重写
  3. ordinal：返回当前对象的位置号，默认从0 开始
  4. values：返回当前枚举类中所有的常量
  5. valueOf：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常！
  6. compareTo：比较两个枚举常量，比较的就是编号！
  7. 使用enum 关键字后，就不能再继承其它类了，因为enum 会隐式继承Enum，而Java 是单继承机制。
  8. 枚举类和普通类一样，可以实现接口

注解

异常

常用类

String类

在这里插入图片描述
在这里插入图片描述

hsp and hava

树下一朵云
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaSE知识目录.pdf
07-30
JavaSE知识目录，博主精心整理的学习笔记导航，快速定位知识点。
JAVASE知识点思维导图
08-22
JAVASE知识点思维导图，通过浏览思维导图就可以了解掌握JAVASE基本的知识点，对大体的知识结构有一个清晰的了解，JAVASE知识点思维导图，通过浏览思维导图就可以了解掌握JAVASE基本的知识点，对大体的知识结构有一个...
非常全面的 JavaSE 知识点总结
Li_Jian_Hui_的博客
04-16 7280
文章目录1.你使用过的JDK版本有哪些？2.面试题或者考试题：JAVA_HOME,Path和ClassPath的区别？3.java数据类型分为几类几种4.&&和&的区别？||与|的区别？5.前++和后++的区别？前--和后--的区别？6.质数【编程题】7.while与do-while的区别？8.break，continue，return三者的区别？9.switch支持的数据类型有哪些？10.数组的定义方式有哪些？11.冒泡排序【编程题】12.面向对象三大特征13.static关键字1
JAVASE知识点总结
最新发布
weixin_61518137的博客
09-30 137
假设此时这个系统是支持用户进行配置的，是支持用户设置皮肤的颜色，设置系统的快捷键，此时就需要使用原型设计模式，不能自己设置把别人的设置都给改了，还不能修改默认的设置，就是为了防止用户有一天进行reset操作，实现原型设计模式，实现备份和恢复。一)为什么要使用克隆?
JAVASE相关知识点
weixin_43132031的博客
07-21 508
涵盖了java大部分基础知识
Javase知识体系
11-17
javase部分思维导图，包括数据库，面向对象，集合，io流, 多线程，异常，网络编程
JAVASE知识汇总
10-18
简单对我所学的javase的知识汇总了一下，希望对有需要的人有帮助，在复习的时候很有用，拿走不谢，下载用xmind打开
JAVASE基础知识详解
02-17
JAVASE基础知识详解
Java中abstract类和abstract方法
树下一朵云的博客
09-20 5087
用关键字abstract修饰的类称为abstract类（抽象类）。如： abstract class A { abstract int min(int x,int y); } 用关键字abstract修饰的方法称为abstract方法（抽象方法）， 对于abstract方法，只允许声明，不允许实现，而且不允许使用final和abstract同时修饰一个方法，例如： abstract int min(int x,int y); 理解abstract类 （1）抽象类可以抽象出...
Java中super关键字介绍
树下一朵云的博客
09-18 2541
由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。 super 关键字的功能： 在子类的构造方法中显式的调用父类构造方法 访问父类的成员方法和变量。 1、使用super调用父类的构造方法 super必须是子类构造方法中头一条语句 ...
Java中为什么使用向上转型而不直接创建子类对象？
树下一朵云的博客
09-20 1576
定义父类 Animal，代码如下： public class Animal { public void sleep() { System.out.println("小动物在睡觉"); } public static void doSleep(Animal animal) { // 此时的参数是父类对象，但是实际调用时传递的是子类对象，就是向上转型。 animal.sleep(); } public static
Java对象的上转型对象与下转型
树下一朵云的博客
09-20 1369
将一个类型强制转换成另一个类型的过程被称为类型转换。本节所说的对象类型转换，是指存在继承关系的对象，不是任意类型的对象。当对不存在继承关系的对象进行强制类型转换时，会抛出Java强制类型转换（java.lang.ClassCastException）异常。 假设，A类是B类的父类，当用子类创建一个对象，并把这个对象的引用放到父类的对象中时，比如： A a; a = new B(); 或 A a; B b = new B(); a = b; 上转型对象 这时，称对象a是对象b的上转型对象....
interface关键字的介绍及使用
树下一朵云的博客
10-11 1200
一、接口的定义与使用 格式： （1）接口体中的抽象方法和常量 JDK8版本之前，接口体中只有抽象方法，访问权限一定都是public（允许省略public、abstract修饰符）。所有的static常量的访问权限一定都是public（允许省略public、final和static修饰符，接口中不会有变量） （2）接口体中的default实例方法 从JDK8版本开始，允许使用default关键字，在接口体中定义称作default的实例方法（不可以定义default的static方法），de...
javaSE基础项目实战一 —— 家庭记账软件
树下一朵云的博客
10-07 1132
javaSE基础项目实战一 —— 家庭记账软件 目标 需求说明 模拟实现基于文本界面的 家庭记账软件 该软件能够记录家庭的收入、支出，并能打印收支细表 项目采用分级菜单方式。主菜单如下： 流程图——主流程 流程图——收入和支出处理流程 键盘访问的实现 step1——实现主程序结构 step2——实现收入和支出登记处理 import java.util.Scanner; /** Utility工具类： 将不同的功能封装为方法，就是可
从命令行输入与输出数据
树下一朵云的博客
09-15 906
1.输入基本数据类型 Scanner在java.util包中，可以使用该类创建一个对象。 Scanner reader = new Scanner(System.in); 然后reader对象调用下列方法，读取用户在命令行输入的各种基本类型数据： nextBoolean();nextByte(),nextShort(),nextInt(),nextLong(),nextFloat(),nextDouble()。 reader对象用空白做分隔标记读取用户在命令行输入的数据。 上述方法执行时读取数
包装类与基本数据类型的相互转换
树下一朵云的博客
10-08 865
package java4; import org.junit.Test; /* * 包装类的使用 * */ public class WrapperTest { //基本数据类型转换为对应的包装类 //调用包装类的构造器 @Test public void test1(){ int num1 = 10; Integer in1 = new Integer(num1); System.out.println(in1.toString()); Integer in2 .
Java中继承与多态的理解
树下一朵云的博客
09-20 539
多态性就是指父类的某个方法被其子类重写时，可以各自产生自己的功能行为。 当一个类有很多子类时，并且这些子类都重写了父类中的某个方法。那么当我们把子类创建的对象的引用放到一个父类的对象中时，就得到了该对象的一个上转型对象，这个上转型对象在调用这个方法时就可能具有多种形态，因为不同的子类在重写父类的方法时可能产生不同的行为。 多态性是面向对象编程的又一个重要特征，它是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的含义。
Javase打印知识
08-18
如果您想要打印JavaSE知识的内容，可以使用Java的IO流来实现。您可以使用System.out.println或者其他打印方法来在控制台输出您想要的JavaSE知识。根据您提供的代码片段，在MapText类的main方法中，使用了System.out....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

树下一朵云

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

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

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

打赏作者

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

抵扣说明：

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

余额充值