内部类笔记（Java）

已于 2024-03-24 15:57:40 修改
阅读量30 收藏
点赞数
文章标签： java jvm 开发语言
于 2022-08-26 08:32:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52921880/article/details/126368331
版权

韩顺平老师的零基础30天学会Java，（小白自学）自己看的写的当记忆，如有不对地方感谢指教

内部类介绍

  1. 内部类：在一个类的内部定义的类。
  2. 成员内部类格式如：class Outer{//外部类 class Inner{}//内部类 }
 public class l6 {// 外部其他类
    public static void main(String[] args) {

    }
}

class Outer {// 外部类
    private int n1 = 100;// 属性

    public Outer(int n1) {// 构造器
        this.n1 = n1;
    }

    public void m1() {// 方法
        System.out.println("m1()");
    }

    {// 代码块
        System.out.println("代码块la");
    }

    class Innter {// 内部类，在Outer类的内部

    }
    }
  1. 类的五大成员：属性，方法，构造器，代码块，内部类
  2. 内部类分类：局部内部类，匿名内部类，成员内部类，静态内部类

局部内部类

  1. 局部内部类：定义在外部类的局部位置，比如方法中+有类名（LocalInnterClass）
  2. 可以直接访问外部类的所有成员，包含私有的
class Outer {// 外部类
    private int n1 = 100;// 属性

    public void m1() {// 方法
        // 1.局部内部类是定义在外部类的局部位置，通常是在方法里
        System.out.println("m1()");
        class Innter {// 本质还是一个类：内部类
            // 2.可以直接访问外部类的所有成员，包含私有
            public void f1() {
                System.out.println("n1" + n1);
                m1();
            }
        }
    }

}
  1. 不能添加访问修饰符，因为他的地位就是一个局部变量，局部变量不能使用。但是可以用final修饰
        class Innter {// 本质还是一个类：内部类
            // 2.可以直接访问外部类的所有成员，包含私有
            public void f1() {
                System.out.println("n1" + n1);
                m1();
            }
        }
        class Innter1 extends Innter {

        }
    }

在这里插入图片描述

  1. 作用域：仅在定义它的方法中或代码块中
  2. 外部类如何使用Innter呢？——外部类在方法中，可以创建Innter对象，然后调用方法即可
// 6.外部类调用内部类可在方法中，创建Innter对象，再调用方法即可
        Innter innter = new Innter();
        innter.f1();
  • 局部内部类定义在方法中/代码块中
  • 作用域在方法体或代码块中
  • 本质仍是个类
public class l6 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.m1();
    }
}

class Outer {// 外部类
    private int n1 = 100;// 属性

    public void m2() {
        System.out.println("m2");
    }

    public void m1() {// 方法
        // 1.局部内部类是定义在外部类的局部位置，通常是在方法里
        // 4.作用域：仅在此方法中或代码块
        System.out.println("m1()");
        final class Innter {// 本质还是一个类：内部类
            // 2.可以直接访问外部类的所有成员，包含私有
            public void f1() {
                System.out.println("n1" + n1);
                m2();

            }
        }
        // 6.外部类调用内部类可在方法中，创建Innter对象，再调用方法即可
        Innter innter = new Innter();
        innter.f1();
    }

}
  1. 外部其他类不能访问局部内部类（因为局部内部类地位是一个局部变量）
    7.如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

Outer.this本质上就是外部类的对象，哪个对象调用了m1,Outer.this就是哪个对象，这里就是outer对象

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

class Outer {// 外部类
    private int n1 = 100;// 属性

    public void m2() {
        System.out.println("m2");
    }

    public void m1() {// 方法
        // 1.局部内部类是定义在外部类的局部位置，通常是在方法里
        // 4.作用域：仅在此方法中或代码块
        System.out.println("m1()");
        final class Innter {// 本质还是一个类：内部类
            // 2.可以直接访问外部类的所有成员，包含私有
            private int n1 = 10;

            public void f1() {
                // 7.如果外部类和内部类的成员重名时，就近原则。如果要使用外部类的成员（外部类名.this.成员）
                System.out.println("n1=" + n1 + "外部类的n1" + Outer.this.n1);
                m2();

            }
        }
        // 6.外部类调用内部类可在方法中，创建Innter对象，再调用方法即可
        Innter innter = new Innter();
        innter.f1();
    }

}
  1. 这里用hashcode显示地址来证明到底对应是不是outer在这里插入图片描述在这里插入图片描述地址一致地址一致，对滴

匿名内部类！！！

  1. 匿名内部类：1）本质是类2）内部类3）该类没有名字【其实系统底层是给分配的名字，隐藏起来的】4）同时还是个对象Anonymous
  2. 匿名内部类基本语法：new 类或接口（参数列表）{类体}；
  3. 基于接口的匿名内部类
    （1）需求：想使用接口，并创建对象
    （2）传统方法，写一个类实现该接口，并创建对象
public class l6 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

class Outer {
    private int n1 = 10;// 属性

    public void method() {// 方法
        // 基于接口的匿名内部类
        IA tiger = new Triger();
        tiger.cry();
    }
}

interface IA {// 接口
    public void cry();
}

class Triger implements IA {

    @Override
    public void cry() {
        System.out.println("老虎咆哮");

    }

}

class Father {

    public Father() {// 构造器
    }

    public void test() {// 方法

    }
}

（3）如果需求是Tiger类只使用一次以后再不使用，这样话每次。。。繁琐
（4）使用匿名类来简化

public class l6 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.method();
    }
}

class Outer {
    private int n1 = 10;// 属性

    public void method() {// 方法
        // 基于接口的匿名内部类
        IA tiger = new IA() {

            @Override
            public void cry() {
                System.out.println("老虎咆哮");

            }

        };
        tiger.cry();
        // IA tiger = new Triger();
        // tiger.cry();
    }
}

interface IA {// 接口
    public void cry();
}

// class Triger implements IA {

// @Override
// public void cry() {
// System.out.println("老虎咆哮");

// }

// }

class Father {

    public Father() {// 构造器
    }

    public void test() {// 方法

    }
}

（5）tiger的编译类型：IA
（6）tiger的运行类型：匿名内部类在这里插入图片描述
class Outer$1。以后看到XXX$1就是匿名内部类，getClass就是获取到该对象的运行类型

  • 编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。

在这里插入图片描述
（7）jdk底层在创建匿名内部类 Outer$1,立刻马上就创建了 Outer$1实例，并且把地址返回给tiger
(8)匿名内部类使用一次，就不能载使用的

  1. 演示基于类的匿名内部类
    father编译类型 Father
    father运行类型 Outer$2
   Father father = new Father(){};

father编译类型 Father
father运行类型 Father

Father father = new Father() ;

在这里插入图片描述

  1. 基于抽象类的匿名内部类
abstract class Animal {// 抽象类
    abstract void eat();
}

这里就不能省省略不写方法。。。抽象。。。有点像父类和子类

   Father father = new Father("jack") {

            @Override
            public void test() {
                System.out.println("iuyinm");

            }

        };

class Father {

    public Father(String name) {// 构造器
        System.out.println("name=" + name);
    }

    public void test() {// 方法

    }
}

编译结果：name=jack

  1. 两种调用方法
    （1）通过对象调用
public class l6 {
    public static void main(String[] args) {
        Outer05 outer = new Outer05();
        outer.f1();
    }
}

class Outer05 {
    private int n1 = 90;

    public void f1() {
        // 创建一个基于类的匿名内部类
        Person person = new Person() {

            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi方法");
            }

        };
        person.hi();// 动态绑定，真实运行类型是Outer05$1
    }
}

class Person {
    public void hi() {
        System.out.println("Person hi");
    }
}

（2）直接调用其本身也是返回对象

public class l6 {
    public static void main(String[] args) {
        Outer05 outer = new Outer05();
        outer.f1();
    }
}

class Outer05 {
    private int n1 = 90;

    public void f1() {
        // 创建一个基于类的匿名内部类
        // Person person = new Person() {

        // @Override
        // public void hi() {
        // System.out.println("匿名内部类重写了hi方法");
        // }
        // };
        // person.hi();// 动态绑定，真实运行类型是Outer05$1
        // 也可以直接调用,匿名内部类本身也是返回对象
        new Person() {

            @Override
            public void ok(String str) {
                super.ok(str);
            }

            @Override
            public void hi() {
                System.out.println("匿名内部类重写了hi方法。。。");
            }

        }.ok("jack");
        ;
    }
}

class Person {
    public void hi() {
        System.out.println("Person hi");
    }

    public void ok(String str) {
        System.out.println("Person ok()" + str);
    }
}
  1. 总结一些点
    在这里插入图片描述
    在这里插入图片描述
  2. 匿名内部类的实践
    当作实参直接传递，简洁高效
public class l6 {
    public static void main(String[] args) {
        // 当作实参直接传递，简洁高效
        f1(new IL() {

            @Override
            public void show() {
                System.out.println("这是一幅名画");

            }

        });
    }

    // 静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}

// 接口
interface IL {
    void show();
}

再看看传统写法

 public static void main(String[] args) {
        // 当作实参直接传递，简洁高效
        // f1(new IL() {

        //     @Override
        //     public void show() {
        //         System.out.println("这是一幅名画");

        //     }

        // });
        // 传统方法
        f1(new Car());

    }

    // 静态方法,形参是接口类型
    public static void f1(IL il) {
        il.show();
    }
}

// 接口
interface IL {
    void show();
}

// 类实现IL 编程领域中被称为硬编码
class Car implements IL {

    @Override
    public void show() {
        System.out.println("这也是一副名画");
    }

}

比如说。要是改了Car里面的”这也是一副名画“，那上面调用静态方法那调用都影响
在这里插入图片描述
// 1.传递的是实现了Bell接口的匿名内部类 l6$1 l6$2
// 2.重写了ring方法
// 3.Bell bell=new Bell() {

    // @Override
    // public void ring() {
    // System.out.println("懒猪起床了");

    // }

    // }
     bell.ring();// 动态绑定

public class l6 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.alarmclock(new Bell() {

            @Override
            public void ring() {
                System.out.println("懒猪起床了");

            }

        });
        cellphone.alarmclock(new Bell() {

            @Override
            public void ring() {
                System.out.println("小伙伴们上课了");
            }

        });
    }
}

interface Bell {// 接口
    public void ring();// 方法
}

class Cellphone {// 类
    public void alarmclock(Bell bell) {// 形参是Bell接口类型
        bell.ring();
    }
}

成员内部类

  1. 成员内部类定义：定义在外部类的成员位置，且没有static修饰（MemberInnerClass）
  2. 可直接访问外部类的所有成员，包含私有
  3. 可以添加任意修饰符（public,protected,默认,private）,因为其就是一个成员
public class l6 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.ti();
    }
}

class Outer08 {// 外部类
    private int n1 = 10;
    public String name = "凌不疑";

    protected class Innter08 {// 1.成员内部类（即不再方法中也不在代码块中，在成员的位置上写）
        // 2.可以添加任意修饰符（public,protected,默认,private),因为他本身地位就是成员
        public void say() {

            System.out.println("Outer的n1=" + n1 + "Outer的name=" + name);
        }
    }

    // 写方法
    public void ti() {
        // 使用了成员内部类
        Innter08 innter08 = new Innter08();
        innter08.say();
    }
}
  1. 作用域：在外部类里面
  2. 成员内部类—访问—外部类成员—直接访问
  3. 外部类—访问—成员内部类—创建对象，再访问（使用相关方法）
  4. 外部其他类—访问成员内部类—2种方式
public class l6 {
    public static void main(String[] args) {
        Outer08 outer08 = new Outer08();
        outer08.ti();
        // 外部内部类访问成员内部类3种方式
        // 1.outer08.new Innter08();相当于把new Innter08()当成outer08的成员
        Outer08.Innter08 innter08 = outer08.new Innter08();
        innter08.say();
        // 2.写一个方法在外部类中，可以返回Innter08对象
        Outer08.Innter08 innter08Instance = outer08.getInner08Instance();
        innter08Instance.say();
    }
}

class Outer08 {// 外部类
    private int n1 = 10;
    public String name = "凌不疑";

    protected class Innter08 {// 1.成员内部类（即不再方法中也不在代码块中，在成员的位置上写）
        // 2.可以添加任意修饰符（public,protected,默认,private),因为他本身地位就是成员
        public double sal = 9.9;

        public void say() {

            System.out.println("Outer的n1=" + n1 + "Outer的name=" + name);
        }
    }

    // 方法，返回一个Innter08实例
    public Innter08 getInner08Instance() {
        return new Innter08();
    }

    // 写方法
    public void ti() {
        // 使用了成员内部类
        // 创建成员内部类对象,然后使用相关的方法
        Innter08 innter08 = new Innter08();
        innter08.say();
        System.out.println(innter08.sal);
    }
}
  1. 如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

静态内部类

  1. 静态内部类定义：定义在外部类的成员位置，并且有static修饰（StaticlnnerClass）
  2. 静态内部类可以直接访问外部类的所有静态成员，包括私有，但是不能直接访问非静态成员
  3. 可以添加任意访问修饰符（public,protected,默认,private），其本身地位是成员
  4. 作用域：同其他成员，为整个类体

public class l6 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.show();
    }
}

class Outer10 {// 外部类
    private int n1 = 10;
    private static String name = "袁善良";

    // Inner10静态内部类
    // 1.放在外部类成员位置
    // 2.使用static修饰
    // 3.可以直接访问外部类的所有静态成员，包含私有，但不能直接访问非静态成员name
    // 4.可以添加任意访问修饰符（public,protected,默认,private），其本身地位是成员
    static class Inner10 {
        public void say() {
            System.out.println(name);
        }
    }

    public void show() {
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
}
  1. 成员内部类—访问—外部类成员—直接访问
  2. 外部类—访问—成员内部类—创建对象，再访问（使用相关方法）
  3. 外部其他类—访问—静态内部类3种方法
public class l6 {
    public static void main(String[] args) {
        Outer10 outer10 = new Outer10();
        outer10.show();
        // 外部其他类 使用静态内部类
        // 1.因为静态内部类可以通过类名直接访问，但是得通过访问权限
        Outer10.Inner10 inner10 = new Outer10.Inner10();
        inner10.say();
        // 2.编写一个方法(非静态)，可以返回静态内部类的对象实例
        Outer10.Inner10 inner102 = outer10.getInner10();
        inner102.say();
        System.out.println("-----------");
        // 静态，这没有再创建对象，直接用外部类名来用
        Outer10.Inner10 inner103 = Outer10.getInner101();
        inner103.say();
    }
}

class Outer10 {// 外部类
    private int n1 = 10;
    private static String name = "袁善良";

    // Inner10静态内部类
    // 1.放在外部类成员位置
    // 2.使用static修饰
    // 3.可以直接访问外部类的所有静态成员，包含私有，但不能直接访问非静态成员name
    // 4.可以添加任意访问修饰符（public,protected,默认,private），其本身地位是成员
    static class Inner10 {
        public void say() {
            System.out.println(name);
        }
    }

    public void show() {
        Inner10 inner10 = new Inner10();
        inner10.say();
    }

    public Inner10 getInner10() {
        return new Inner10();

    }

    public static Inner10 getInner101() {
        return new Inner10();

    }
}
  1. 如果外部类和局部内部类的成员重名时，默认遵循就近原则。如果想访问外部类的成员，则可以使用（外部类名.成员）去访问

课堂测试题

写出输出结果：

class Test {// 外部类
    public Test() {// 构造器
        Innter s1 = new Innter();
        s1.a = 10;
        Innter s2 = new Innter();
        System.out.println(s2.a);
    }

    class Innter {// 内部类。成员内部类
        public int a = 5;
    }

    public static void main(String[] args) {
        Test t = new Test();
        Innter r = t.new Innter();
        System.out.println(r.a);
    }
}

在这里插入图片描述

起气球
关注
java 内部类 构造方法_Java笔记9：构造方法，内部类
weixin_29515393的博客
02-24 1393
构造方法：1：#构造方法的名称必须与类名一样。#构造方法的声明处不能有任何返回值类型的声明。#不能在构造方法中使用人turn返回一个值实例化对象时候调用构造方法声明时候不调用构造方法class Person{public Person(){System.out.print("构造方法");}}public class test07{public static void main(String ar...
Java--内部类学习笔记
记录并分享学习编程时的知识点...
05-21 2417
本文介绍了什么是内部类,Java中的内部类:实例内部类. 静态内部类.局部内部类.匿名内部类的语法和注意事项,以及每个内部类的运用场景,以及简单介绍了匿名内部类更简洁更特殊的语法->lambda表达式
Java学习笔记10——静态内部类使用及意义
2303_79232676的博客
03-06 1959
在Java语言中，静态内部类（Static Inner Class）是一种定义在另一个类内部的类，但与外部类的实例无关。静态内部类使用`static`关键字来定义，这意味着它不需要外部类的实例就可以被创建和使用。静态内部类不能访问外部类的非静态成员（实例变量和实例方法），但可以访问外部类的静态成员（静态变量和静态方法）以及它自己的成员。 静态内部类为Java提供了一种强大的机制来组织和管理相关的类，同时保持代码的清晰性和可维护性。
java内部类练习题_学习笔记——Java内部类练习题
weixin_42162171的博客
02-16 767
1.尝试在方法中编写一个匿名内部类。package com.lzw;public class AnonymityInnerClass {}class OuterClass4{public OutInterface doit(final String s){return new OutInterface(){private int i=0;public int getValue(){System.o...
Java 中的内部类
林二月的博客
07-09 1530
本文详细解释了 内部类 的概念与使用，并深入介绍了 4种内部类 的注意事项和细节。这一部分的知识非常的多且琐碎，而且想要理解好需要较好的面向对象的基础。小白博主已经尽力整理了，希望小伙伴们看后能有所收获！最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！我们下一篇博文见吧！
Thinking in Java读书笔记
热门推荐
yjclsx的博客
07-31 42万+
Thinking in Java读书笔记（IO和并发除外） 1.1、类中所有的private方法都隐式地指定为final的，由于其他类无法取用private方法，所以也就无法覆盖它；private方法无法被重写，继承对应private的方法无效，private的属性也无法拿到，但我们通常private的属性有对应的get、set方法，通常是public的，所以子类继承后可以调用方法来取得到父类的...
Java学习笔记
m0_51060495的博客
04-02 1619
未完待续
【java笔记】Java中的匿名类和匿名内部类
zuzhiang的博客
06-18 1609
匿名类和匿名内部类 匿名类是指没有类名的内部类，必须在创建时使用 new 语句来声明类。其语法形式如下： new <类或接口>() { // 类的主体 }; 匿名类有两种实现方式： 继承一个类，重写其方法 实现一个接口（可以是多个），实现其方法 public class Out { void show() { System.out.println("调用 Out 类的 show() 方法"); } } public class TestAnonym
java学习笔记——09内部类与异常类
昭与云的博客
01-05 1054
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类,嵌套其他类的类称为外部类。是我们类的第五大成员【思考:类的五大成员是哪些?属性，方法，构造器，代码块，内部类】，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系在编写程序时可以扩展Exception类定义自己的异常类，然后根据程序的需要来规定哪些方法产生这样的异常。
Java常用类笔记
保持学习
02-11 7541
文章目录一、前言二、字符串相关类1.String 一、前言 这篇技术博客是我复习尚硅谷JavaSE教程做的笔记总结，方便大家的学习同时也方便自己。博客内容非复制粘贴，纯手写。如果对你有帮助，欢迎点赞评论收藏！ 二、字符串相关类 1.String ...
Java内部类基础笔记
03-19
本篇笔记将详细介绍Java中的四种内部类：普通内部类、静态内部类、方法内部类以及匿名内部类。 ### A. 普通内部类 普通内部类（也称为成员内部类）是定义在外部类的成员位置，如同字段一样。它们可以直接访问外部...
整理java读书笔记十五之java中的内部类
09-03
Java中的内部类是一种特殊的类，它定义在一个外部类的内部，允许更加紧密的耦合和封装。这种设计模式使得内部类能够直接访问外部类的所有成员，包括私有（private）成员，而无需任何特殊权限。这为代码组织和实现...
Java基础内容-内部类学习笔记
03-21
根据老师讲解写的笔记
java超强笔记
12-03
在面向对象高级特性的部分，笔记可能包含抽象类、接口、内部类、匿名类、枚举，以及泛型和注解的使用。这些特性使得Java代码更加灵活且易于维护。 最后，笔记可能还会涉及一些设计模式，如单例模式、工厂模式、观察...
尚硅谷JAVA基础笔记吐血整理
02-03
包是组织Java类和接口的一种方式，通过package关键字声明，如`package com.example.myapp;`。包名反映了文件的目录结构，可以避免名称冲突，并有助于代码的管理。 【MVC设计模式】 MVC（Model-View-Controller）...
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
最新发布
h2345678的博客
10-29 1228
项目功能：商品分类,商品信息,用户。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1016
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 495
简单的说: 递归就是方法自己调用自己,每次调用时传入不同的变量.递归有助于编程者解决复杂问题,同时可以让代码变得简洁。
ssm智慧社区电子商务系统+vue
weixin_44832324的博客
10-28 1228
系统能否进行正常工作，功能模块能否实现，程序代码是否有错误，这些都需要通过系统测试来进行判断，测试是程序开发中必不可少的步骤，就算系统一步不差的被开发出来了，但进行测试时总能发现一个之前从没遇到过的问题[26]。在系统开发的整个过程当中都需要不断进行系统测试，根据经验发现，前期的一个小问题，将会酿成后期的一个大问题，所以越早发现，越早解决，才能保证后续的编码、测试和设计能够顺利进行。目前，系统测试所使用的方法主要是黑盒测试，系统测试的目的包括：根据客户的需求来设计用户界面；
Java学习笔记：内部类与泛型解析
"这篇java学习笔记涵盖了内部类和泛型的好处，同时也详细介绍了Java语言中的原始数据类型，包括它们的大小、格式和用途。" 在Java编程语言中，内部类和泛型是两个重要的概念，它们极大地提高了代码的灵活性和可复用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值