类加载机制与反射

时间  2019-11-18
标签 加载 机制 反射 繁體版
原文   原文链接

一. 类的加载，链接，初始化

  1.1. JVM和类

当调用Java命令运行某个Java程序时，该命令将会启动一个Java虚拟机进程。无论Java程序多么复杂，启动多少个线程，它们都处于该Java虚拟机进程里，都是使用同一个Java进程内存区。java

JVM程序终止的方式：mysql

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

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

  1.2 类的加载

当程序主动使用某个类时，若是该类还未被加载到内存中，则系统会经过加载、链接、初始化三个步骤来对该类进行初始化。数据库

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

系统中全部的类实际上也是实例，它们都是java.lang.Class的实例api

类的加载经过JVM提供的类加载器完成，类加载器时程序运行的基础，JVM提供的类加载器被称为系统类加载器。除此以外，开发者能够经过继承ClassLoader基类来建立本身的类加载器。数组

经过使用不一样的类加载器，能够从不一样来源加载类的二进制数据，一般有以下几种来源。缓存

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

类加载器一般无需等到首次使用该类时才加载该类，Java虚拟机规范容许系统预先加载某些类。安全

  1.3 类的链接网络

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

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

  1.4 类的初始化

再累温馨化阶段，虚拟机负责对类进行初始化，主要就是对类变量进行初始化。在Java类中对类变量指定初始值有两种方式：①声明类变量时指定初始值；②使用静态初始化块为类变量指定初始值。

JVM初始化一个类包含以下步骤

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

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

  1.5 类初始化时机

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

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

二. 类加载器

  2.1类加载器介绍

　　类加载器负责将.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的静态方法或区该系统类加载器。若是没有特别指定，则用户自定义的类加载器都已类加载器做为父加载器

  2.2 类加载机制

JVM类加载机制主要有三种

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

类加载器加载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对象

其中，第五、6步容许重写ClassLoader的findClass()方法来实现本身的载入策略，甚至重写loadClass()方法来实现本身的载入过程。

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

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

  • loadClass(String name,boolean resolve)：该方法为ClassLoader的入口点，根据指定名称来加载类，系统就是调用ClassLoader的该方法来获取指定类的class对象
  • findClass(String name):根据指定名称来查找类

若是须要是实现自定义的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源文件。

 

package com.gdut.basic;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

public class CompileClassLoader extends ClassLoader {
private byte[] getBytes(String fileName) {
    File file = new File(fileName);
    Long len = file.length();
    byte[] raw = new byte[(int)len];
    
        FileInputStream fin = new FileInputStream(file);
        //一次读取class文件的二进制数据
        int r = fin.read(raw);
        if(r != len) {
            throw new IOException("没法读取文件"+r+"!="+raw);
        
    
    return null;
        }
}
    private boolean compile(String javaFile) throws IOException {
        System.out.println("正在编译"+javaFile+"...");
        Process p = Runtime.getRuntime().exec("javac"+javaFile);
        try {
            //其余线程都等待这线程完成
            p.waitFor();
        }catch(InterruptedException ie) {
            System.out.println(ie);
        }
        int ret = p.exitValue();
        return ret == 0;
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class clazz = null;
        String findStub = name.replace(".", "/");
        String javaFileName = findStub+".java";
        String classFileName = findStub+".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 {
            if(!compile(javaFileName)|| !classFile.exists()) {
                throw new ClassNotFoundException("ClassNotFoundExcetion"+javaFileName);
            }
            }catch(IOException ie) {
                ie.printStackTrace();
            }
        }
        if(classFile.exists()) {
            
                byte[] raw = getBytes(classFileName);
                
                clazz = defineClass(name,raw,0,raw.length);
        }
        //若是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);
        
    }
}

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

package com.gdut.basic;

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. 根据应用需求把其余数据以字节码的形式加载到应用中。

    2.4 URLClassLoader类

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

该类提供两个构造器

  • URLClassLoader(URL[] urls)：使用默认的父类加载器建立一个ClassLoader对象，该对象将从urls所指定的路径来查询并加载类
  • URLClassLoader(URL[] urls,ClassLoader prarent)：使用指定的父类加载器建立一个ClassLoader对象，该对象将从urls所指定的路径来查询并加载类。

下面程序示范了如何从文件系统中加载MySQL驱动，并使用该驱动获取数据库链接。经过这种方式来获取数据库链接，无需将MySQL驱动添加到CLASSPATH中。

package java.gdut;

import java.net.URL;
import java.net.URLClassLoader;
import java.sql.Connection;
import java.sql.Driver;
import java.util.Properties;

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()运算符进行判断，再利用强制类型转换将其转换成运行时类型的变量便可
  • 第二种作法是编译时根本没法知道该对象和类可能属于那些类，程序只依靠运行时信息来发现该对象和类的真实信息，这就必须使用反射

  3.1 得到class对象

每一个类被加载后，系统会为该类生成一个对应的Class对象，经过该Class对象能够访问到JVM中的这个类。得到Class对象一般三种方式

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

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

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

  3.2 从Class中获取信息

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

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

  • ConStructor<T> getConStructor(Class<?> parameterTypes)：返回Class对象对应类的，带指定参数列表的public构造器
  • ConStructor<?>[] getConStructor()：返回此Class对象对应类的全部public构造器
  • ConStructor<T> 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 extends Annotation>A getAnnotation(Class<A> annotationClass):尝试获取该Class对象对应类存在的，指定类型的Annotation；若是该类型的注解不存在，则返回null。
  • <A extends Annotation>A getDeclaredAnnotation(Class<A> annotationClass):Java 8新增方法，尝试获取直接修饰该Class对象对应类存在的，指定类型的Annotation；若是该类型的注解不存在，则返回null。
  • Annotation[] getAnnotations()：获取该Class对象对应类存在的全部Annotation
  • Annotation[] getDiclaredAnnotations()：获取直接修饰该Class对象对应类存在的全部Annotation
  • <A extends Annotation>A[] getAnnotationByType(Class<A> annotationClass):因为Java 8的新增了重复注解功能，所以须要使用该方法获取修饰该Class对象对应类，指定类型的多个Annotation
  • <A extends Annotation>A[] getDeclaredAnnotationByType(Class<A> 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)

  3.3 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的参数反射功能

public class MethodParameterTest {
    public static void main(String[] args) throws Exception {
        Class<Test> clazz = Test.class;
        Method replace = clazz.getMethod("replace",String.class,List.class);
        System.out.println("replace方法的参数个数为："+replace.getParameterCount());

        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());
            }
        }
    }
}

  3.4 利用反射生成并操做对象

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

3.4.1 建立对象

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

  • 使用Class对象的newInstance()方法来建立该Class对象对应类的实例，这种方式要求该Class对象的对应类有默认构造器。
  • 先使用Class对象获取指定的Constructor对象，在调用Constructor对象的newInstance()方法来建立该Class对象对应类的实例。

3.4.2 调用方法

能够经过Class对象的getMethods()方法和getMethod()方法来获取所有方法和指定方法。

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

  • Object invoke(Object obj,Object... args)：该方法中的obj是执行该方法的主调，后面的args是执行该方法时传入该方法的实参。

下面程序是对象池工厂增强版，它容许在配置文件中增长配置对象的成员变量的值，对象池工厂会读取为该对象配置的成员变量值，并利用该对象的Setter方法设置成员变量的值。

package com.gdut.test0516;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ExtendedObjectPoolFactory {
    //定义一个对象池，前面是对象名，后面是实际对象
    private Map<String,Object> objectPool = new HashMap<>();
    private Properties config = new Properties();

    public void init(String fileName)
    {
        try(FileInputStream fis = new FileInputStream(fileName))
        {
            config.load(fis);
        }catch(IOException ex){
            System.out.println("读取"+fileName+"异常");
        }
    }

   private Object createObject(String clazzName)throws ClassNotFoundException,
           InstantiationException,IllegalAccessException{
        Class<?> clazz = Class.forName(clazzName);
        //使用clazz默认构造器建立实例
        return clazz.newInstance();
   }


   public void initPool()throws ClassNotFoundException,
           InstantiationException,IllegalAccessException{
       for (String name:config.stringPropertyNames())
       {
           //没取出一个key-value对。若是key中不包含百分号（%），便可认为该key用于
           // 控制调用对象的setter方法设置值，%前半为对象名字，后半控制setter方法名
       if( !name.contains("%")){
           objectPool.put(name,createObject(config.getProperty(name)));
       }
       }
   }
   public Object getObject(String name){
        return objectPool.get(name);
   }

   public void initProperty()throws NoSuchMethodException,
   IllegalAccessException,InvocationTargetException {
       for (String name:config.stringPropertyNames()) {
           if(name.contains("%")){
               String[] objAndProp = name.split("%");
               Object target = getObject(objAndProp[0]);
               String mtdName = "set"+objAndProp[1].substring(1);
               Class<?> targetClass = target.getClass();
               Method mtd = targetClass.getMethod(mtdName);
               mtd.invoke(target,config.getProperty(name));
           }
       }
   }

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

  3.4.3 访问成员变量

经过Class对象的getFields()方法和getField()方法能够获取该类包含的全部成员变量和指定成员变量。Field提供以下方法读取或设置成员变量值

  • getXxx(Object obj)：获取Object对象的成员变量值。此处的Xxx对应8种基本类型，若是该成员变量类型时引用类型，则取消get后面的Xxx。
  • setXxx(Object obj,Xxx val)：将obj对象的该成员变量设置成val值。此处的Xxx对应8种基本类型，若是该成员变量类型时引用类型，则取消set后面的Xxx。

3.4.4 操做数组

在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)。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程