Class文件如何存储基本数据,引用类型

于 2023-03-15 12:48:50 发布
阅读量708 收藏
点赞数
文章标签： jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52410356/article/details/129551623
版权

本文概述:
在上一个文章我们谈论了关于字节码的信息.
这里我们来看看 Class 文件是什么

Class 文件是什么

还是老样子, 不直接说是啥, 应该先了解为什么需要.

其实你看这个名字就了解到了, 肯定和类有关系. 我们思考一下, 我们学习的时候肯定都有了解过, Java 是跨平台的, 那么如何跨平台呢?

答案就是这个 Class 文件, 名字很明显, 保存的就是一个类的信息.

也就是说, 这个 Class 文件保存了一个类的所有信息, Class 文件是可以开平台的 (注: 拓展思考一下, 你可能了解过 JVM 里面也有 Class 类信息, 事实上,Class 类信息就是根据这个 Class 文件而产生的, 所以说不同平台, 虚拟机不同, 只要虚拟机是按照规范设计的, 就可以加载这个 Class 文件.)

Class 文件里面存储了类的所有信息, 其实到这里, 一定要做的是,Class 文件里面 <都需要存储哪些东西>,如果你知道, 也不要去回忆他存储哪些东西, <最重要的是,一个Class里面有哪些信息>

由问题来思考需要保存哪些信息:

  1. 版本问题: 1.8 和 1.7 的 Class 文件能通用吗?, 肯定不行, 那么就需要保存版本号
  2. 下面分析就简单多了, 我们编写类的时候有啥
    1. 类信息: 类全限定名, 修饰符, 如果实现了父类, 是不是还需要父类的全限定名和修饰符. 或者说实现了接口, 接口的全限定名, 修饰符等
    2. 方法信息: 一个类中有很多方法吧, 方法名, 修饰符, 返回值, 参数.
    3. 属性信息: 比如说基本数据类型, 引用对象等等.

有个很重要的就是: Class 常量池, 这货在类加载器加载了 Class 文件之后就会变成 Class 运行时常量池, 等会会介绍一下.

下面来主要来介绍一下 Class 文件存储属性, 因为我觉得如何保存属性更好玩, 保存类信息, 基本上都是保存字符串啥的, 没有什么很好玩的地方.

Class 文件如何存储属性

Class 文件中一个结构,Constant Pool, 我们可以叫他 Class 静态常量池

在这里插入图片描述

Tag 值是啥啊, 到底是如何存储的, 图片更直观

常量池里面都存储哪些信息呢?

Classfile /E:/VSCODE_FILE/Test/src/main/java/org/example/jvm/ConstantPoolTest.class
  Last modified 2023-3-14; size 693 bytes                                                
  MD5 checksum ac8bce83662ec1afa8a0ae98d8ad91c9                                          
  Compiled from "ConstantPoolTest.java"                                                  
public class org.example.jvm.ConstantPoolTest                                            
  minor version: 0                                                                       
  major version: 52                                                                      
  flags: ACC_PUBLIC, ACC_SUPER                                                           
Constant pool:                // 这里是静态常量池哦!!!                                                           
   #1 = Methodref          #16.#42        // java/lang/Object."<init>":()V               
   #2 = Fieldref           #15.#43        // org/example/jvm/ConstantPoolTest.int_num:I  
   #3 = Fieldref           #15.#44        // org/example/jvm/ConstantPoolTest.char_num:C 
   #4 = Fieldref           #15.#45        // org/example/jvm/ConstantPoolTest.short_num:S
   #5 = Float              130.0f                                                        
   #6 = Fieldref           #15.#46        // org/example/jvm/ConstantPoolTest.float_num:F
   #7 = Double             140.0d
   #9 = Fieldref           #15.#47        // org/example/jvm/ConstantPoolTest.double_num:D
  #10 = Fieldref           #15.#48        // org/example/jvm/ConstantPoolTest.byte_num:B
  #11 = Long               3333l
  #13 = Fieldref           #15.#49        // org/example/jvm/ConstantPoolTest.long_num:J
  #14 = Fieldref           #15.#50        // org/example/jvm/ConstantPoolTest.boolean_flag:Z
  #15 = Class              #51            // org/example/jvm/ConstantPoolTest
  #16 = Class              #52            // java/lang/Object
  #17 = Utf8               int_num
  #18 = Utf8               I
  #19 = Utf8               char_num
  #20 = Utf8               C
  #21 = Utf8               short_num
  #22 = Utf8               S
  #23 = Utf8               float_num
  #24 = Utf8               F
  #25 = Utf8               double_num
  #26 = Utf8               D
  #27 = Utf8               byte_num
  #28 = Utf8               B
  #29 = Utf8               long_num
  #30 = Utf8               J
  #31 = Utf8               long_delay_num
  #32 = Utf8               boolean_flag
  #33 = Utf8               Z
  #34 = Utf8               <init>
  #35 = Utf8               ()V
  #36 = Utf8               Code
  #37 = Utf8               LineNumberTable
  #38 = Utf8               main
  #39 = Utf8               ([Ljava/lang/String;)V
  #40 = Utf8               SourceFile
  #41 = Utf8               ConstantPoolTest.java
  #42 = NameAndType        #34:#35        // "<init>":()V
  #43 = NameAndType        #17:#18        // int_num:I
  #44 = NameAndType        #19:#20        // char_num:C
  #45 = NameAndType        #21:#22        // short_num:S
  #46 = NameAndType        #23:#24        // float_num:F
  #47 = NameAndType        #25:#26        // double_num:D
  #48 = NameAndType        #27:#28        // byte_num:B
  #49 = NameAndType        #29:#30        // long_num:J
  #50 = NameAndType        #32:#33        // boolean_flag:Z
  #51 = Utf8               org/example/jvm/ConstantPoolTest
  #52 = Utf8               java/lang/Object
{
  public org.example.jvm.ConstantPoolTest();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: bipush        110
         7: putfield      #2                  // Field int_num:I
        10: aload_0
        11: bipush        97
        13: putfield      #3                  // Field char_num:C
        16: aload_0
        17: bipush        120
        19: putfield      #4                  // Field short_num:S
        22: aload_0
        23: ldc           #5                  // float 130.0f
        25: putfield      #6                  // Field float_num:F
        28: aload_0
        29: ldc2_w        #7                  // double 140.0d
        32: putfield      #9                  // Field double_num:D
        35: aload_0
        36: bipush        111
        38: putfield      #10                 // Field byte_num:B
        41: aload_0
        42: ldc2_w        #11                 // long 3333l
        45: putfield      #13                 // Field long_num:J
        48: aload_0
        49: iconst_1
      LineNumberTable:
        line 13: 0
        line 15: 4
        line 16: 10
        line 17: 16
        line 18: 22
        line 19: 28
        line 20: 35
        line 21: 41
        line 23: 48

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
      LineNumberTable:
        line 27: 0
}
SourceFile: "ConstantPoolTest.java"
PS E:\VSCODE_FILE\Test\src\main\java\org\example\jvm> javac .\ConstantPoolTest.java          
PS E:\VSCODE_FILE\Test\src\main\java\org\example\jvm> javap -verbose .\ConstantPoolTest.class
Classfile /E:/VSCODE_FILE/Test/src/main/java/org/example/jvm/ConstantPoolTest.class
  Last modified 2023-3-14; size 710 bytes
  MD5 checksum 30896b5e6fccdb34ecc7c03e41cfbed5
  Compiled from "ConstantPoolTest.java"
public class org.example.jvm.ConstantPoolTest
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #17.#43        // java/lang/Object."<init>":()V
   #2 = Fieldref           #16.#44        // org/example/jvm/ConstantPoolTest.int_num:I
   #3 = Fieldref           #16.#45        // org/example/jvm/ConstantPoolTest.char_num:C
   #4 = Fieldref           #16.#46        // org/example/jvm/ConstantPoolTest.short_num:S
   #5 = Float              130.0f
   #6 = Fieldref           #16.#47        // org/example/jvm/ConstantPoolTest.float_num:F
   #7 = Double             140.0d
   #9 = Fieldref           #16.#48        // org/example/jvm/ConstantPoolTest.double_num:D
  #10 = Fieldref           #16.#49        // org/example/jvm/ConstantPoolTest.byte_num:B
  #11 = Long               3333l
  #13 = Fieldref           #16.#50        // org/example/jvm/ConstantPoolTest.long_num:J
  #14 = Fieldref           #16.#51        // org/example/jvm/ConstantPoolTest.boolean_flag:Z
  #15 = String             #52            // ggzx !!!!,这里是我定义的字符串
  #16 = Class              #53            // org/example/jvm/ConstantPoolTest
  #17 = Class              #54            // java/lang/Object
  #18 = Utf8               int_num
  #19 = Utf8               I
  #20 = Utf8               char_num
  #21 = Utf8               C
  #22 = Utf8               short_num
  #23 = Utf8               S
  #24 = Utf8               float_num
  #25 = Utf8               F
  #26 = Utf8               double_num
  #27 = Utf8               D
  #28 = Utf8               byte_num
  #29 = Utf8               B
  #30 = Utf8               long_num
  #31 = Utf8               J
  #32 = Utf8               long_delay_num
  #33 = Utf8               boolean_flag
  #34 = Utf8               Z
  #35 = Utf8               <init>
  #36 = Utf8               ()V
  #37 = Utf8               Code
  #38 = Utf8               LineNumberTable
  #39 = Utf8               main
  #40 = Utf8               ([Ljava/lang/String;)V
  #41 = Utf8               SourceFile
  #42 = Utf8               ConstantPoolTest.java
  #43 = NameAndType        #35:#36        // "<init>":()V
  #44 = NameAndType        #18:#19        // int_num:I
  #45 = NameAndType        #20:#21        // char_num:C
  #46 = NameAndType        #22:#23        // short_num:S
  #47 = NameAndType        #24:#25        // float_num:F
  #48 = NameAndType        #26:#27        // double_num:D
  #49 = NameAndType        #28:#29        // byte_num:B
  #50 = NameAndType        #30:#31        // long_num:J
  #51 = NameAndType        #33:#34        // boolean_flag:Z
  #52 = Utf8               ggzx
  #53 = Utf8               org/example/jvm/ConstantPoolTest
  #54 = Utf8               java/lang/Object
{
  public org.example.jvm.ConstantPoolTest();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: aload_0
         5: bipush        110
         7: putfield      #2                  // Field int_num:I
        10: aload_0
        11: bipush        97
        13: putfield      #3                  // Field char_num:C
        16: aload_0
        17: bipush        120
        19: putfield      #4                  // Field short_num:S
        22: aload_0
        23: ldc           #5                  // float 130.0f
        25: putfield      #6                  // Field float_num:F
        28: aload_0
        29: ldc2_w        #7                  // double 140.0d
        32: putfield      #9                  // Field double_num:D
        35: aload_0
        36: bipush        111
        38: putfield      #10                 // Field byte_num:B
        41: aload_0
        42: ldc2_w        #11                 // long 3333l
        45: putfield      #13                 // Field long_num:J
        48: aload_0
        49: iconst_1
        50: putfield      #14                 // Field boolean_flag:Z
        53: return
      LineNumberTable:
        line 13: 0
        line 15: 4
        line 16: 10
        line 17: 16
        line 18: 22
        line 19: 28
        line 20: 35
        line 21: 41
        line 23: 48

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=2, args_size=1
         0: ldc           #15                 // String ggzx
         2: astore_1
         3: return
      LineNumberTable:
        line 26: 0
        line 27: 3
}
SourceFile: "ConstantPoolTest.java"

结论:

  1. final 修饰的 8 种基本类型的值, 会全部进入常量池
  2. 非 final 修饰的, 也包括使用了 static 的情况, 只有 double, float,long 的值会进入常量池
  3. 所有字符串类型字面量 这里在以后的文章中的 StringTable 会讲, 很有趣
先看看如何存储 int 和 float 数据类型的变量

![[Pasted image 20230314134952.png]]

我们只需要了解, 对于这类 int, float,long, double 基本数据类型, 每个数据肯定都需要相同的存储空间.

String 又如何存储呢?

刚才上面我们说到, 对于哪一类固定存储空间的, 很简单. 那么 String 呢?String 需要的空间不一定啊.

这里我们要搞清楚一个点, 就是 String 和字符串在这里的小小区别 ,就是 String 并不是基本数据类型, 字符串是一个常量,String 属于引用, 其引用指向的内容, 是字符串.这里很重要嗷

既然谈到字符串了, 先来看看字符串如何存储的

// 下面的ConstantPool里面的部分 
#15 = String             #52            // ggzx !!!!,这里是我定义的字符串
#52 = Utf8               ggzx

// 这里是main方法的字节码
Code:
  stack=1, locals=2, args_size=1
	 0: ldc           #15                 // String ggzx
	 2: astore_1
	 3: return

欸, 怎么"定义了"两个 "ggzx"字符串, 但是其实没有哦, 这里的 #15 是啥呢, 是 String 引用, 那后面的 #52 有是啥, 是一个 Utf-8 类型欸, 这里指的就是一个字符串内容.

也就是说,String 是一个引用, 他保存着一个字符串, 所有字符串都是有编号的, String 直接指向字符串就可以了.

现在我们再来看看是 String 如何存储的,
![[Pasted image 20230314135408.png]]

看看这里,String 是一个引用, 他只需要保存目标字符串的序号即可.

在看一个图片:
![[Pasted image 20230314141501.png]]

引用类型如何存储的

经过 String 的分析, 你可能有一些头绪了. 引用类型, 是也给引用指向在堆中分配的实例数据.Class 就是一个文本哇, 哪里有堆?
来看看引用类型的结构:
![[Pasted image 20230314141529.png]]

这个是不是和 String 很像, 保存的依然是序号.
那这个序号存储的是啥呢?

符号引用: 不知道你看见这个的时候, 有没有想到类加载阶段的解析阶段. 对的, 没错, 就是哪个.
符号引用是啥呢:
符号引用本质上就是字符串, 但是这个字符串是具有意义的, 根据这个字符串能找到目标.
比如说类的全限定名: com.ggzx.User, 当然接口也可以.
在类加载的解析阶段: 会把符号引用解析成直接引用
解析动作主要针对于接口字段类方法接口方法，方法类型，因为没有将符号引用替换之前，比如说一个类，一个类的字段，调用的方法，其都是一个字符，而将符号引用解析成直接引用的过程是找到这个方法，这个类，这个属性的一个存储位置的指针。

撰文不易, 期望一个小小的赞.
本文讲的确实不多, 是因为我自己比较喜欢记录自己思考过的东西, 而不是去写一篇"说明书".
下一篇文章仍然会讲述 Class 文件相关的知识

Java class文件格式之数据类型_动力节点Java学院整理
08-30
除了这些基本类型之外，class文件的常量池还包含有其他类型的常量信息，例如CONSTANT_Class_info、CONSTANT_String_info、CONSTANT_Methodref_info等，它们分别用于存储类引用、字符串以及方法引用等信息。...
Java class文件格式之数据类型（二)_动力节点Java学院整理
08-30
在本文中，我们将深入探讨class文件中的数据类型，特别是CONSTANT_Class_info和CONSTANT_Fieldref_info这两个重要的数据项。 首先，CONSTANT_Class_info是常量池中的一个数据类型，它的作用是对类或接口的符号引用...
一个class文件到底包含了哪些东西
IT乐知
05-06 800
​通过对一个class文件的分析，基本理解了class文件结构，在这里最后再做一个总结，梳理下class文件内容。 两种结构 class文件内容如果泛化的区分可以分成两种结构： 1、字节数据：通过预先指定结构的占用字节数来存储基本的数据类型，比如class文件最开始的几个字节按顺序存储了魔数、小版本、大版本，在比如字段结构的访问标识符，都是通过提前确定了结构所占用的字节数，根据占用的字节来存储数据...
Class文件结构
weixin_30700977的博客
10-03 298
Class类文件结构 Class文件是一组以8字节为基础单位的二进制流， 各个数据项目严格按照顺序紧凑排列在class文件中， 中间没有任何分隔符，这使得class文件中存储的内容几乎是全部程序运行的程序。 Java虚拟机规范规定，Class文件格式采用类似C语言结构体的伪结构来存储数据，这种结构只有两种数据类型：无符号数和表。 无符号数 属于基本数据类型，主要可以用来描述数字...
Class文件是什么及其加载？
weixin_30532973的博客
10-06 110
Java编译器编译好.class文件后，产生的文件会放入磁盘或者网络。这种.class文件其实是Java独有的字节码（bytecode），只有Java虚拟机才能识别的机器码，Jvm读取.class文件，取出二进制数据，加载到内存中去，解析.class文件信息，生成对应的class对象。 过程如图： 转载于:https://www.cnblogs....
引用数据类型
热门推荐
AAA31321的博客
08-09 1万+
引用数据类型 1、 什么叫引用数据类型 - 引用数据类型是java的两大数据类型之一； - 该数据类型在创建的时候，会先在堆内存中分配一块空间，存储对象的具体信息，然后在栈中存储该对象的地址信息； 2、引用数据类型的种类： - 引用数据类型包括：类（class）、接口类型（interface）、数组类型（list）、枚举类型、注解类型，字符串型（String，String的衍生类，如StringBUilder等）。 3、需要注意的是 1、引用数据类型是由类加载器创建的，他们是用于访问对象的； 2、任何引用数
定义如下XML文档, class.xml (解析XML文件数据，保存到oracle数据库)
qq_51750546的博客
11-18 190
package StudyWork3; import java.util.ArrayList; import java.util.List; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; import org.dom4j.io.SAXReader; import lib.BaseDao; public class Test extends BaseDao { // .
java基本数据类型和引用类型以及他们的存储方式
zhengqiang的博客
09-15 803
1、基本数据类型： byte 8位 short 16 位 int 32 位 long 64位 float 32位 double 64位 2、基本数据类型和引用数据类型的存储位置： java中的基本数据类型是存储在栈中还是存储在堆中取决于基本类型声明在何处以及是否使用了关键词new 1、如果基本类型声明在方法中，并且没有使用关键词new，那么变量名和变量值都是存储在栈中...
11.基本数据类型与引用数据类型的存储方式
weixin_37714766的博客
02-06 1009
基本数据类型与引用数据类型的存储方式 在JVM(java虚拟机)中,数据类型主要存储在虚拟机栈(stack)和堆(heap)中。 1.JVM中的栈和堆 在虚拟机栈中存放了各种基本数据类型，以及对象的引用(不包括内存)。 在堆中存放了各种对象的实例，以及数组和字符串(数组和字符串其实也是引用数据类型)。 示例图： ​ 注：对象的引用(引用数据类型变量名)实际上存储的是对象在堆中分配空间的...
11.Class文件的数据结构1
08-04
以下是关于Class文件数据结构的详细说明： 1. **基础单位**： - Class文件基于8位字节的单位，即每个基本单元是1个字节。当需要存储超过1个字节的数据时，会按照高位在前的原则进行分割存储。 2. **无符号数**： ...
java教程课件5基本数据类型与引用类型
10-12
Java教程中的核心知识点主要涉及Java的基本数据类型、引用类型、常用包、对象的内存分配以及字符串操作。下面将对这些内容进行详细的阐述。 1. **基本数据类型与引用类型** - Java的基本数据类型包括布尔型`...
深入理解JVM之Class类文件结构详解
08-25
Java虚拟机规范规定，Class文件格式采用类似C语言结构体的伪结构来存储数据，这种结构只有两种数据类型：无符号数和表。 魔数和Class文件版本号 魔数是Class文件的头4个字节，是Java虚拟机确定这个Class文件是否是...
Class文件介绍
qq_45788130的博客
08-06 1276
Class文件介绍 1.Class文件都存了什么数据？ Class文件字节码结构组织示意图 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6i4Lquey-1628239418394)(C:\Users\孤风\AppData\Local\Temp\WeChat Files\f56d9bfd3953a51d6907839e62db027.png)] class常量池如何存储数据 1.常量池的常量有哪些 分为字面量和符号引用 2.常量池的里面是怎么组织的？ cp_info:常量池
第十八篇_Class文件
yingzi的技术博客
05-29 532
文章目录JVM基本组成 基于Hotspot虚拟机学习的过程 - 从上到下字节码文件的跨平台性Java的前端编译器透过字节码指令看代码执行细节举例Class文件到底存储的是什么什么是字节码指令（Byte Code）Class文件本质和内部数据类型Class文件的结构Class字节码文件结构Class文件版本号和平台的对应Class文件数据类型类型描述符常量类型和结构常量类型和结构细节访问标志字段表访问标志类索引、父类索引、接口索引属性的通用格式数据类型和默认初始值对应分别解释其作用魔数 Magic Numbe
Java引用类型(class、interface)用法总结详解
write less , do more
12-07 2433
实际的开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式基础上，进一步 去掌握引用类型的使用方式。基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类 型也是可以的。
Java知识点（六）：类和对象、引用类型、null和NullPointerException
qq_45138120的博客
04-26 1447
包含什么是类？什么是对象？成员变量、成员方法、对象的创建、成员变量初始化、什么是引用、引用类型声明、引用类型画等号：指向同一个对象、基本类型之间画等号：赋值、null：空、NullPointerException：空指针异常、面向过程和面向对象。
Java保存class文件,[转载]Class文件在JVM中如何存储
weixin_33154775的博客
03-11 976
JDK6 HotSpot VM用instanceKlass来记录类的元数据，每个Java类有一个对应的instanceKlass。每个instanceKlass上引用着一个constantPoolOopDesc对象，然后间接引用着一个constantPoolCacheOopDesc对象。前者跟Class文件里记录的常量池的结构类似，而后者是为了让解释器运行得更高效的一个缓存。举例的话，用Visua...
基本数据类型和引用数据类型的数据存储
eclipse_yin的博客
04-04 3232
实验总结，希望对大家有帮助。
基本类型与引用类型存储方式——基本类型存储在栈内存，存储具体数据或者内存地址 & 引用类型存储在堆内存，实际的引用类型的数据
weixin_44867717的博客
12-18 297
基本类型与引用类型存储方式——基本类型存储在栈内存，存储具体数据或者内存地址 & 引用类型存储在堆内存，实际的引用类型的数据 代码 <script type="text/javascript"> /* .运算符优先级最高 基本类型与引用类型存储方式： 基本类型存储在栈内存，存储具体数据或者内存地址 引用类型存储在堆内存，实际的引用类型的数据 a.x ——指在a的对象里面添加属性 x
java Class文件内部结构解析过程详解
09-04
Java Class文件是Java程序的核心组成部分，它包含了编译后的字节码指令，元数据和类相关的其他信息。本文将深入探讨Java Class文件的内部结构，帮助理解其工作原理。 首先，每个Java Class文件都以一个特定的魔数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

渣渣高不会写Java

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

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

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

打赏作者

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

抵扣说明：

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

余额充值