反射学习笔记

最新推荐文章于 2024-09-04 20:23:24 发布
最新推荐文章于 2024-09-04 20:23:24 发布
阅读量31 收藏
点赞数
文章标签： 学习 笔记 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51470924/article/details/132336303
版权

反射

需求：通过外部文件配置，在不修改源码的情况下，来控制程序，也符合设计模式 的ocp原则（开闭原则：不修改源码，开扩容功能）

配置文件
classfullpath=com.hspedu.Cat
method=hi

这样做的好处时，当方法改变时，不需要修改源码，直接改配置文件中的method即可。

用反射机制得到一个Class对象，接着通过Class对象new一个实例，接着用Class对象得到Method


public class ReflectionQUestion {
  public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
      
    //使用Properties类，可以读写配置文件
    Properties properties = new Properties();
    properties.load(new FileInputStream("D:/javacode/javaweb/javaweb/reflection/src/main/resources/re.properties"));
    String classfullpath = properties.get("classfullpath").toString();
    String methodName = properties.get("method").toString();


    //加载类，返回Class类型的对象cls
    Class cls = Class.forName(classfullpath);
    //通过cls得到加载的类com.hspedu.Cat实例对象
    Object o = cls.newInstance();
      //得到o的运行类型
    System.out.print(o.getClass());
    //通过cls得到加载的类com.hspedu.Cat的methodName的“hi”对象
    //即：在反射中，可以把方法视为对象
    Method method = cls.getMethod(methodName);
    System.out.println("======================");
    method.invoke(o);
  }
}

反射机制

​ 反射机制允许程序在执行期借助于ReflectionAPI取得任何类的内部信息（比如成员变量，构造器，成员方法等），并能操作对象的属性及方法。反射在设计模式和框架底层都会用到。

​ 加载完类之后，在堆中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象包含了类的完整结构信息。通过这个对象得到类的结构。这个对象就像一面镜子，通过这个镜子看到类的结构，所以，形象的称之为反射。

🍕java程序在计算机有三个阶段

  • 代码阶段/编译阶段
    • java文件通过javac编译生成字节码文件
  • Class类阶段（加载阶段）
    • 加载字节码文件，将字节码文件加载到内存中的堆中去。类加载器完成，体现反射机制。
  • Runtime运行阶段

创建对象Cat cat = new Cat();会导致类的加载,加载Cat.class字节码文件，将字节码文件加载到内存中的堆中去，生成一个Class类对象。类加载完成之后生成对象，Cat对象知道它是属于那个Class对象。因此，通过对象也可以知道它所关联的Class

反射机制可以完成

  • 在运行时可以判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时得到任意一个类所具有的成员变量和方法
  • 在运行时调用任意一个对象的成员变量和方法
  • 生成动态代理
反射相关的类
  • java.lang.Class:代表一个类，Class对象表示加载后在堆中的对象
  • java.lang.reflect.Method：代表类的方法,Method对象表示某个类的方法
  • java.lang.reflect.Filed：代表类的成员变量，Filed对象表示某个类的成员变量
  • java.lang.reflectConstructor：代表类的构造方法，Constructor对象表示构造器

反射的调用优化

反射的优点：可以动态的创建和使用对象（也是框架底层的核心），使用灵活，没有反射机制，框架技术就失去底层支撑

缺点：使用反射基本是解释执行，对执行速度有影响

反射调用优化—关闭访问检查（有点作用，但是效果不是特别明显）

  • Method、Field、Constructor对象都有setAccessible()方法
  • setAccessible()方法的作用是启动和禁用访问安全检查的开关
  • 参数值为true，反射的对象在使用时取消访问检查，提高反射效率，参数值为False表示反射的对象执行访问检查

Class类

  • Class也是类，因此也继承了Object（从IDEA类图中看出）
  • Class类对象不是new出来的，而是系统创建的
  • 对于某个类的Class类对象，在内存中只有一份，因为类只加载一次
  • 每个类的实例都会记得自己是由那个Class实例所生成的
  • 通过Class对象可以完整地得到一个类的完整结构，通过一系列API
  • Class对象是存放在堆的
  • 类的字节码二进制数据是放在方法区的，有的地方称为元数据（包括方法代码、变量名、方法名、访问权限等）

类class对象是由类加载器（ClassLoader）生成的，通过loadClass( )方法完成类加载，生成某个类对应的Class对象。

package com.hspedu.reflection.question;

import java.lang.reflect.Field;
public class Class02 {

  public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {
    String classPath = "com.hspedu.Car";
    //获取Car类对应的Class对象
    //<?>不确定的java类型
    Class<?> cls = Class.forName(classPath);
    //1、显示cls对象，是哪个类的Class对象 com.hspedu.Car,cls不是真正的Car对象
    System.out.println(cls);
    //2、输出cls运行类型 java.lang.Class
    System.out.println(cls.getClass());
    //3、得到包名 com.hspedu
    System.out.println(cls.getPackage().getName());
    //4、得到全类名
    System.out.println(cls.getName());
    //5、通过cls创建对象实例
    Object car = cls.newInstance();
    //6、通过反射获取属性brand
    Field brand = cls.getField("brand");
    System.out.println(brand.get(car));
    //7、通过反射给属性赋值
    brand.set(car,"奔驰");
    System.out.println(brand.get(car));
    //8、遍历所有属性
    Field[] fields = cls.getFields();
    for(Field field : fields){
      System.out.println(field.getName());
    }

  }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U6T1IqXq-1692240829078)(study/08151.jpg)]

获取Class类对象

  1. 前提：已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可以会抛出ClassNotFoundException异常

应用场景：多用于配置文件，读取全类路径，加载类

  1. 前提：若已知具体类，通过类的Class获取，该方式最为可靠，程序性能最高 Class cls2 = Cat.Class

应用场景：多用于参数传递，比如通过反射得到对应的构造器对象。

  1. 前提：已知某个类的实例，调用该实例的getClass( )方法获取Class对象，实例Class cls3 = 对象.getClass();

应用场景：通过创建好的对象，获取Class对象

  1. 其他方式

ClassLoader cl = 对象.getClass().getClassLoader();

Class cl2 = cl.loadClass("类的全类名");

  1. 基本数据（int 、char、boolean、float、double、byte、long、short）按如下方式得到Class类对象Class cls = 基本数据类型.class

  2. 基本数据类型对应的包装类，可以通过.type得到Class类Class cls = 包装类.TYPE;

  • 代码阶段\编译阶段:Class.forName 需要类加载器ClassLoader调用loadClass()方法获取类对象
  • Class类阶段（加载阶段）类.Class
  • Runtime运行阶段 对象.Class 即由对象可以知道它是属于那个Class对象，Class类型就是它真正加载进来的字节码文件Cat.class的类型，也就是它的运行类型（多态 编译类型与运行类型）

那些类型由Class对象

  1. 外部类、成员内部类、静态内部类、局部内部类、匿名内部类
  2. interface：接口
  3. 数组
  4. enum：枚举
  5. annotation：注解
  6. 基本数据类型
  7. void返回类型

类加载

类加载是指在Java程序运行期间，将类的字节码文件（.class文件）加载到Java虚拟机（JVM）中，并转换成可执行的Java类的过程。

基本说明：

反射机制是java是实现动态语言的关键，也是通过反射实现类动态加载。

  • 静态加载：在编译时就会加载相关的类，依赖性太强。Cat cat = new Cat();当没有该类时，编译时会报错。

  • 动态加载：运行时加载需要的类，如果运行时不用该类且该类不存在，则不报错，降低了依赖性。比如Class.forName("person")编译不报错，但是如果运行时，由于条件分支，没有用到这里也不会报错。只有运行到该代码时才会报错。

  • 动态加载可以说是延迟加载，静态加载是及时加载。

类加载时间

  • 当创建对象时（new）
  • 当子类被加载时，父类也加载
  • 调用类中静态成员时
  • 通过反射

前三种是静态加载，反射是动态加载。

类加载过程：

java源码（Cat.java） —javac编译—->字节码文件（com.Cat.class）—java运行—>加载Loading、连接Linking、初始化initialization(类加载三个阶段)

类加载后内存布局情况

生成的字节码文件通过类加载器，可以把字节码加载到内存中，并在堆中生成了类的Class对象，以及在方法区中得到了类的字节码的二进制数据。

类加载各阶段完成的任务

🍉加载（Loading）

将类的class文件读入内存，并为之创建一个java.lang.Class对象，此过程由类的加载器完成。JVM在该阶段的主要目的将字节码从不同的数据源（类的字节码可以来源于本地文件系统、网络、数据库等）转化为二进制数据加载到内存中。

🍉连接（Linking）将类的二进制数据合并到JRE中。

  • 验证（verification)对文件安全性进行校验。目的是确保Class文件的字节流中包含的信息符号当前虚拟机的要求，包括校验文件格式、元数据的正确性、字节码的正确性等。可以考虑使用-Xverify:none参数关闭大部分类的验证措施，缩短虚拟机加载时间。
  • 准备（Preparation）为类的静态变量分配内存并设置默认初始值。这些变量使用的内存都将在方法区中进行分配。
class A{
  /*
  属性也是成员变量
  分析：类加载链接阶段 准备属性是如何处理
  n1是实例属性，不是静态变量，因此在准备阶段，是不会分配内存
  n2是静态变量，分配内存 n2默认初始化是0，而不是20
  n3是static final 是常量，它和静态变量不一样，一旦赋值就不会 n3=30

   */
  public int n1 = 10;
  public static int n2 = 20;
  public static final int n3 = 30;
}
  • 解析（Resolution）虚拟机将常量池内的符号引用替换为直接引用的过程。符号引用是指在编译时使用的类、方法、字段等的符号名称，而直接引用是指在虚拟机运行时直接指向内存中的对象。

🍉初始化（initialization）JVM负责对类进行初始化，这里主要是指静态成员。

执行类的初始化代码，包括静态变量赋值和静态代码块的执行。类的初始化是类加载过程的最后一步，它会按需触发并保证在多线程环境下的安全性。

  • 到了初始阶段，才真正开始执行类中定义的java代码，此阶段是执行clinit()方法的过程。
  • clinit方法是由编译器按语句在源文件中出现的顺序，依次自动收集类中的所有静态变量的赋值动作和静态代码块中的语句，并进行合并。
    • 不创建类的对象，只加载类，构造器不执行
    • 如果直接使用类的静态属性，会导致类的加载
  • 虚拟机会保证一个类的clinit方法在多线程环境中被正确地枷锁、同步，如果多个线程去同时初始化一个类，那么只会一个线程去执行这个类的clinit方法，其他线程都需要阻塞等待，直到活动线程执行clinit方法完毕。正是因为有这个机制，才能保证某个类在内存中，只有一份Class对象。

反射获取类的结构信息

  • java.lang.Class

可以获取全类名、简单类名、所有public修饰的属性、方法（本类以及父类），本类的public修饰的构造器，本类所有的属性、方法、构造器，以及包、父类、接口、注解。

  • java.lang.reflect.Field

  • java.lang.reflect.Method

  • java.lang.reflect.Constructor

package com.hspedu.reflection.question;

import org.junit.Test;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class ReflectionUtils {
  public static void main(String[] args) {

  }
  @Test
  public void api_02() throws ClassNotFoundException {
    Class<?> personClass = Class.forName("com.hspedu.Person");
    Field[] fields = personClass.getDeclaredFields();
    //getModifiers 以int形式返回修饰符
    //默认修饰符0，public 1，private 2，protected 4， static 8，final 16
    //返回的是属性类型对应的那个Class类对象
    for (Field field : fields) {
      System.out.println("本类所有属性："+field.getName()+"----该属性的修饰符值"+field.getModifiers()+"----该属性的类型"+field.getType());
    }

    Method[] methods = personClass.getDeclaredMethods();
    for (Method method : methods) {
      System.out.println("本类所有方法："+method.getName()+"----该方法的修饰符值"+method.getModifiers()+"----该方法的返回值类型"+method.getReturnType());
      //返回参数类型数组
      Class<?>[] parameterTypes = method.getParameterTypes();
      for(Class<?> parameterType : parameterTypes){
        System.out.println("该方法的形参类型"+parameterType);
      }
    }

    Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
    for(Constructor<?> declaredConstructor : declaredConstructors){
      System.out.println("本类中所有构造器"+declaredConstructor.getName());

      Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
      for(Class<?> parameterType : parameterTypes){
        System.out.println("该构造器的形参类型"+parameterType);
      }
    }
  }
}
通过反射创建对象
  1. 调用类中的public修饰的无参构造器
  2. 调用类中的指定构造器

Class类相关方法

  • newInstance：调用类中无参构造器，获取对应类的对象
  • getConstructor（Class… clazz）：根据参数列表，获取public对应的构造器对象
  • getDecalaredConstructor（Class… clazz):根据参数，获取对应的所有构造器对象

Constructor类相关方法

​ setAccessible：暴破

​ newInstance（Object … obj）:调用构造器

反射暴破机制创建实例

package com.hspedu.reflection.question;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

public class ReflectCreateInstance {
  public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
    Class<?> userClass = Class.forName("com.hspedu.reflection.question.User");

    //通过public无参构造器创建实例
    Object o = userClass.newInstance();//o的运行类型就是User
    System.out.println(o);
    //通过public有参构造器创建实例
    //先得到构造器，再创建实例，并传入实参
    Constructor<?> constructor = userClass.getConstructor(String.class);//得到public修饰的构造器对象
    Object o1 = constructor.newInstance("涂山璟");
    System.out.println("user1 " + o1);

    //通过非public有参构造器创建实例
    Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
    constructor1.setAccessible(true);//解决构造器私有化问题，即使用反射可以访问private的构造器、方法、属性，
    // 暴力破解，反射面前都是纸老虎
    Object o2 = constructor1.newInstance(100, "叶十七");
    System.out.println("user2 "+o2);

    Field age =userClass.getField("age");
    age.set(o,66);
    System.out.println(o);
    System.out.println(age.get(o));

    Field desc = userClass.getDeclaredField("desc");
    desc.setAccessible(true);
    //desc.set(o,"厉害了");
    desc.set(null,"厉害了");//因为desc是static属性，因此o也可以写成null

    System.out.println("user3 "+o);
    //System.out.println(desc.get(o));
    System.out.println(desc.get(null));

  }

}
class User{
  public int age=10;
  private String name="啊哈";

  private static String desc;

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

  private User(int age, String name) {
    this.age = age;
    this.name = name;
  }

  @Override
  public String toString() {
    return "User [ age=" + age +", name=" + name + ", desc=" + desc + "]";
  }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LFm50bLL-1692240829081)(study/0816.jpg)]

通过反射访问类中的成员

🌷访问属性

  1. 根据属性名获取Field对象Field f = clazz对象.getDeclaredField(属性名);
  2. 暴破：f.setAccessible(true);
  3. 访问 f.set(o,值); f.get(o);
  4. 如果是静态属性，则set和get中的参数可以写成null，因为静态属性是和类相关的，不是和对象相关的

🌷访问方法

  1. 根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名，XX.Class);
  2. 获取对象Object o = clazz.newInstance();
  3. 暴破：m.setAccessible(true);
  4. 访问：Object returnValue = m.invoke(o,实参列表);
  5. 注意：如果是静态方法，则invoke的参数o,可以写成null

f = clazz对象.getDeclaredField(属性名); 2. 暴破：f.setAccessible(true);3. 访问f.set(o,值); f.get(o);`
4. 如果是静态属性，则set和get中的参数可以写成null，因为静态属性是和类相关的，不是和对象相关的

🌷访问方法

  1. 根据方法名和参数列表获取Method方法对象：Method m = clazz.getDeclaredMethod(方法名，XX.Class);
  2. 获取对象Object o = clazz.newInstance();
  3. 暴破：m.setAccessible(true);
  4. 访问：Object returnValue = m.invoke(o,实参列表);
  5. 注意：如果是静态方法，则invoke的参数o,可以写成null
123456lww
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
java反射实现接口_Java反射学习笔记
weixin_36354965的博客
02-25 1885
非原创：以下内容都是学习Java反射时从网上摘录的信息汇总Java反射机制可以让我们在编译期(Compile Time)之外的运行期(Runtime)检查类，接口，变量以及方法的信息。反射还可以让我们在运行期实例化对象，调用方法，通过调用get/set方法获取变量的值。下面是一个Java反射的简单例子：Method[] methods = MyObject.class.getMethods();f...
Java反射学习笔记
TroyeMartin的博客
09-20 123
Java反射学习笔记
sqlalchemy ORM reflection反射学习笔记
LelemamaAnne的博客
02-03 799
把数据库模式反射到ORM风格的类中，可以使用SQLAlchemy扩展模块中的automap（自动映射) 为了反射数据库，需要使用automap_base。 from sqlalchemy import create_engine, select from sqlalchemy.ext.automap import automap_base from sqlalchemy.orm import Session # 使用automap_base()创建一个Base对象 Base = automap_b
反射——学习笔记
BlackPenguin的博客
05-20 102
反射，是指反向探知，逆向去学习与使用类内部细节的方法。在Java运行时，动态的去获取对象的信息，并调用其属性。 通过动态获取类的内容、动态调用对象的方法和属性的机制，就叫做Java的反射机制。 一、获取类对象 这个对象是类对象，即该对象指代了一个类，通过该对象可以获取其指代类的具体信息以及属性方法，如类名、包名、加载器、类中的方法等等。 以下是获取类对象的四种方式。 public class MainTest { public static void main(String[] args) t
java学习——java中的反射学习笔记.rar_java 反射
09-21
本篇笔记将深入探讨Java反射的概念、重要性以及如何使用。 一、反射基础 1. 类加载：当Java虚拟机（JVM）加载一个类时，它会创建该类的Class对象。这个对象包含了关于类的所有信息，包括方法、字段、构造器等。...
【学习笔记】卫星通信NTN 3GPP标准化进展分析（六）- 参考标准
u011376987的博客
09-01 1118
本文总结了NTN标准化进程以及后续的研究计划，是学习NTN协议的入门。本文来自3GPP Joern Krause, 3GPP MCC。
Datawhale X 李宏毅苹果书AI夏令营 学习笔记
m0_61049596的博客
08-31 1024
今天，我继续学习了深度学习中的优化算法，并且着重理解了如何利用。等高级优化器来提高模型训练的效率和效果。2024年8月30日。
iomuxc、pinctrl子系统、gpio子系统（学习总结）
最新发布
weixin_61385844的博客
09-04 746
IOMUXC是SOC设计中实现引脚复用的关键组件，它通过动态切换引脚功能，提高了IO资源的利用率，满足了不同外设和功能的IO需求。在配置和使用IOMUXC时，需要参考芯片使用手册和设备树文档，确保引脚功能的正确设置。
SpringCloud Alibaba】（十三）学习 RocketMQ 消息队列
sco5282的博客
09-01 1274
引入MQ最大的优点就是异步解耦和流量削峰，但是引入 MQ 后也有很多需要注意的事项和问题，主要包括：系统的整体可用性降低、系统的复杂度变高、引入了消息一致性的问题。重新打开 cmd 命令行，进入 RocketMQ 的 bin 目录，在命令行输入如下命令调用 RocketMQ 自带的消费者程序消费 RocketMQ 中的消息。下单成功后将订单的信息发送到 RocketMQ，然后用户微服务订阅 RocketMQ 的消息，接收到消息后进行打印。说明生产者发送到 RocketMQ 的消息，被消费者成功消费到了。
学习项目1
m0_62803606的博客
09-03 1521
这篇文章主要记录你最近入手的无线串口模块的配置情况，这是个很好的习惯，尤其是在你以后需要重复操作或排查问题时，会非常有帮助。- **DL_20无线串口模块**：这是一个常见的无线串口通信模块，通常基于nRF24L01+等无线通信芯片，支持点对点或多点通信，适合短距离的无线数据传输。是的，如果你按照步骤成功配置了两个模块并将它们连接到单机和电脑，当你在上位机软件（如SSCOM）上能稳定地接收到从单片机发送的数据（例如每秒输出的T值），就说明两个无线模块之间的通信已经配置成功。
关于HarmonyOS的学习
m0_72035166的博客
08-30 768
1.flex固定定位的特点：脱离文档流，不会占位置；相对于body定位；不区分元素类型；不会随滚动条的滚动而滚动。2.sticky粘性定位的特点：是在固定定位和相对定位之间的一种定位。如果设置了坐标，满足条件，那么他就是固定定位，反之就是相对定位。3.吸顶效果*{margin: 0;padding: 0;main{4.轮播图结构：opacity，表示透明：取值范围0-1 0.1 0.2... 可以省略0不写；
Web3开发与安全：6个月高效学习路径
weixin_47075747的博客
08-30 1733
这份计划应该能帮助你系统地学习智能合约开发和安全审计技能，同时克服英语的障碍。
AI实践与学习8-AI Agent Workflow助力解题和验证答案置信度
xiaosi的博客
08-30 807
之前在试着提高解题正确率，目标100%，发现外部知识不足仅依靠大模型的话比较困难。而试题人工生产成本巨大。本质因为大模型生成内容会有幻觉特点，也就是说解答的试题正确性不太好评判，直接解答试题生产场景不太可控。后面考虑调用OpenAI解题的时候，像xxx那样通过输出置信度来帮助判断答案的正确性 or 其他形式只要能保证LLM生成答案是可靠（程序判断）的。
算法的学习笔记—把数字翻译成字符串
业精于勤，荒于嬉
08-31 935
通过动态规划的方法，我们可以高效地计算出一个数字字符串有多少种不同的翻译方法。这个问题不仅考察了我们对动态规划的理解，还让我们熟悉了如何处理字符串中的边界情况和状态转移。希望通过这个例子的讲解，能够帮助你更好地理解动态规划的应用。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybit欢迎大家加入我的社区尘觉社区文章到这里就结束了，如果有什么疑问的地方请指出，诸佬们一起来评论区一起讨论
假期学习-- iOS runtime的简单了解
m0_74217598的博客
09-04 742
（Runtime字典转模型，数据的接受取决于模型的属性）首先需要了解，属性定义在类里面，那么类里面就有一个属性列表，属性列表以数组的形式存在，根据属性列表就可以获得类里面的所有属性名，所以遍历属性列表，也就可以遍历模型中的所有属性名。所以RunTime字典转模型过程就很清晰了。
2024.8.30 学习记录
sdhdhdhdh的博客
08-30 188
思维导图：
Go语言学习笔记精要
"Go 学习笔记 第三版" 这是一份关于Go语言的学习笔记，作者通过简洁易懂的方式，分享了自己对Go语言的理解和实践经验。笔记旨在帮助读者快速复习和掌握Go语言的关键知识点，尤其适合已经有一定编程基础的程序员使用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值