注解与反射笔记

最新推荐文章于 2024-05-06 10:37:06 发布
最新推荐文章于 2024-05-06 10:37:06 发布
阅读量100 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hoppinging/article/details/114669461
版权

2021/03/11

注解：Annotation
注释：Comment
注解与注释的关系：注解是一种可以被其他程序(比如编译器)读取的注释

注解的格式：@注释名
—— 可以添加一些参数，如@SuppressWarning(value=“unchecked”)

注释的使用位置：包(package)、类(class)、方法(method)、域(field)

常见的注解
@Override 表示重写超类中的方法 用于方法的修饰
@Deprecated 不建议使用（因为很危险或是有更好的选择） 可用于方法、属性、类的修饰
@SuppressWarning 镇压警告 用于抑制编译时的警告信息

Tip1 : @SuppressWarning需要参数，可以参考这篇博客： 忽略警告注解@SuppressWarnings详解

元注解(用于注解其他注解的注解)
@Target 表示被注解注解的使用范围
@Retention 表示被注解注解的生命周期(源码SOURCE < 编译文件CLASS < 运行时RUNTIME)
@Documented 表示被注解注解可以生成在Javadoc中
@Inherited 表示子类可以继承父类的这种注解

Tip2 : @Target也需要参数，可以去看看源码

自定义注解
@interface 定义自己的注解

Tip3 : 元注解可用在自定义注解上，常用的是@Target和@Retention
Tip4 : 自定义注解中参数的定义形式为：参数类型 + 参数名+ ()
Tip5 : 当自定义注解中参数唯一且参数名为value时，使用该注解并输入参数时默认不用写出参数名，即@CustomAnnotations(value = “XXX”)可以直接写作@CustomAnnotations(“XXX”)，@CustomAnnotations是自定义的注解

一个自定义注解的代码示例 ↓

/**
 * @author hoppi
 */
@Target({ElementType.TYPE,ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotion01{
    String name() default "";
    int age() default 0;
    int id() default -1; //默认的，如果值为-1，则表示不存在
    String[] schools();
}

反射：Reflection
 反射是Java被视为一门动态语言的关键，反射机制允许程序在执行期间借助Reflection API获取任何类的内部信息，并能操作对象的内部属性和方法
 当类加载完后，会在堆中产生一个Class类型的对象，此对象包含了该类完整的结构信息，我们可以通过对象看到类的信息的这种机制被形象地称为反射

获得类的方法

  1. 对象.getClass
  2. forName(“路径名”)
  3. 类名.class
  4. 包装类.Type
public class Learn03 {
    public static void main(String[] args) throws ClassNotFoundException {
        TestClass testClass = new TestClass();
        /** 1. 通过对象获得 */
        Class c1 = testClass.getClass();
        /** 2. 通过forName获得 */
        Class c2 = Class.forName("day2.TestClass");
        /** 3. 通过类名获得 */
        Class c3 = TestClass.class;
        /** 4. 通过Type属性获得(仅适用于内置基本类型的包装类) */
        Class c4 = Integer.TYPE;
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        /** 结果：
        class day2.TestClass
		class day2.TestClass
		class day2.TestClass
		int
		*/
    }
}
//新建一个类
class TestClass {
    private String name;

    public TestClass() {
    }

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

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

补充内容关于类加载器
 直接上代码

public class Learn04 {
    public static void main(String[] args) {
        TestClass02 testClass02 = new TestClass02();
        System.out.println(TestClass02.m);
        TestClass03 testClass03 = new TestClass03();
        System.out.println(TestClass03.m);
    }
}

class TestClass02 {
    static int m = 100;
    static {
        System.out.println("TestClass02类静态代码块初始化");
        m = 300;
    }
    public TestClass02() {
        System.out.println("TestClass02类构造方法初始化");
    }
}

class TestClass03 {
    static {
        System.out.println("TestClass03类静态代码块初始化");
        m = 300;
    }
    static int m = 100;
    public TestClass03() {
        System.out.println("TestClass03类构造方法初始化");
    }
}

上面这段代码的执行结果是：
 TestClass02类静态代码块初始化
 TestClass02类构造方法初始化
 300
 TestClass03类静态代码块初始化
 TestClass03类构造方法初始化
 100

  TestClass02与TestClass03的差别在于静态代码块(包含为m赋值操作)与静态变量m创建的顺序不同
  简单地思考可以得出，[静态代码块赋值] 和 [静态变量创建并赋值] 执行的先后关系应该是创建赋值分离，创建在前，然后依照顺序从前往后执行赋值
  然而事实并非如此，这二者的执行是没有先后顺序的，JVM在链接源码编译成的class文件加载到内存里的Class对象时，会先为所有类变量(static)在方法区分配内存并设置默认初始值
  然后执行类构造器<clinit>() 方法，类构造器<clinit>()是由编译期自动搜集的所有静态代码块中的语句、类变量的赋值动作糅合而成的，而为同一类变量赋值的语句会重叠覆盖
  换句话说，二者的先后不能影响二者执行的先后，却能影响最终真实的赋值操作，谁在后就赋谁的值。当然，按之前的思路理解也没什么影响就是了

狂神老师的PPT是这么写的：在这里插入图片描述

2021/03/12

好耶，周五没课

继续放狂神老师的PPT:
在这里插入图片描述

2021/03/14

类加载器的分类

  1. 引导类加载器 Bootstap Classloder
     用C++编写的JVM自带的加载器，负责Java平台核心类库的装载，无法直接获取
  2. 扩展类加载器 Extension Classloder
     负责将jre/lib/ext下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库
  3. 系统类加载器 System Classloder
     负责将java -classpath或-D java.class.path所指目录下的类与jar包装入工作库，是最常用的加载器
  4. 自定义加载器
package day3;

/**
 * <p>
 * 创建日期：2021-03-14 14:11
 * 类加载器
 * @author Hoppinging
 * @version 1.1
 * @since 1.0
 */
public class Learn05 {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取系统类的加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器:" + systemClassLoader);
        //获取系统类加载器的父类加载器->扩展类加载器
        ClassLoader parent = systemClassLoader.getParent();
        System.out.println("扩展类加载器:" + parent);
        //获取扩展类加载器的父类加载器->根加载器(引导类加载器)
        ClassLoader parent1 = parent.getParent();
        System.out.println("根加载器:" + parent1);
        //测试当前类是哪个加载器加载的
        ClassLoader classLoader = Learn05.class.getClassLoader();
        System.out.println("当前类加载器:" + classLoader);
        //测试JDK内置类加载器
        ClassLoader classLoader1 = Object.class.getClassLoader();
        System.out.println("内置类加载器:" + classLoader1);
        //获得系统类加载器可以加载的路径
        System.out.println(System.getProperty("java.class.path"));
    }
}

类加载器的双亲委派机制 用来保证类的安全性
可以参考这篇博文：双亲委派机制及其部分源码分析

获取类的运行时结构

package day3;

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

/**
 * <p>
 * 创建日期：2021-03-14 15:40
 * 获取类的运行时结构
 * @author Hoppinging
 * @version 1.1
 * @since 1.0
 */
public class Learn06 {
    public static void main(String[] args) throws NoSuchMethodException {
        Class testClass = Test.class;
        //获得类的名字
            //包名 + 类名
        System.out.println(testClass.getName());
            //类名
        System.out.println(testClass.getSimpleName());

        System.out.println("==============");

        //获得类的属性
            //获得public属性
        Field[] fields = testClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("==============");
            //获得所有属性
        fields = testClass.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        System.out.println("==============");
            //获得指定名字属性的信息
        try {
            System.out.println(testClass.getDeclaredField("name"));
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
        System.out.println("==============");
        //获得类的方法
            //获得本类及其父类的全部public方法
        Method[] methods = testClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("==============");
            //获得本类的全部方法(包括私有)
        methods = testClass.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        System.out.println("==============");
            //获得指定方法
        System.out.println(testClass.getMethod("print", null));
        System.out.println(testClass.getMethod("setName", String.class));
        System.out.println("==============");
        //获得构造器
            //获得public构造器
        Constructor[] constructors = testClass.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("==============");
            //获得全部构造器
        constructors = testClass.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
        System.out.println("==============");
            //获得指定构造器(按照参数)
        System.out.println(testClass.getDeclaredConstructor());
        System.out.println(testClass.getDeclaredConstructor(int.class, String.class, int.class, double.class));
    }
}
class Test {
    private int id;
    private String name;
    public int age;
    public double money;
    public Test(){}
    private Test(int id, String name, int age, double money) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.money = money;
    }

    public void print(){
        System.out.println("Hi, dog");
    }
    public void setName(String name) { this.name = name; }
    private void nothing(){
        System.out.println("");
    }
}

2021/03/21

动态创建对象执行方法

package day4;


import day3.Learn06;

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

/**
 * <p>
 * 创建日期：2021-03-15 18:45
 * 动态创建对象执行方法
 * @author Hoppinging
 * @version 1.1
 * @since 1.0
 */
public class Learn07 {
    public int age;
    public String name;
    private int id;
    public Learn07(){}
    public Learn07(int age, String name, int id){
        this.age = age;
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        //此处重写toString方法的原因是接下来输出构造出的对象时直观地表现对象的内容
        return "Learn07{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", id=" + id +
                '}';
    }

    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        //获得Class对象
        Class c1 = Class.forName("day4.Learn07");

        //Class类构造对象(本质是调用了类的无参构造器)
        //可以看到，这种方法已经被弃用
        Learn07 learn07 = (Learn07) c1.newInstance();
        System.out.println(learn07);

        //Class类构造器(大家一般都这么干)构造对象
            //无参
        learn07 = (Learn07) c1.getDeclaredConstructor().newInstance();
        System.out.println(learn07);
            //有参
        learn07 = (Learn07) c1.getDeclaredConstructor(int.class, String.class, int.class).newInstance(100, "George Wang", 99);
        System.out.println(learn07);

        //通过反射调用方法
            //1. 获取方法
        Method setName = c1.getDeclaredMethod("setName", String.class);
            //2. 激活方法
        setName.invoke(learn07, "Alpaca");
        System.out.println(learn07);

        //通过反射操作属性
            //操作public属性
        Field name = c1.getDeclaredField("name");
        name.set(learn07, "George Pig");
        System.out.println(learn07);
            //操作私有属性,setAccessible为true关闭安全检测
        Field id = c1.getDeclaredField("id");
        id.setAccessible(true);
        id.set(learn07, 33);
        System.out.println(learn07);

    }
}

反射性能对比
尝试通过不同的方式调用方法1000000000次，对比所用的时间

  1. 普通调用； 2. 反射调用； 3. 反射+关闭检测调用
package day4;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * <p>
 * 创建日期：2021-03-15 19:52
 * 反射性能对比
 * @author Hoppinging
 * @version 1.1
 * @since 1.0
 */
public class Learn08 {
    int age;
    public Learn08(){}

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
        Learn08 learn08 = new Learn08();
        learn08.test01();
        learn08.test02();
        learn08.test03();
    }
    /** 普通方式调用 */
    public void test01() {
        Learn08 learn08 = new Learn08();
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            learn08.setAge(1);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("普通方式：" + (endTime - startTime) + "ms");
    }
    /** 反射方式调用 */
    public void test02() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Learn08 learn08 = new Learn08();
        Class c1 = learn08.getClass();
        Method setAge = c1.getDeclaredMethod("setAge", int.class);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            setAge.invoke(learn08, 1);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式：" + (endTime - startTime) + "ms");
    }
    /** 反射方式调用，关闭检测 */
    public void test03() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Learn08 learn08 = new Learn08();
        Class c1 = learn08.getClass();
        Method setAge = c1.getDeclaredMethod("setAge", int.class);
        setAge.setAccessible(true);
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 1000000000; i++) {
            setAge.invoke(learn08, 1);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("反射方式(关闭检测)：" + (endTime - startTime) + "ms");
    }
}

应该出现的结果是：普通调用用时最短，关闭检测的反射调用次之，反射调用用时最长。
然而我的结果是反射调用比关闭检测的反射调用用时更短:
普通方式：5ms
反射方式：1581ms
反射方式(关闭检测)：1812ms

反射与泛型
使用反射来获取泛型信息

package day5;


import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 创建日期：2021-03-19 16:17
 * Generic泛型 使用反射来获取泛型信息
 * @author Hoppinging
 * @version 1.1
 * @since 1.0
 */
public class Learn09 {
    public static void main(String[] args) throws NoSuchMethodException {
        Method method = Learn09.class.getMethod("test01", Map.class, List.class);
        Type[] genericParameterTypes = method.getGenericParameterTypes();
        //打印test01的所有传入参数类型
        for (Type genericParameterType : genericParameterTypes) {
            if(genericParameterType instanceof ParameterizedType){
                Type[] actualTypeArguments = ((ParameterizedType) genericParameterType).getActualTypeArguments();
                for (Type actualTypeArgument : actualTypeArguments) {
                    System.out.println(actualTypeArgument);
                }
            }
        }
        method = Learn09.class.getMethod("test02", null);
        Type genericReturnType = method.getGenericReturnType();
        System.out.println("=======================");
        //打印test02的所有返回参数类型
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    }
    public void test01(Map<String, Integer> map, List<Boolean> list){
        System.out.println("Good job");
    }
    public List<String> test02(){
        return null;
    }
}

通过反射中使用泛型，可以避免使用反射生成的对象再次需要强制类型转换
关于反射与泛型的关系，可以去看看这篇博客：Java学习之反射与泛型

通过反射获得注解信息

package day5;

import java.lang.annotation.*;
import java.lang.reflect.Type;

/**
 * <p>
 * 创建日期：2021-03-19 17:08
 * 通过反射获取注解
 * @author Hoppinging
 * @version 1.1
 * @since 1.0
 */
public class Learn10 {
    public static void main(String[] args) throws NoSuchFieldException {
        //正题：通过反射获得类的注解
        Annotation[] annotations = SimulatedDatabase.class.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println(annotation);
        }
        //获得类注解的参数
        TableAnnotion annotation = SimulatedDatabase.class.getAnnotation(TableAnnotion.class);
        System.out.println(annotation.value());
        //获得属性的注解
        FieldAnnotion annotation1 = SimulatedDatabase.class.getDeclaredField("name").getAnnotation(FieldAnnotion.class);
        System.out.println(annotation1.name());
        System.out.println(annotation1.type());
        System.out.println(annotation1.length());
    }
}
@TableAnnotion("Students")
class SimulatedDatabase {
    @FieldAnnotion(name = "id", type = "int", length = 20)
    private int id;
    @FieldAnnotion(name = "age", type = "int", length = 3)
    private int age;
    @FieldAnnotion(name = "name", type = "varchar", length = 20)
    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
/** 类名的注解
 * @author hoppi*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TableAnnotion{
    //表名
    String value();
}
/** 属性的注解
 * @author hoppi*/
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface FieldAnnotion{
    //列名
    String name();
    //类型
    String type();
    //长度
    int length();
}
Hoppinging
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
注解和反射(狂神) 笔记
weixin_43905212的博客
12-14 1308
视频链接 p1 什么是注解：不是程序本身，可以对程序作出解释，但是区别于注释，注解可以写入参数，通过反射机制来获取所注解信息的访问。 p2 元注解：用来注解其他注解，有4个标准的meta-annotation：@Target、@Retention、@Documented、@Inherited，前两个常用。 Target需要传入ElementType数组作为value表示使用范围，其中ElementType是一个枚举类enum，包括类、域、方法、参数等。 Retention表示注解在什么地方有效，SO
java注解和反射的个人学习笔记
03-01
java注解和反射的个人学习笔记
注解
Valentino112358的博客
05-22 175
* 概念：说明程序的。给计算机看的 * 注释：用文字描述程序的。给程序员看的 * 定义：注解（Annotation），也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。 * 概念描述： * JDK1.5之后的新特性 * 说明程序的 ...
狂神笔记—注解与反射
hanpiyo的博客
02-03 499
学习狂神说Java—注解与反射的代码以及文字解析
注解和反射笔记
YANKUOP的博客
08-07 355
注解和反射学习记录
Java_注解与反射笔记
qq_44626465的博客
03-09 76
注解 Annotation(注解)-对程序作出解释，可被其他程序读取。 可附加在class,package等上面，通过发射机制，实现对元数据的访问。 内置注解 @Override适用于修辞方法，表示一个方法声明要重写超类中的另一个方法。 @Deprecated修辞方法，表示该方法不建议使用 @SupperssWarning抑制编译时的警告信息。 元注解：负责注解其他注解。有@Target，@Retention, @Documented, @Inherited @Target 描述注解的
狂神说Java学习笔记——注解与反射
weixin_65098078的博客
07-22 171
狂神说Java学习笔记——注解与反射
注解与反射笔记（狂神说）
qq_39831512的博客
01-20 305
注解和反射 注解（java.Annotation) 内置注解 @Override：重写注解 @Deprecated：废弃注解 @SuppressWarnings()：镇压警告 元注解 元注解的作用就是负责注解其他注解，Java定义了4个标准的meta-annotation类型，他们被用来提供对其他annotation类型作说明。 @Target:描述注解可以用在什么地方 @Retention：表示在什么级别保存该注解信息（描述注解的生命周期 SOURCE<CLASS<RUNTIME） @
JAVA 注解与反射 笔记
u012861792的博客
11-19 127
注解与反射 1. 什么是注解(Annotation) Annotation是从JDK5.0开始引入的新技术 Annotation的作用： 可以对程序作出解释，这一点和注释comment类似 对程序进行检查和约束，例如@Override 可以被其他程序（比如：编译器等）读取 @Override //重写注解，若是重写的方法名写错会出现警告 @Deprecated //不推荐使用注解，可以使用但是又风险或者有更好的方式 @SuppressWarnings //取消所有警告 Annotation的格
注解与反射笔记（尚学堂_高淇_视频课注解与反射）
海星的博客
07-02 145
一、注解 1、 二、反射 1、动态语言 1、动态语言：程序运行时，可以改变程序结构或变量类型。 eg:Python、ruby、javascript。 function test(){ var s = "var a=3;var b=5;alert(a+b);"; eval(s); } c、c++、java不是动态语言，但是java有一定动态性，我们可以利用反射、字节码操作获得类似动态语言的特性。 反射机制（reflection）：指的是可以于运行时加载、探知、使用编译期间完全未知的类。 一个类只对应一个
注解和反射机制的学习笔记
03-05
注解和反射机制的学习笔记
注解与反射-狂神说Java学习笔记
07-22
注解与反射—狂神说Java学习笔记
注解、反射、单元测试、lombok知识点总结笔记
01-30
关于注解、反射、单元测试、lombok等知识点的总结笔记
day021-反射和注解笔记和代码.rar
03-16
第一个next（可以设置生成文档注释的目录），第二个next，设置字符集 如果是UTF-8编码，且有中文，请输入-encoding UTF-8 -charset UTF-8 4. 勾选一个生成完毕后，直接通过浏览器打开的选项 5...
链表刷题集
yajunjiao的专栏
04-30 905
本文主要列举了一些刷的题，不多，有那么几道，也建议各位去建立自己的刷题集。积少成多。
《设计一款蓝牙热敏打印机》
最新发布
唐顺才的博客
05-06 201
安卓apk用java + kotlin编写、上位机用Qt编写。主控芯片用易兆威蓝牙ic，通讯接口：蓝牙、串口、usb。
【一步一步了解Java系列】：探索Java基本类型与C语言的区别
2302_81249757的博客
04-29 1220
​​喜欢的一句话： 常常会回顾努力的自己，所以要为自己的努力留下足迹。作者：小闭。
Nacos 配置中心实例分析实践
m0_73557631的博客
05-03 1016
​ 浏览器: http://localhost:5000/nacos/config/ip。先创建e-commerce-nacos-config-client5000 模块。​ 启动e-commerce-nacos-config-client5000。​ 启动Nacos Server。
信号与系统笔记pdf
09-22
同时，我们还可以在PDF中添加批注和注释，帮助我们更好地理解笔记内容。 总之，信号与系统笔记PDF是一种非常方便的学习工具。通过读取和编写这些文件，我们可以更好地理解和掌握信号与系统的知识，提高学习效果，为...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值