疯狂java18

最新推荐文章于 2024-07-20 20:17:20 发布
最新推荐文章于 2024-07-20 20:17:20 发布
阅读量470 收藏
点赞数
分类专栏： 疯狂java讲义
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43958223/article/details/108793420
版权

类加载机制与反射

类的加载，连接和初始化

​ 系统可能在第一次使用某个类时加载该类，也可能才用预加载机制来加载某个类。

JVM和类

​ 当调用java命令运行java程序时，该命令将会启动一个java虚拟机进程，不管该java程序有多复杂，该程序启动了多少个进程，它们都处于该java虚拟机进程里。当系统出现以下情况时，JVM进程会被终止：

  1. 程序运行到最后正常结束
  2. 程序运行到使用System.exit()或Runntime.getRuntime().exit()代码处结束程序
  3. 程序执行过程中遇到未捕获异常或者错误而结束
  4. 程序所在平台强制结束了JVM进程

JVM进程结束，该进程所在内存中的状态将会丢失

类的加载

​ 当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过加载、连接、初始化三个步骤来对该类进行初始化。

​ 类的加载时将该类的class文件读入内存，并为之创建一个java.lang.Class对象，也就是说，当程序使用任何类时，系统都会为之建立一个java.lang.Class对象。

​ 类的加载通过JVM提供的类加载器完成，类加载器是程序运行的基础，JVM提供的类加载器被称为系统类加载器。除此之外，开发者可以通过继承ClassLoader基类来创建自己的类加载器。

​ 通过不同的类加载器，可以从不同来源加载类的二进制数据，通常有这几种来源

  1. 从本地文件系统加载class文件，这是前面绝大部分实例程序的类加载方式
  2. 从jar包加载class文件，这种方式也是很常见的，jdbc编程所用的驱动类就放在jar文件中，JVM可以直接从jar文件中加载该class文件。
  3. 通过网络加载class文件
  4. 把一个Java源文件动态编译，并执行加载

​ 类加载器通常无需等到首次使用该类时才加载该类，Java虚拟机规范允许系统预先加载某些类。

类的连接

​ 当类被加载之后，系统为之生成一个对应的Class对象，接着将会进入连接阶段，连接阶段负责把类的二进制数据合并到JRE中，类的连接分为三个阶段：

  1. 验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致
  2. 准备：类准备阶段则负责为类的类变量分配内存，并设置默认初始值
  3. 解析：将类的二进制数据中的符号引用替换成直接引用

类的初始化

​ 在类初始化阶段，虚拟机负责对类进行初始化，主要是对类变量进行初始化。

​ java类中对类变量指定初始值有两种方式：1. 声明类变量时指定初始化 ；2. 使用静态初始化块为类变量指定初始值

​ JVM初始化一个类的步骤：

  1. 加载并连接该类
  2. 先初始化其直接父类
  3. 依次执行初始化语句

​ 当执行第2步时，系统对直接父类的初始化也遵循1~3,以此类推

类初始化的时机

​ 当java程序首次通过下面6种方式来使用某个类或接口时，系统会初始化该类或接口

  1. 创建类的实例。创建类的实例包括new操作符来创建实例，通过反射来创建实例，通过反射实例化创建实例
  2. 调用某个类的类方法（静态方法）
  3. 访问某个类或接口的类变量或为该类变量赋值
  4. 使用反射方式来强制来创建某个类或接口的java.lang.Class对象。例如代码“Class.forname(“Person”)”,如果系统还未初始化Person类，则这行代码会导致Person类被初始化，并返回person类的java.lang.Class对象
  5. 初始化某个类的子类
  6. 使用java.exe命令来运行某个主类。当运行某个主类时，程序会初始化该主类

特别情况：

​ 一个final类型的类变量，该类变量的值在编译时就确认下来，这个类变量相当于宏变量，编译器会在编译时把这个类变量出现的地方直接替换成它的值，

类加载器

​ 加载器负责将.class文件加载到内存中，并且生成对应的java.lang.Class对象。

类加载器简介

​ 一个载入JVM的类有一个唯一的标识。在Java中，一个类使用全限定类名（包括包名和类名）作为标识；但在JVM中，一个类使用全限定类名和其类加载器作为唯一标识。

当JVM启动时，会形成由三个类加载器组成的初始类加载器层次结构

  • Bootstrap ClassLoader：跟类加载器
  • Extension ClassLoader：扩展类加载器
  • System ClassLoader：系统类加载器

Bootrap ClassLoader被称为引导（也称为原始或跟）类加载器，它负责加载Java的核心类。根类加载器不是java.lang.ClassLoader的子类，而是JVM自身实现的。

Extension ClassLoader负责加载JRE拓展目录中的JAR包的类，它的父类加载器是根类加载器

System ClassLoader，它负责在JVM启动时加载来自Java命令的-classpath选项、java.class,path系统属性，或CLASSPATH指定的jar包和类历经。系统可通过ClassLoader的静态方法或区该系统类加载器。如果没有特别指定，则用户自定义的类加载器都已类加载器作为父加载器

类加载机制

​ JVM的类加载器机制主要有三种：

  1. 全盘负责。就是当类加载器负责加载某个Class时，该Class所依赖的和所引用的其他Class也将由该类加载器负责载入，除非显式使用另外一个类加载器来载入
  2. 父类委托。所谓父类委托，就是先让父类加载器试图加载该Class。只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
  3. 缓存机制。缓存机制将会保证所有加载过的Class都会被缓存，当程序需要使用时，先从缓存中搜索该Class，当缓存中不存在该Class，系统菜才读取该类对应的二进制数据，并将其转为Class对象，存入缓存区中。这就是为什么修改了Class后，必须重新启动JVM，程序所做的修改才会生效的原因。

在这里插入图片描述

​ 类加载器之间的父子关系不是类继承父子关系，这里的父子关系是类加载器实例之间的关系。

//访问JVM的类加载器
public class ClassLoaderPropTest {
    public static void main(String[] args) throws IOException {
        //获取类加载器
        ClassLoader systemLoader=ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器："+systemLoader);
        /*
        获取系统类加载器的加载路径---通常由CLASSPATH环境变量指定
        如果操作系统没有指定CLASSPATH环境变量，则默认以当前路径作为
        系统类加载器的加载路径
        */
        Enumeration<URL> em1=systemLoader.getResources("");
        while (em1.hasMoreElements()){
            System.out.println(em1.nextElement());
        }
        //获取系统类加载器的父类加载器，得到扩展类加载器
        ClassLoader extensionLader=systemLoader.getParent();
        System.out.println("扩展类加载器:"+extensionLader);
        System.out.println("扩展类加载器的加载路径："+System.getProperty("java.ext.dirs"));
        System.out.println("扩展类加载器的parent："+extensionLader.getParent());
    }
}

类加载器加载Class大致经过8个步骤

  1. 检测此Class是否载入过（即缓存区中是否有此Class),如果有则直接进入第8步，否者接着第2步
  2. 如果父类加载器（父类 gt+ 加载器，要么Parent一定是跟类加载器，要么本身就是跟类加载器）不存在，则调到第4步执行
  3. 请求使用父类加载器载入目标类，如果成功载入调到第8步
  4. 请求使用跟类加载器来载入目标类
  5. 当前类加载器尝试寻找Class文件（从与此ClassLoader相关的类路径中寻找），如果找到则执行第6步，如果找不到执行第7步
  6. 从文件中载入Class，成功载入调到第8步
  7. 抛出ClassNotFoundException异常
  8. 返回对应的java.lang.Class对象

其中，第5、6步允许重写ClassLoader的findClass()方法来实现自己的载入策略，甚至重写loadClass()方法来实现自己的载入过程。

创建并使用自定义的类加载器

​ JVM除跟类加载器之外的所有类加载器都是ClassLoader子类的实例，开发者可以通过拓展ClassLoader的子类，并重写该ClassLoader所包含的方法实现自定义的类加载器。ClassLoader有如下两个关键方法。

在这里插入图片描述

​ 如果需要是实现自定义的ClassLoader,则可以通过重写以上两个方法来实现，通常推荐重写findClass()方法而不是loadClass()方法。

classLoader()方法的执行步骤：

  1. findLoadedClass():来检查是否加载类，如果加载直接返回。
  2. 父类加载器上调用loadClass()方法。如果父类加载器为null，则使用跟类加载器加载。
  3. 调用findClass(String)方法查找类

从上面看出，重写findClass()方法可以避免覆盖默认类加载器的父类委托，缓冲机制两种策略；如果重写loadClass()方法，则实现逻辑更为复杂。

ClassLoader的一些方法：

  • Class defineClass(String name,byte[] b,int off,int len)：负责将字节码分析成运行时数据结构，并检验有效性
  • findSystemClass(String name):从本地文件系统装入文件。
  • static getSystemClassLoader():返回系统类加载器
  • getParent():获取该类加载器的父类加载器
  • resolveClass(Class<?> c)：链接指定的类
  • findClassLoader(String name)：如果加载器加载了名为name的类，则返回该类对用的Class实例，否则返回null。该方法是类加载缓存机制的体现。
//下面程序开发了一个自定义的ClassLoader。该classLoader通过重写findClass()方法来实现自定义的类加载机制。
//这个ClassLoader可以在加载类之前先编译该类的源文件，从而实现运行Java之前先编译该程序的目标，
//这样即可通过该classLoader运行Java源文件。
public class CompileClassLoader extends ClassLoader {
    //读取一个文件内容
    private byte[] getBytes(String filename) throws IOException {
        File file=new File(filename);
        long len=file.length();
        byte[] raw=new byte[(int) len];
        try(FileInputStream fin=new FileInputStream(file)){
            //一次读取class文件的全部二进制数据
            int r=fin.read(raw);
            if(r!=len){
                throw new IOException("无法读取全部文件："+r+"!"+len);
            }
            return raw;
        }
    }
    //定义编译指定java文件的方法
    private boolean compile(String javaFile) throws IOException {
        System.out.println("CompileClassLoder:正在编译"+javaFile+"...");
        //调用系统的javac命令
        Process p= Runtime.getRuntime().exec("javac"+javaFile);
        try{
            //其他线程都等待这个线程完成
            p.waitFor();
        }catch (InterruptedException e){
            System.out.println(e);
        }
        //获取javac线程的退出值
        int ret=p.exitValue();
        //返回编译是否成功
        return ret==0;
    }
    //重写ClassLoader的findClass方法
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class clazz=null;
        //将包路径中的点(.)替换成斜杠(/)
        String fileStub=name.replace(".","/");
        String javaFilename=fileStub+".java";
        String classFilename=fileStub+".class";
        File javaFile=new File(javaFilename);
        File classFile=new File(classFilename);
        //当指定java源文件存在，且Class文件不存在，或者java源文件
        //的修改时间比Class文件的修改时间更晚时，重新编译
        if(javaFile.exists()&&(!classFile.exists()||javaFile.lastModified()>classFile.lastModified())){
            try{
                //如果编译失败，或者该Class文件不存在
                if(!compile(javaFilename)||!classFile.exists()){
                    throw new ClassNotFoundException("ClassNotFoundExceptoon:"+javaFilename);
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        //如果Class文件存在，系统负责将该文件转换成Class对象
        if(classFile.exists()){
            try{
                //将Class文件的二进制数据读入数组
                byte[] raw=getBytes(classFilename);
                //调用ClassLoader的defineClass方法将二进制数据转换成Class对象
                clazz=defineClass(name,raw,0,raw.length);
            }catch (IOException e){
                e.printStackTrace();
            }
        }
        //如果clazz为null，表明加载失败，则抛出异常
        if(clazz==null){
            throw new ClassNotFoundException(name);
        }
        return clazz;
    }

    public static void main(String[] args) throws Exception {
        //如果运行该程序时没有参数，即没有目标类
        if(args.length<1){
            System.out.println("缺少目标类，请按如下格式运行java源文件");
            System.out.println("java CompileClassLoader ClassName");
        }
        //第一个参数是要运行的类
        String progClass=args[0];
        //剩下的参数作为运行目标类的参数
        //将这些参数复制到一个新数组中
        String[] progArgs=new String[args.length-1];
        System.arraycopy(args,1,progArgs,0,progArgs.length);
        CompileClassLoader ccl=new CompileClassLoader();
        //加载需要运行的类
        Class<?> clazz=ccl.loadClass(progClass);
        //获取需要运行的类的方法
        Method main=clazz.getMethod("main",(new String[0]).getClass());
        Object argsArray[]={progArgs};
        main.invoke(null,argsArray);
    }
}

​ 通过重写findClass()方法，可以实现自定义类加载器机制。

​ 接下来可以提供任意一个简单的主类，该主类无需编译就可以使用上面的CompileClassLoader来运行他

public class Hello {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.println("运行Hello的参数："+arg);
        }
    }
}

​ 无需编译该Hello.java,可以直接运行下面命令来运行该Hello.java程序

java CompileClassLoader hello 疯狂Java讲义

​ 运行结果如下：

CompileClassLoader:正常编译 Hello.java...
运行hello的参数：疯狂Java讲义

使用自定义的类加载器，可以实现如下功能

  1. 执行代码前自动验证数字签名
  2. 根据用户提供的密码解密代码，从而可以实现代码混淆器来避免反编译*.class文件
  3. 根据应用需求把其他数据以字节码的形式加载到应用中。

URLClassLoader类

​ 该类时系统类加载器和拓展类加载器的父类（此处的父类，是指类与类之间的的继承关系）。URLClassLoader功能比较强大，它可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件加载类。

该类提供两个构造器

  • URLClassLoader(URL[] urls)：使用默认的父类加载器创建一个ClassLoader对象，该对象将从urls所指定的路径来查询并加载类
  • URLClassLoader(URL[] urls,ClassLoader prarent)：使用指定的父类加载器创建一个ClassLoader对象，该对象将从urls所指定的路径来查询并加载类。
//下面程序示范了如何从文件系统中加载MySQL驱动，并使用该驱动获取数据库连接。
//通过这种方式来获取数据库连接，无需将MySQL驱动添加到CLASSPATH中。
public class URLClassLoaderTest {
    private static Connection conn;
    public static Connection getConn(String url,String user,String pass) throws Exception{
        if(conn == null){
            URL[] urls = {new URL("file:mysql-connection-java-5.1.46-bin.jar")};
            URLClassLoader myClassLoader = new URLClassLoader(urls);
            //加载MySQL，并创建实例
            Driver driver = (Driver)myClassLoader.loadClass("com.mysql.jdbc.Driveer").newInstance();

            Properties properties = new Properties();
            properties.setProperty("user",user);
            properties.setProperty("pass",pass);
            //调用driver的connect方法来取得数据库连接
            conn = driver.connect(url,properties);
        }
        return conn;

    }
    public static void main(String[] args) throws Exception {
        System.out.println(getConn("jdbc:mysql://localhost:3306/tb_test","sherman","a123"));
    }
}

​ 本程序类加载器的加载路径是当前路径下的mysql-connection-java-5.1.46-bin.jar文件，将MySQL驱动复制到该路径下，这样保证ClassLoader可以正常加载到驱动类

通过反射查看类信息

​ Java程序中的许多对象在运行时都会出现收到外部传入的一个对象，该对象编译时类型是Object，但程序又需要调用该对象运行时的方法。

  • 第一种做法是假设编译时和运行时都知道该对象的的类型的具体信息，这种情况下，可以先用instanceof()运算符进行判断，再利用强制类型转换将其转换成运行时类型的变量即可
  • 第二种做法是编译时根本无法知道该对象和类可能属于那些类，程序只依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射

获得Class对象

​ 每个类被加载后，系统会为该类生成一个对应的Class对象，通过该Class对象可以访问到JVM中的这个类。获得Class对象通常三种方式

  1. 使用Class类的forName(String clazz)静态方法。字符串参数传入全限定类名（必须添加包名），可能会抛出ClassNotFoundexception异常。
  2. 调用某个类的class属性来获取该类的的Class对象。
  3. 调用某个对象的getClass()方法，该方法是Object类的一个方法。

对于第一种方式，第二种的优势：

  • 代码更安全。程序在编译阶段就可以检查需要访问的Class对象是否存在。
  • 程序性能更好。这的种方式无需调用方法，所以性能更好。

从Class中获取信息

Class类提供了大量的实例方法获取该Class对象所对应类的详细信息

下面4个方法用于获取Class对象对应类的构造器

  • ConStructor getConStructor(Class<?> parameterTypes)：返回Class对象对应类的，带指定参数列表的public构造器
  • ConStructor<?>[] getConStructor()：返回此Class对象对应类的所有public构造器
  • ConStructor getDeclaredConStructor(Class<?>… parameterTypes)：返回此Class对象对应类的、带指定参数列表的构造器，与构造器的访问权限无关
  • ConStructor<?>[] getDeclaredConStructor()：返回此Class对象对应类的所有构造器，与构造器的访问权限无关

下面四个方法获取Class对象对应类所包含方法。

  • Method getMethod(String name,Class<?> parameterTypes)：返回Class对象对应类的,带指定形参列表的public方法
  • Method[] getMethods()：返回Class对象对应类的所有public方法
  • Method getDeclaredMethod(String name,Class<?> parameterTypes)：返回Class对象对应类的,带指定形参列表的方法,与访问权限无关
  • Method[] getDeclaredMethods()：返回Class对象对应类的所有全部方法，与方法的访问权限无关

下面四个方法获取Class对象对应类所包含的成员变量。

  • Field getField(String name)：返回Class对象对应类的,指定名称的public成员变量
  • Field[] getFIelds()：返回Class对象对应类的所有public成员变量
  • Field getDeclaredField(String name)：返回Class对象对应类的,指定名称的成员变量，与成员的访问权限无关
  • Field[] getFIelds()：返回Class对象对应类的所有成员变量,与成员的访问权限无关

如下几个方法用于访问Class对应类的上所包含的Annotation.

  • A getAnnotation(Class annotationClass):尝试获取该Class对象对应类存在的，指定类型的Annotation；如果该类型的注解不存在，则返回null。
  • A getDeclaredAnnotation(Class annotationClass):Java 8新增方法，尝试获取直接修饰该Class对象对应类存在的，指定类型的Annotation；如果该类型的注解不存在，则返回null。
  • Annotation[] getAnnotations()：获取该Class对象对应类存在的所有Annotation
  • Annotation[] getDiclaredAnnotations()：获取直接修饰该Class对象对应类存在的所有Annotation
  • A[] getAnnotationByType(Class annotationClass):由于Java 8的新增了重复注解功能，因此需要使用该方法获取修饰该Class对象对应类，指定类型的多个Annotation
  • A[] getDeclaredAnnotationByType(Class annotationClass):由于Java 8的新增了重复注解功能，因此需要使用该方法获取直接修饰该类的，指定类型的多个Annotation

如下方法用于访问Class对应类的内部类

  • Class<?>[] getDeclaredClass()：返回该Class对象对应类里包含的内部类

如下方法用于访问Class对应类的所在的外部类

  • Class<?>[] getDeclaringClass()：返回该Class对象对应类所在的外部类

如下方法用于访问Class对应类的所实现的接口

  • Class<?>[] getInterfaces():返回该Class对象对应类的所实现的接口

如下方法用于访问Class对应类的所继承的父类

  • Class<? super T> getSuperClass()：返回该Class对象对应类的超类的Class对象

如下方法用于访问Class对应类的修饰符，所在包，类名等基本信息

  • int getModifiers()：返回此类或接口的所有修饰符对应的常量，返回的整数需要Modifier工具类的方法来解码，才可以获取真正的修饰符
  • Package getPackage()：获取此类的包
  • String getName()：以字符串的形式返回该Class对象对应类的类名
  • String getSimpleName()：以字符串的形式返回该Class对象对应类的简称

以下几个方法来判断该类是否为接口、枚举、注解类型

  • boolean isAnnotation()：返回此Class对象是否表示一个注解类型（有@interface定义）
  • boolean isAnnotationPresent(Class<? extends Annotation>annotationClass):判断此Class对象是否使用了注解修饰
  • boolean isAnonymousClass()：返回此Class对象是否为匿名类
  • boolean isArray()：返回此Class对象是否为数组类
  • boolean isEnum()：返回此Class对象是否为枚举类
  • boolean isInterface()：返回此Class对象是否为接口
  • boolean isInstance(Object obj)：判断obj是否为该Class对象的实例，该方法可以替代instanceof操作符

以上getMethod()方法和getConStructor()方法中，都需要传入多个类型为Class<?>的参数，用于获取指定的方法和构造器。要确定一个方法应该由方法名和形参列表确定。例如下面代码获取clazz对应类的带一个String参数的info方法：

clazz.getMethods("info",String.class)

若要获取clazz对应类的带一个String参数，一个Integer参数的info方法

clazz.getMethods("info",String.class,Integer.class)

Java 8新增加的方法参数反射

​ Java 8新增了一个Executable抽象基类，该对象代表可执行的类成员，该类派生了Constructor和Method两个子类。

​ Executable抽象基类提供了大量方法来获取修饰该方法或构造器的注解信息；还提供了is VarArgs()方法用于判断该方法或构造器是否包含数量可变的形参，以及通过getModifiers()方法获取该方法或构造器的修饰符。除此之外，还提供如下两个方法

  • int getParameterCount()：获取该构造器或方法的形参个数
  • Parameter[] getParameters()：获取该构造器或方法的所有形参

Parameter类是Java 8新增的api，提供了大量方法来获取声明该方法或参数个数的泛型信息，还提供了如下方法获取参数信息

  • getModifiers()：获取修饰该形参的修饰符
  • String getName()：获取形参名
  • Type getParameterizedType()：获取带泛型的形参类型
  • Class<?> getType()：获取形参类型
  • boolean isNamePresent()：该方法返回该类的class文件中是否包含了方法的形参名信息
  • boolean isVarArgs()：判断该参数是否为个数可变的形参

需要指出的是，使用javac命令编译Java源文件时，默认生成的class文件并不包含方法的形参名信息，因此调用isNamePresent()将返回false，调用getName()也不能得到该参数的形参名。需要编译时保留形参信息，则需要该命令指定-parameter选项。

//示范了Java 8的参数反射功能
class Test{
    public void replace(String str,List<String> list){}
}
public class MethodParameterTest {
    public static void main(String[] args) throws Exception {
        //获取String的类
        Class<Test> clazz = Test.class;
        //获取String类的带两个参数的replace方法
        Method replace = clazz.getMethod("replace",String.class,List.class);
       //获取指定方法的参数
        System.out.println("replace方法的参数个数为："+replace.getParameterCount());
        //获取replace的所有参数信息
        Parameter[] parameters = replace.getParameters();
        int index = 1;
        //遍历所有参数
        for(Parameter parameter:parameters){
            if(!parameter.isNamePresent()){
                System.out.println("-----第"+index+"行的参数信息-----");
                System.out.println("参数名："+parameter.getName());
                System.out.println("形参类型："+parameter.getType());
                System.out.println("泛型类型："+parameter.getParameterizedType());
            }
        }
    }
}

使用反射生成并操作对象

​ Class对象可以获得该类的方法，构造器，成员变量。程序可以通过Method对象来执行对应的方法，通过ConStructor对象调用对应的构造器创建实例，能通过Field对象直接访问并修改对象的成员变量值。

创建对象

​ 通过反射生成对象有两种方式。

  • 使用Class对象的newInstance()方法来创建该Class对象对应类的实例，这种方式要求该Class对象的对应类有默认构造器。
  • 先使用Class对象获取指定的Constructor对象，在调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。
//实现一个简单的对象池，该对象池根据配置文件读取key-value对，然后创建这些对象，并放入HashMap中
public class ObjectPoolFactory {
    //定义一个对象池，前面是对象名，后面是实际对象
    private Map<String,Object> objectPool=new HashMap<>();
    //定义一个创建对象的方法
    //该方法只要传入   一个字符串类名，程序可以根据该类名生成java对象
    private Object createObject(String clazzName) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        //根据字符串来获取对应的Class对象
        Class<?> clazz=Class.forName(clazzName);
        //使用clazz对应类的默认构造器创建实例
        return  clazz.newInstance();
    }
    //该方法根据指定文件来初始化对象池
    //它会根据配置文件来创建对象
    public void initPool(String fileName){
        try(
                FileInputStream fis=new FileInputStream(fileName);
                ){
            Properties props=new Properties();
            props.load(fis);
            for (String name : props.stringPropertyNames()) {
                //每取出一对key-value对，就根据value创建一个对象
                //调用createObject()创建对象，并将对象添加到对象池中
                objectPool.put(name,props.getProperty(name));
            }
        }catch (IOException e){
            System.out.println("读取："+fileName+"异常");
        }
    }
    public Object getObject(String name){
        //从objcetPool中取出指定name对应的对象
        return objectPool.get(name);
    }

    public static void main(String[] args) {
        ObjectPoolFactory pf=new ObjectPoolFactory();
        pf.initPool("obj.txt");
        System.out.println(pf.getObject("a"));
        System.out.println(pf.getObject("b"));
    }
}

利用Constructor对象，指定构造器来创建java对象，需要三个步骤

  1. 获取该类的Class对象
  2. 利用Class对象的getConstructor()方法来获取指定的构造器
  3. 调用Constructor的newInstance()方法来创建java对象
//利用反射创建一个JFrame对象，使用指定构造器
public class CreateJFrame {
    public static void main(String[] args) throws Exception {
        //获取JFrame对应的Class对象
        Class<?> jframeClazz=Class.forName("javax.swing.JFrame");
        //获取JFrame中带一个字符串参数的构造器
        Constructor ctor=jframeClazz.getConstructor(String.class);
        //调用Constructor的newInstance方法创建对象
        Object obj=ctor.newInstance("测试窗口");
        //输出JFrame对象
        System.out.println(obj);
    }
}

​ 实际上，只有当程序需要动态创建某个类的对象时才会考虑使用反射，通常在开发通用性比较好的框架，基础平台时才会大量使用反射。

调用方法

​ 可以通过Class对象的getMethods()方法和getMethod()方法来获取全部方法和指定方法。

​ 每个Method对象对应一个方法，可以通过它调用对应的方法，在Method里包含一个invoke()方法，该方法的签名如下。

  • Object invoke(Object obj,Object… args)：该方法中的obj是执行该方法的主调，后面的args是执行该方法时传入该方法的实参
//下面程序是对象池工厂加强版，它允许在配置文件中增加配置对象的成员变量的值，
//对象池工厂会读取为该对象配置的成员变量值，并利用该对象的Setter方法设置成员变量的值。
public class ExtendedObjectPoolFactory {
    //定义一个对象池，前面是对象名，后面是实际对象
    private Map<String,Object> objectPool=new HashMap<>();
    private Properties config=new Properties();
    //从指定属性文件中初始化Properties对象
    public void init(String fileName){
        try(FileInputStream fis=new FileInputStream(fileName)){
            config.load(fis);
        }catch (IOException e){
            System.out.println("读取："+fileName+"异常");
        }
    }
    //定义一个创建对象的方法
    //该方法只传入一个字符串类名，程序可以根据该类名生成java对象
    private Object createObject(String clazzName) throws IllegalAccessException, InstantiationException, ClassNotFoundException {
        //根据字符串来获取对应的Class对象
        Class<?> clazz=Class.forName(clazzName);
        //使用clazz对应类的默认构造器创建实例
        return clazz.newInstance();
    }
    //该方法根据指定文件来初始化对象池
    //它会根据配置文件来创建对象
    public void initPool() throws IllegalAccessException, ClassNotFoundException, InstantiationException {
        for (String name : config.stringPropertyNames()) {
            //每取出一个键值对，如果key中不包含百分号(%)
            //这就表明是根据valuel来创建一个对象
            //调用createObject来创建对象，并将对象添加到对象池中
            if(!name.contains("%")){
                objectPool.put(name,createObject(config.getProperty(name)));
            }
        }
    }
    //该方法将会根据属性文件来调用指定对象的setter方法
    public void initProperty() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        for (String name : config.stringPropertyNames()) {
            //每取出一对key-value对，如果key中包含百分号(%)
            //即可认为该key用于控制调用对象setter方法设置值
            //%前半为对象名字，后半控制setter方法名
            if(name.contains("%")){
                //将配置文件中的key按%分割
                String[] objAndProp=name.split("%");
                //取出调用setter方法的参数值
                Object target=getObject(objAndProp[0]);
                //获取setter方法名：set+"首字母大写"+剩下部分
                String mtdName="set"+objAndProp[1].substring(1);
                //通过target的getClass()获取他的实现类所对应的Class对象
                Class<?> targetClass=target.getClass();
                //获取希望调用的setter方法
                Method mtd=targetClass.getMethod(mtdName,String.class);
                //通过Method的invoke方法执行setter方法
                //将config.getProperty(name)的值作为调用setter方法的参数
                mtd.invoke(target,config.getProperty(name));
            }
        }
    }
    public Object getObject(String name){
        //从objectPool中取出指定name对应的对象
        return objectPool.get(name);
    }

    public static void main(String[] args) throws  Exception {
        ExtendedObjectPoolFactory epf=new ExtendedObjectPoolFactory();
        epf.init("extObj.txt");
        epf.initPool();
        epf.initProperty();
        System.out.println(epf.getObject("a"));
    }
}

在这里插入图片描述

访问成员变量

​ 通过Class对象的getFields()方法和getField()方法可以获取该类包含的所有成员变量和指定成员变量。Field提供如下方法读取或设置成员变量值

  • getXxx(Object obj)：获取Object对象的成员变量值。此处的Xxx对应8种基本类型，如果该成员变量类型时引用类型，则取消get后面的Xxx。
  • setXxx(Object obj,Xxx val)：将obj对象的该成员变量设置成val值。此处的Xxx对应8种基本类型，如果该成员变量类型时引用类型，则取消set后面的Xxx。
//使用两个方法随意访问指定对象的所有成员变量，包括private修饰的成员变量
class Person{
    private String name;
    private int age;

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

public class FieldTest {
    public static void main(String[] args) throws Exception {
        //创建一个Person对象
        Person  p=new Person();
        //获取Person类对应的Class对象
        Class<Person> personClazz=Person.class;
        //获取Person的名为name的成员变量
        //使用getDeclaredField()方法表名可获取各种访问控制符的成员变量
        Field nameField=personClazz.getDeclaredField("name");
        //设置通过反射访问成员变量时取消访问权限检查
        nameField.setAccessible(true);
        //调用set()方法为p对象的name成员变量设置值
        nameField.set(p,"Yeeku.H.Lee");
        //获取Person类名为age的成员变量
        Field ageField=personClazz.getDeclaredField("age");
        //设置通过反射访问该成员变量时取消访问权限检查
        ageField.setAccessible(true);
        //调用setInt()方法为p对象的age成员变量设置值
        ageField.set(p,30);
        System.out.println(p);
    }
}

操作数组

​ 在java.lang.reflect包下还提供了一个Array类，Array对象可以代表所有的数组。程序可以通过使用该类来创建数组，操作数组元素等。

​ Array提供如下方法

  • static Object newInstance(Class<?>ComponentType,int… length)：创建一个具有指定的元素类型，指定维度的新数组
  • static xxx getXxx(Object array,int index)：返回数组array的第index个元素。此处的xxx对应8种基本类型，如果数组元素是引用类型，则该方法变为get(Object array,int index)。
  • static void setXxx(Object array,int index,Object val)：将数组array的第index个元素设置为val。此处的xxx对应8种基本类型，如果数组元素是引用类型，则该方法变为set(Object array,int index,Object val)。
public class ArrayTest1 {
    public static void main(String[] args) {
        try{
            //创建一个元素类型为String，长度为10的数组
            Object arr= Array.newInstance(String.class,10);
            //依次为arr数组中index为5 6的元素赋值
            Array.set(arr,5,"java讲义");
            Array.set(arr,6,"javaEE讲义");
            //依次取出arr数组中index为5 6的元素的值
            Object book1=Array.get(arr,5);
            Object book2=Array.get(arr,6);
            //输出arr数组中index为5 6的元素
            System.out.println(book1);
            System.out.println(book2);
        }catch (Throwable e){
            System.out.println(e);
        }
    }
}

​ 通过Array创建数组，为数组元素设置值，访问数组元素的值，通过使用Array就可以动态的创建并操作数组

使用反射生成JDK动态处理

​ java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口可以生成JDK动态代理类或动态代理对象。

使用Proxy和InvocationHandler创建动态代理

​ Proxy提供了用于创建动态代理和代理对象的静态方法，他是所有动态代理类的父类。

​ Proxy提供了如下两个方法来创建动态代理和动态代理实例：

在这里插入图片描述

系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。

interface Person2{
    void walk();
    void sayHello(String name);
}

class MyInvocationHandler implements InvocationHandler {

    /**
     *执行动态代理对象的所有方法时，都会替换成执行如下的invoke方法
     * @param proxy 代表动态代理对象
     * @param method   代表正在执行的方法
     * @param args 代表调用目标方法时传入的实参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("-------正在执行的方法："+method);
        if (args!=null){
            System.out.println("下面的执行该方法时传入的实参为：");
            for (Object val : args) {
                System.out.println(val);
            }
        }else{
            System.out.println("调用该方法没有实参");
        }
        return null;
    }
}
public class ProxyTest{
    public static void main(String[] args) throws InterruptedException {
        //创建一个InvocationHandler对象
        InvocationHandler handler=new MyInvocationHandler();
        //使用指定的InvocationHandler来生成一个动态代理对象
        Person2 p2= (Person2) Proxy.newProxyInstance(Person2.class.getClassLoader(),new Class[]{Person2.class},handler);
        //调用动态代理对象的walk()和sayHell()方法
        p2.walk();
        p2.sayHello("孙悟空");
    }
}

实际上，在普通编程中，确实无须使用动态代理，但是在编写框架或底层基础代码时，动态代理的作用就很大

动态代理和AOP

​ 由于JDK动态代理只能为接口创建动态代理。所以如下我们定义一个接口

public interface Dog {
    //info()方法声明
    void info();
    //run()方法声明
    void run();
}

​ 上面如果直接使用Proxy为该接口创建动态处理，则动态处理对象的所有方法的执行效果将完全一样。要想实现多态，需要为Dog提供一个或多个实现类。

public class GunDog implements Dog {
    @Override
    public void info() {
        System.out.println("我只是一只狗");
    }

    @Override
    public void run() {
        System.out.println("我奔跑迅速");
    }
}

​ 程序执行info() ,run()方法时能调用某个通用方法，但又不想以硬编码方法调用该方法，下面提供一个DogUtil类，该类包含两个通用方法

public class DogUilt {
    //第一个拦截器方法
    public void method1(){
        System.out.println("=======模拟第一个通用方法=======");
    }
    //第二个拦截器方法
    public void method2(){
        System.out.println("=======模拟第二个通用方法=======");
    }
}

​ 借助于proxy和InvocationHandler就可以实现----当程序调用info()方法和run()方法时，系统就可以自动将method1()和method2()两个通用方法插入info和run方法中执行
​ 次程序的关键在于下面的类，该类是一个InvocationHandler实现类，该实现类的invoke()方法将会作为代理对象的方法实现。

public class MyInvocationHandler2 implements InvocationHandler {
    //需要被代理的对象
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }
    //执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        DogUilt du=new DogUilt();
        //执行DogUilt对象中的method1方法
        du.method1();
        //以target作为主调来执行method方法
        Object result=method.invoke(target,args);
        //执行DogUilt对象中的method2方法
        du.method2();
        return result;
    }
}

​ 上面程序实现了invoke方法包含了一行关键代码，这行代码通过反射以target作为主调来执行method方法，这就是回调了target对象的原有方法。
​ 提供一个MyProxyFactory类，该对象专门指定了target生成动态代理实例


public class MyProxyFactory {
    //为指定的traget生成动态代理对象
    public static Object getProxy(Object target){
        //创建一个MyInvocationHandler2对象
        MyInvocationHandler2 handler2 =new MyInvocationHandler2();
        //为MyInvocationHandler2设置target对象
        handler2.setTarget(target);
        //创建并返回一个动态代理
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),handler2);
    }
}

​ 上面的动态代理工厂类提供了一个getProxy方法，该方法为targetd对象生成了一个动态代理对象，这个动态代理对象与target实现了相同的接口，所以具备了相同的public方法–从不同意义上看，动态代理对象可以当成target对象使用。当程序调用动态代理对象的指定方法时，实际上变为执行MyInvocationHandler2对象的invoke方法。

public class Test {
    public static void main(String[] args) {
        //创建一个原始的GunDog对象，作为target
        Dog target=new GunDog();
        //以指定target来创建动态代理对象
        Dog dog= (Dog) MyProxyFactory.getProxy(target);
        dog.run();
        dog.info();
    }
}

​ 通常而言，使用Proxy生成一个动态代理时，往往不会凭空产生一个动态代理，这样做没有意义，通常都是为指定的目标对象生成d动态代理

​ 这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法，但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前，之后插入一些通用处理

在这里插入图片描述

反射和泛型

​ 从JDK5之后，java类增加了泛型功能，从而允许使用泛型来限制Class类。通过在反射中使用泛型，可以避免使用反射生成的对象需要强制类型转换。

泛型和Class类

​ 使用Class<?>泛型可以避免强制类型转换。

//提供一个简单的对象工厂，该对象工厂可以根据指定类来提供类的实例
public class CrazyitObjectFactory {
    public static Object getInstance(String clsName){
        try{
            //创建指定类对应的Class对象
            Class cls=Class.forName(clsName);
            //返回使用该Class对象创建的实例
            return cls.newInstance();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }
}

上面程序根据字符串类型创建一个新对象，但这个对象的类型是Object，因此需要强制类型转换。

如果将上面工厂类改写成泛型之后的Class，就可以避免。

public class CrazyitObjectFactory2 {
    public static <T> T getInstance(Class<T> cls){
        try{
            return cls.newInstance();
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        //获取实例后无须类型转换
        Date d=CrazyitObjectFactory2.getInstance(Date.class);
        JFrame f=CrazyitObjectFactory2.getInstance(JFrame.class);
    }
}

​ 上面程序getInstance方法中传入一个Class参数，这是一个泛型化的Class对象，调用该Class对象的newInstance方法将会返回一个T类型的对象。接下来使用CrazyitObjectFactory2工厂类的getInstance方法来产生对象时，无须强制类型转换。

​ 对Array的newInstance()方法进行包装

public class CrazyitArray {
    //对Array的newInstance方法进行包装
    @SuppressWarnings("unchecked")
    public static <T> T[] newInstance(Class<T> componentType,int length){
        return (T[]) Array.newInstance(componentType,length);
    }

    public static void main(String[] args) {
        //使用CrazyitArray的newInstance()创建一维数组
        String[] arr=CrazyitArray.newInstance(String.class,10);
        //使用CrazyitArray 的newInstance创建二维数组
        //在这种情况下，只需要设置数组元素的类型是int[]即可
        int [] [] intArr=CrazyitArray.newInstance(int[].class,5);
        arr[5]="疯狂java";
        //intArr是二维数组，初始化该数组的第二个数组元素
        //二维数组的元素必须是一维数组
        intArr[1]=new int[]{2,3};
        System.out.println(arr[5]);
        System.out.println(intArr[1][1]);
    }
}

使用反射来获取泛型信息

​ 通过指定类对应的Class对象，可以获取该类里包含的所有成员变量，不管该类成员变量是使用private修饰，还是public修饰。

​ 为了获取指定成员变量的泛型类型，应该使用如下方法来获取成员变量泛型类型

//获取成员变量f的泛型类型
Type f=f.getGenricType();

​ 然后将Type对象强制类型转换成ParameterizedType对象，ParameterizedType代表被参数化的类型，也就是增加了泛型限制的类型。

​ ParameterizedType类提供了两个方法：

在这里插入图片描述

public class GenericTest {
    private Map<String,Integer> score;

    public static void main(String[] args) throws Exception {
        Class<GenericTest> clazz=GenericTest.class;
        Field f=clazz.getDeclaredField("score");
        //直接使用getType()取出类型只对普通的成员变量有效
        Class<?> a=f.getType();
        //下面将看到输出java.util.Map
        System.out.println("socre的类型是："+a);
        //获取成员变量f的泛型类型
        Type gType=f.getGenericType();
        //如果gType类型的是ParameterizedType
        if (gType instanceof ParameterizedType){
            //强制类型转换
            ParameterizedType pType= (ParameterizedType) gType;
            //获取原始类型
            Type rType=pType.getRawType();
            System.out.println("原始类型："+rType);
            //获取泛型类型的泛型参数
            Type[] tArgs=pType.getActualTypeArguments();
            System.out.println("泛型信息是：");
            for (int i = 0; i < tArgs.length; i++) {
                System.out.println("第"+i+"个泛型类型是："+tArgs[i]);
            }
        }else {
            System.out.println("获取泛型类型出错");
        }
    }
}

​ 使用getType()方法只能获取普通类型成员变量的数据类型；对于增加了反省类型的成员变量，应该使用getGenericType()方法来取得其类型。

A丶Y
关注
专栏目录
疯狂java讲义18 电子版 pdf
04-08
疯狂java讲义 电子版 pdf 疯狂java讲义 电子版 pdf
java 18
m0_55680205的博客
05-14 153
一.学习内容 1.异常处理 2.练习书上代码 3.代码如下： （1） package Demo2; //定义异常类 public class InputException extends Exception { InputException(String str){ super(str); } } package Demo2; import java.io.*; //7-10代码 public class InputExceptionDemo { static void InputNum(Str
Java新特性梳理——Java18
最新发布
weixin_45254062的博客
07-20 352
highlight: xcode theme: vuepress 概述 Java 18 在 2022 年 3 月 22 日正式发布，Java 18 不是一个长期支持版本，这次更新共带来 9 个新功能。 默认的UTF-8字符编码 JDK 一直都是支持 UTF-8 字符编码，这次是把 UTF-8 设置为了默认编码，也就是在不加任何指定的情况下，默认所有需要用到编码的 JDK API 都使...
类加载机制与反射
weixin_30701575的博客
05-16 66
一. 类的加载，连接，初始化 1.1. JVM和类 当调用Java命令运行某个Java程序时，该命令将会启动一个Java虚拟机进程。不管Java程序多么复杂，启动多少个线程，它们都处于该Java虚拟机进程里，都是使用同一个Java进程内存区。 JVM程序终止的方式： 程序运行到最后正常结束 程序运行到使用System.exit()或Runtime.getRuntime().exi...
Java--18
qq_55689272的博客
05-23 182
目录ArrayList类编译期异常和运行期异常 ArrayList类 它是一个引用 对象数组 package day18.demo01; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class demo01Iterator { public static void main(String[] args) { Collection<String> co
疯狂Java语言编程 程序源代码 全部源码 共18个章节.rar
06-02
01.Java语言概述 02.理解结构化程序设计_理解面向对象 03.数据类型和运算符 04.流程控制和数组 05.面向对象(上) 06.面向对象(下) 07.与运行环境交互 08.Java集合 09.泛型 10.异常处理 ...18.类加载与反射
疯狂JAVA讲义
10-17
1.6.3 初学者容易犯的错误 18 1.7 垃圾回收机制 20 1.8 何时开始使用IDE工具 21 学生提问：老师，我想学习Java编程，到底是学习Eclipse好呢，还是学习JBuilder好呢？ 21 1.9 本章小结 22 本章练习 22 第2章 ...
推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 全套PPT课件资源集合 共18个章节.rar
12-19
【完整课程列表】 推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 01.Java语言概述（共21页）.ppt ...推荐优质Java课程 疯狂Java语言编程 Java入门到进阶教程 18.类加载与反射（共25页）.ppt
疯狂java光盘内容
12-29
(1) 01～18文件夹名对应于《疯狂Java讲义》中的章名， 即第3章所使用的代码放在codes文件夹的03件夹下，依此类推。 (2) 本书所有代码都是IDE工具无关的程序，读者既可以在命令行窗口直接编译、 运行这些代码，...
Java 18 正式发布
码农小胖哥
03-22 9473
Java 18 正式发布，一共有九个JEP
java18_java18
weixin_28781243的博客
02-12 2261
所有对象和数组都是在堆里创建的1.数组在堆中的存储方式。int[ ] ages = new int[ ]{10,20,30};//声明数组ages //在堆中开辟了一块空间并将数组初始化//同时将新开辟空间的内存地址赋值给了ages)System.out.println(ages);【[I@15db9742】//输出内存地址java的jvm中有自动清除垃圾...
Java 18发布了
极道Jdon的技术博客
03-23 405
JDK 18作为Java 18 的参考实现GA版本发布，可用于生产： https://jdk.java.net/18此版本包括九个 JEP改进：   400：默认字符集改为 UTF-8   408：一个简单的Web服务器   413：可在Java API 文档中嵌入代码片段   416：使用方法句柄重新实现核心反射   417：Vector API（第三个孵化器版本）   4...
Java18天
zkzkzkzkzkzkzk的博客
04-07 771
缓冲流 缓冲流,也叫高效流，是对4个基本的FileXxx 流的增强，所以也是4个流，按照数据类型分类： 字节缓冲流：BufferedInputStream，BufferedOutputStream 字符缓冲流：BufferedReader，BufferedWriter 缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，...
Java18
m0_52900812的博客
05-11 413
一，Collection常用功能
java18
chizhuan6861的博客
03-01 81
1:Map(掌握) (1)将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。 (2)Map和Collection的区别? A:Map 存储的是键值对形式的元素，键唯一，值可以重复。夫妻对 B:Collection 存储的是单独出现的元素，子接口Set元素唯一，子接口L...
2021-05-11
m0_55689512的博客
05-11 122
Java学习 day18 目录 集合 Iterator 迭代器 异常的处理 1、集合 Collection: 单列集合类的根接口，用于存储-系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序、元素可重复。Set 的特点是元素无序，而且不可重复。List接口的主要实现类有java. util.HashSet和java.util.TreeSet。 集合本身是一个工具，它存放在java.util包中。 在collect
黑马程序员——JAVA基础----IO流（一）
Du_jing的博客
11-05 654
-----------android培训、java培训、java学习型技术博客、期待与您交流！------------ IO流（一） 01_IO流(IO流概述及其分类) 1.概念 IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的类都在IO包中 流按流向分为两种：输入流，输出流。 流按操作类型分为两种： 字节
java18_JAVA.18
weixin_34574003的博客
02-22 430
package abc;import java.util.ArrayList;public class test {public static void main(String[] args) {// TODO Auto-generated method stubArrayList list = new ArrayList();list.add("欧欧 Q仔");list.add("亚...
疯狂Java教程：流程控制与数组详解
"疯狂Java语言编程是一套全面的Java入门到进阶教程，由疯狂软件提供，旨在帮助学习者系统地掌握Java编程技能。这套教程共包含18个章节，从基础的Java语言概述开始，逐步深入到高级主题，如面向对象编程、数据结构、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值