反射(reflection)

于 2022-02-21 14:46:07 发布
阅读量455 收藏
点赞数 1
分类专栏： JavaSE 文章标签： java 后端 反射 javase
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47200222/article/details/123046857
版权

反射(reflection)

文章目录

1.反射机制

1.1 反射机制原理示意图

reflection

1.2 反射机制功能

  • 在运行时判断任意一个对象所属的类
  • 在运行时构造任意一个类的对象
  • 在运行时得到任意一个类所具有的成员变量和方法
  • 在运行时调用任意一个对象的成员变量和方法
  • 生成动态代理

1.3 反射相关类的主要类

类名作用
java.lang.Class代表一个类，Class对象表示某个类加载后在堆中的对象
java.lang.reflect.Method代表类的方法,Method对象表示某个类的方法
java.lang.reflect.Field代表类的成员变量,Field对象表示某个类的成员变量
java.lang.reflect.Constructor代表类的构造方法,Constructor对象表示构造器

1.4 反射优点和缺点

  1. 优点:可以动态的创建和使用对象(也是框架底层核心),使用灵活,没有反射机制,框架技术就失去底层支撑。
  2. 缺点:使用反射基本是解释执行，对执行速度有影响。

1.5 反射调用优化-关闭访问检查

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

method.setAccessible(true); //在反射调用方法时，取消访问检查

2.Class类

bbf3086d27314f53806fb5b6425d4334

2.1 基本介绍

  1. Class也是类,因此也继承Object类
  2. Class类对象不是new出来的,而是系统创建的
  3. 对于某个类的实例都会记得自己是由哪个Class实例所生成
  4. 每个类的实例都会记得自己是由哪个Class实例所生成
  5. 通过Class对象可以完整地得到一个类的完整结构(通过一系列API)
  6. Class对象是存放在堆的
  7. 类的字节码二进制数据，是放在方法区的，有的地方为类的元数据(包括 方法代码，变量名，方法名，访问权限等等)

2.2 常用方法

car类

public class Car {

    public String brand = "宝马";
    public int price = 50000;
    public String color = "白色";

    public void Call() {
        System.out.println("小车呼呼叫。。。");
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", color='" + color + '\'' +
                '}';
    }
}

class02

/*
 * class常用方法演示
 */
public class Class02 {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException, NoSuchMethodException {

        String classAllPath = "com.xujc.Car";
        //1. 获取到Car类,对应的 Class对象
        //<?> 表示不确定的Java类型
        Class<?> cls = Class.forName(classAllPath);
        //2. 输出cls
        System.out.println(cls);//显示cls对象，是哪个类的Class对象 com.xujc.Car
        System.out.println(cls.getClass());//输出cls运行类型 java.lang.Class

        //3.得到包名
        System.out.println(cls.getPackage().getName()); //包名

        //4.得到全类名
        System.out.println(cls.getName());
        //5.通过cls创建对象实例
        Car car = (Car) cls.newInstance();
        System.out.println(car);//car.toString()
        //6.通过反射获取属性
        Field brand = cls.getField("brand");
        System.out.println(brand.get(car));
        //7.通过反射给属性赋值
        brand.set(car, "奔驰");
        System.out.println(brand.get(car));
        //8.我希望大家可以得到所有的属性(字段)
        System.out.println("=====所有的字段属性====");
        Field[] fields = cls.getFields();
        for (Field f : fields) {
            System.out.println(f.getName()); //名称
        }


    }
}

3.获取Class类对象

请添加图片描述

/**
 * 演示得到Class对象的各种方式(6)
 */
public class GetClass_ {
    public static void main(String[] args) throws ClassNotFoundException {
        //1. Class.forName
        String classAllPath = "com.xujc.Car"; //通过读取配置文件获取
        Class<?> cls1 = Class.forName(classAllPath);
        System.out.println(cls1);

        //2. 类名.class , 应用场景: 用于参数传递
        Class cls2 = Car.class;
        System.out.println(cls2);

        //3. 对象.getClass(), 应用场景，有对象实例
        Car car = new Car();
        Class cls3 = car.getClass();
        System.out.println(cls3);

        //4. 通过类加载器【4种】来获取到类的Class对象
        //(1)先得到类加载器 car
        ClassLoader classLoader = car.getClass().getClassLoader();
        //(2)通过类加载器得到Class对象
        Class cls4 = classLoader.loadClass(classAllPath);
        System.out.println(cls4);

        //cls1 , cls2 , cls3 , cls4 其实是同一个对象
        System.out.println(cls1.hashCode());
        System.out.println(cls2.hashCode());
        System.out.println(cls3.hashCode());
        System.out.println(cls4.hashCode());

        //5. 基本数据(int, char,boolean,float,double,byte,long,short) 按如下方式得到Class类对象
        Class<Integer> integerClass = int.class;
        Class<Character> characterClass = char.class;
        Class<Boolean> booleanClass = boolean.class;
        System.out.println(integerClass);//int

        //6. 基本数据类型对应的包装类，可以通过 .TYPE 得到Class类对象
        Class<Integer> type1 = Integer.TYPE;
        Class<Character> type2 = Character.TYPE; //其它包装类BOOLEAN, DOUBLE, LONG,BYTE等待
        System.out.println(type1);

        System.out.println(integerClass.hashCode());//
        System.out.println(type1.hashCode());//两者是一样的
    }
}

4.类加载

  • 基本说明

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

    1. 静态加载:编译时加载相关的类，如果没有则报错，依赖性太强

    2. 动态加载:运行时加载需要的类，如果运行时不用该类,即使不存在该类，也不会报错，降低了依赖性

  • 类加载时机

    1. 当创建对象时(new) //静态加载
    2. 当子类被加载时,父类也加载 //动态加载
    3. 调用类中的静态成员时 //静态加载
    4. 通过反射 //动态加载

  • 类加载3个阶段(5个子阶段)

    1. 加载阶段(Loading)

      JVM在该阶段的主要目的是将字节码从不同的数据源(可能是class文件、也可能是jar包，甚至网络)

      转化成二进制字节流加载到内存中，并生成一个代表该类的java.lang.Class对象

    2. 连接阶段-验证(verification)

      • 目的是为了是确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机

        自身的安全

      • 包括: 文件格式验证(是否以魔数 oxcafebabe开头)、元数据验证、字节码验证和

    3. 连接阶段-准备(preparation)

      • JVM会在该阶段对静态变量，分配内存并初始化(对应数据类型的默认初始值，如0、0L、null、false等)。

        这些变量所使用的内存都将在方法区中进行分配

    4. 链接阶段-解析(Resolution)

      • 虚拟机将常量池内的符号引用替换为直接引用的过程。

    5. 初始化(Initialization)

      • 到初始化阶段，才真正开始执行类中定义的Java程序代码,此阶段是执行()方法的过程

      • ()方法是由编译器按语句在源文件中出现的顺序,依次自动收集类中的所有静态变量的

        赋值动作和静态代码块中的语句,并进行合并。

      • 虚拟机会保证一个类()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去

        初始化一个类，那么只会有一个线程去执行这个类的()方法，其他线程需要阻塞等待，

        直到活动线程执行()方法完毕

请添加图片描述

5.通过反射获取类的结构信息

a> java.lang.Class类

api作用
getName获取全类名
getSimpleName获取简单类名
getFields获取所有public修饰的属性，包括本类以及父类的
getDeclaredFields获取本类中所有属性
getMethods获取所有public修饰的方法,包括本类以及父类的
getDeclaredMethods获取本类中所有方法
getConstructors获取本类所有public修饰的构造器
getDeclaredConstructors获取本类中所有构造器
getPackage以Package形式返回 包信息
getSuperClass以Class形式返回父类信息
getInterfaces以Class[]形式返回接口信息
getAnnotations以Annotation[]形式返回注解信息

b> java.lang.reflect.Field类

  1. getModifiers: 以int形式返回修饰符

    [说明:默认修饰符是 0,public是 1，private是 2,protect是 4,static是 8,final是 16，如果是两个修饰符则相加

    如public static返回的值是1+8=9]

  2. getType:以Class形式返回类型

  3. getName:返回属性名

c> java.lang.reflect.Method类

  1. getModifiers:以int形式返回修饰符

    [说明:默认修饰符是 0,public是 1，private是 2,protect是 4,static是 8,final是 16]

  2. getReturnType: 以Class形式获取 返回类型

  3. getName：返回方法名

  4. getParameterTypes:以Class[]返回参数类型数组

d> java.lang.reflect.Constructor类

  1. getModifiers:以int形式返回修饰符
  2. getName:返回构造器(全类名)
  3. getParameterTypes:以Class[]返回参数类型数组

e> 实例演示

/**
 * 通过反射获取类的结构信息
 */
public class ReflectionUtils {

    public static void main(String[] args) {

    }

    //第一组
    @Test
    public void api_01() throws ClassNotFoundException, NoSuchMethodException {

        //得到Class对象
        Class<?> personClass = Class.forName("com.xujc.reflection.Person");
        //| getName                 | 获取全类名                                     |
        System.out.println(personClass.getName());
        //| getSimpleName           | 获取简单类名                                   |
        System.out.println(personClass.getSimpleName());
        //| getFields               | 获取所有public修饰的属性，包括本类以及父类的   |
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println("本类以及父类的属性" + field.getName());
        }
        //| getDeclaredFields       | 获取本类中所有属性                             |
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName());
        }

        //| getMethods              | 获取所有public修饰的方法,包括本类以及父类的    |
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println("本类以及父类的方法=" + method.getName());
        }
        //        | getDeclaredMethods      | 获取本类中所有方法                             |
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类所有的方法" + declaredMethod);
        }
        // | getConstructors         | 获取所有public修饰的构造器，包括本类 |
        Constructor<?>[] constructors = personClass.getConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("本类的构造器=" + constructor.getName());
        }

        //         | getDeclaredConstructors | 获取本类中所有构造器                           |
        Constructor<?>[] declaredConstructors = personClass.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类的所有方法" + declaredConstructor);
        }
        //        | getPackage              | 以Package形式返回 包信息                       |
        System.out.println(personClass.getPackage());
        //        | getSuperClass           | 以Class形式返回父类信息                        |
        Class<?> superclass = personClass.getSuperclass();
        System.out.println("父类的class对象" + superclass);
        //         | getInterfaces           | 以Class[]形式返回接口信息                      |
        Class<?>[] interfaces = personClass.getInterfaces();
        for (Class<?> anInterface : interfaces) {
            System.out.println("接口信息=" + anInterface);
        }
        //        | getAnnotations          | 以Annotation[]形式返回注解信息                 |
        Annotation[] annotations = personClass.getAnnotations();
        for (Annotation annotation : annotations) {
            System.out.println("注解信息=" + annotation); //注解
        }
    }

    @Test
    public void api_02() throws ClassNotFoundException, NoSuchMethodException {

        //得到Class对象
        Class<?> personCls = Class.forName("com.xujc.reflection.Person");
        //getDeclaredFields: 获取本类中所有属性
        Field[] declaredFields = personCls.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("本类中所有属性=" + declaredField.getName()
                    + " 该属性的修饰符=" + declaredField.getModifiers()
                    + " 该属性的类型=" + declaredField.getType());
        }

        //getDeclaredMethods: 获取所有public修饰的方法,包括本类以及父类的
        Method[] declaredMethods = personCls.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println("本类以及父类的方法=" + declaredMethod.getName() +
                    " 该方法的访问修饰符值=" + declaredMethod.getModifiers() +
                    " 该方法返回类型" + declaredMethod.getReturnType());

            //输出当前这个方法的形参数组情况(无参不输出)
            Class<?>[] parameterTypes = declaredMethod.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该方法的形参类型=" + parameterType);
            }
        }

        //getDeclaredConstructors:获取本类中所有构造器
        Constructor<?>[] declaredConstructors = personCls.getDeclaredConstructors();
        for (Constructor<?> declaredConstructor : declaredConstructors) {
            System.out.println("本类的所有方法" + declaredConstructor);

            Class<?>[] parameterTypes = declaredConstructor.getParameterTypes();
            for (Class<?> parameterType : parameterTypes) {
                System.out.println("该构造器的形参类型=" + parameterType);
            }
        }

    }
}

class A {
    public String hobby;

    public void hi() {
    }

    //构造器
    public A() {
    }

    public A(String hobby) {
        this.hobby = hobby;
    }
}

interface IA {

}

interface IB {

}

@Deprecated
class Person extends A implements IA, IB {
    //属性
    public String name;
    protected int age;
    String job;
    private double sal;

    //构造器
    public Person() {
    }

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

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

    //方法
    public void m1(String name, int age, double sal) {

    }

    protected String m2() {
        return null;
    }

    void m3() {

    }

    private void m4() {

    }
}

6.通过反射创建对象

  1. 方式一: 调用类中的public修饰的无参构造器
  2. 方式二: 调用类中的指定构造器
  3. Class类相关方法
    • newInstance:调用类中的无参构造器，获取对应类的对象
    • getConstructor(Class…clazz):根据参数列表,获取对应的public构造器对象
    • getDecalaredConstructor(Class…clazz):根据参数列表，获取对应的所有构造器对象
  4. Constructor相关方法
    • setAccessible:爆破
    • newInstance(Object…obj):调用构造器

实例

/**
 * 通过反射创建对象
 */
public class ReflectCreateInstance {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1. 先获取到User类中的Class对象
        Class<?> userClass = Class.forName("com.xujc.reflection.User");
        //2. 通过pubic的无参构造器创建实例
        Object o = userClass.newInstance();
        System.out.println(o);
        //3. 通过public的有参构造器创建实例
        /*
            constructor 对象就是
            public User(String name) { //public的有参构造器
               this.name = name;
            }
         */

        //3.1 先得到对应的构造器
        Constructor<?> constructor = userClass.getConstructor(String.class);
        //3.2 创建实例,并传入实参
        Object aSoul = constructor.newInstance("一个魂");
        System.out.println("aSoul = " + aSoul);
        //4. 通过非public的有参构造器创建实例
        //4.1 得到private的构造器对象
        Constructor<?> constructor1 = userClass.getDeclaredConstructor(int.class, String.class);
        //4.2 创建实例
        constructor1.setAccessible(true); //暴破【暴力破解】 , 使用反射可以访问private构造器
        Object user2 = constructor1.newInstance(100, "向晚大魔王");
        System.out.println("user2 = " + user2);

    }

}

@Data
@NoArgsConstructor
class User {
    private int age = 10;
    private String name = "嘉然今天吃什么";

    public User(String name) { //public的有参构造器
        this.name = name;
    }

    private User(int age, String name) { //private 有参构造器
        this.age = age;
        this.name = name;
    }
}

7.通过反射访问类中的成员

  • 访问属性

    1. 根据属性名获取Field对象

      Field f = clazz对象.getDeclaredField(属性名);

    2. 爆破

      f.setAccessible(true);

    3. 访问

      f.set(0,值); //o表示对象

      syso(f.get(o)); //o表示对象

    注意: 如果是静态属性，则set和get中的参数o，可以写成null

  • 演示反射操作属性

    /**
 * 演示反射操作属性
 */
public class ReflectAccessProperty {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchFieldException {

        //1. 得到Student类对应的 Class 对象
        Class<?> stuClass = Class.forName("com.xujc.reflection.Student");
        //2. 创建对象
        Object o = stuClass.newInstance();// o 的运行类型就是Student
        System.out.println(o.getClass()); // Student
        //3. 使用反射得到age 属性对象
        Field age = stuClass.getField("age");
        age.set(o, 88); //通过反射操作属性
        System.out.println(o); //
        System.out.println(age.get(o)); //返回age的值

        //4. 使用反射操作 name 属性
        Field name = stuClass.getDeclaredField("name");
        //对name 进行爆破
        name.setAccessible(true);
        // name.set(o, "乃琳");
        name.set(null,"乃琳");  //因为name是static属性,因此 o 也可以写成null
        System.out.println(o); //获取属性值
        System.out.println(name.get(null)); //获取属性值,要求name是static
    }
}

@Data
@NoArgsConstructor
class Student {
    public int age = 10;
    private static String name = "嘉然今天吃什么";

    public Student(String name) { //public的有参构造器
        this.name = name;
    }

}

  • 访问方法

    1. 根据方法名和参数列表获取Method方法对象:

      Method m = clazz.getDeclaredMethod(方法名, XX.class);//得到本类的所有方法

    2. 获取对象

      Object o = clazz.newInstance();

    3. 爆破

      m.setAccessible(true)

    4. 访问

      Object returnValue = m.invoke(o,实参列表);

    注意: 如果是静态方法,则invoke的参数o,可以写成null

  • 演示反射操作方法

    /**
 * 演示反射操作方法
 */
public class ReflectAccessMethod {

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
        //1. 得到Boss类对应的Class对象
        Class<?> bossCls = Class.forName("com.xujc.reflection.Boss");
        //2. 创建对象
        Object o = bossCls.newInstance();
        //3. 调用public的hi方法
        // Method hi = bossCls.getMethod("hi",String.class);
        //3.1 获得hi方法对象
        Method hi = bossCls.getDeclaredMethod("hi",String.class); //OK
        //3.2 调出
        hi.invoke(o,"world");

        //4. 调用private static方法
        //4.1 得到 say 方法对象
        Method say = bossCls.getDeclaredMethod("say", int.class, String.class, char.class);
        //4.2 因为say方法是private,所以需要爆破,原理和前面讲的构造器和属性一样
        say.setAccessible(true);
        System.out.println(say.invoke(o,1,"人",'3'));
        //4.3 因为say方法是static的，还可以这样调用
        System.out.println(say.invoke(null,200,"鬼",'无'));

        //5. 在反射中,如果方法有返回值,统一返回Object,但是他运行类型和方法定义的返回类型一致
        Object reVal = say.invoke(null, 300, "王五", '男');
        System.out.println("reVal的运行类型 = " + reVal.getClass()); // String


    }

}

class Boss {
    private int age;
    private static String name;

    public Boss() { //构造器
    }

    private static String say(int n, String s, char c) { //静态方法
        return n + " " + s + " " + c;
    }

    public void hi(String s) { //普通方法
        System.out.println("hi " + s);
    }
}
J.T.L
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
反射Reflection小应用
07-21
在Java编程语言中，反射（Reflection）是一种强大的工具，它允许程序在运行时检查和操作类、接口、字段和方法的信息。通过反射，我们可以动态地创建对象、调用方法、访问字段，甚至处理私有成员，这在某些情况下非常...
C# 反射 Reflection
09-20
2. 命名空间：`System.Reflection`命名空间包含所有与反射相关的类。它是访问类型、成员和元数据的关键入口点。 二、动态类型创建与实例化 1. `Activator.CreateInstance()`: 这个静态方法允许我们在运行时根据类型...
反射机制（Reflection）
pmc0_0的博客
03-14 129
反射 Reflection(反射）是Java被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。 引用加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象)，这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，反射由此而来 正常方式：引入需要的包类名称—》new实例化—》取得实例化对象 反射方式：实例化对象
反射
cpongo55
01-11 225
每个类都有一个 Class 对象，包含了与类有关的信息。当编译一个新类时，会产生一个同名的 .class 文件，该文件内容保存着 Class 对象。 类加载相当于 Class 对象的加载，类在第一次使用时才动态加载到 JVM 中。也可以使用 Class.forName(“com.mysql.jdbc.Driver”)...
反射_刘锋的博客
jiu_mu_mu的博客
07-26 100
反射（Reflection） 反射是使java称为准动态语言的关键 加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象，一个类只有一个class对象，这个对象就包含了这个完整类的结构信息，这个过程就称为反射。 Class类 反射的根源 获取class类的几种方法 1、类名.class 这个方法是最为安全可靠的 2、对象名.getClass() 3、Class.forName(“类的路径”) 4、基本内置类型的包装类都有一个Type属性 // 通过Class的静态方法 Class user
java 反射机制图
biezanhan0147的博客
09-11 117
反射篇
zb6340430的博客
07-03 138
反射的原理当我们编写好一个“.java”文件，通过javac编译器编译后会形成一个“.class”文件。当我们运行该文件时，Java虚拟机就通过类加载器（类加载器本质就是一段程序）把“.class”文件加载到内存，在方法区形成该类各方法的代码段和描述该类细节信息的常量池，同时在堆区形成一个表示该类的Class对象（一个java.lang.Class类的实例）。Class对象中存储了指向了该类所有属...
java 反射Reflection；Class类
12-21
Java反射机制是Java编程语言中的一个重要特性，它允许程序在运行时动态地获取类的信息并进行操作。这一机制使得Java具备了动态性，能够在运行时分析类的结构，调用方法，访问字段，以及创建对象等。以下是关于Java...
reflection反射
07-13
Object instance = constructor.newInstance("Hello, Reflection!"); ``` 这会创建一个带有给定参数的新实例。 ### 5. 调用方法 `Method`对象提供了`invoke(Object obj, Object... args)`方法，允许我们在运行时...
java反射机制Reflection详解
08-26
java反射机制Reflection详解 Java反射机制Reflection是Java语言中的一个重要机制，它允许在程序运行期间访问类、接口、字段和方法，而不必在编译期间知道接口、字段或者方法的名称。反射机制使得Java程序更加灵活和...
java反射demo
11-13
java反射demo
Java 不安全的反射 unsafe reflection
最新发布
06-10
Java的"unsafe"包是指通过直接访问和修改内存绕过正常Java语言限制和安全检查的方式。这通常被认为是一种危险和不受支持的做法，因为它可能导致意外和不稳定的行为，从而导致崩溃、安全漏洞和其他问题的发生。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

J.T.L

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

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

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

打赏作者

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

抵扣说明：

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

余额充值