0033 Java学习笔记-反射-初步1

图片 1

反射能够减轻在编写翻译时敬谢不敏预感对象和类是归于非常类的,要依附程序运营时的信息本领掌握该指标和类的音讯的难点。

一. 类的加载,连接,开始化

先看看通过反射能干嘛

  • 身体力行:订正对象的private实例变量

    package testpack;
    import java.lang.reflect.Field;
    public class Test1 {

    public static void main(String[] args)throws Exception{ 
        Person per=new Person("Java",21);
        System.out.println("现在的per对象是:"+per);   //[name= Java , age= 21 ]
    
        Class<Person> perClazz=Person.class;           //获取Person类的Class对象
    
        Field fName=perClazz.getDeclaredField("name"); //获取Person类的名为“name”的变量,即使是private修饰
        fName.setAccessible(true);                     //取消该变量的访问权限检查
        fName.set(per, "C++");                         //将per对象的name变量改为“C++”
    
        Field fAge=perClazz.getDeclaredField("age");
        fAge.setAccessible(true);
        fAge.set(per, 33);                             //将per对象的age变量改为“33”
    
        System.out.println("private的实例变量被修改了,还是那个per对象:"+per); //[name= C++ , age= 33 ]
    }
    

    }
    class Person{

    private int age;
    private String name;
    public Person(String n,int a){
        name=n;
        age=a;
    }
    public String toString(){
        return "[name= "+name+" , age= "+age+" ]";
    }
    

    }

  • 地点的演示中,就算age和name被private修饰,但照旧被修正了,这那岂不是特别不安全,违背了打包的初志?作者也不知底

在三人搭档开辟时,你一旦精通对方的类名就足以拓张开头的支出了。

  1.1. JVM和类

当调用Java命令运营有些Java程序时,该命令将会运行叁个Java设想机进度。不管Java程序多么烦琐,运行多少个线程,它们都地处该Java设想机进度里,都以采取同一个Java进度内部存储器区。

JVM程序终止的艺术:

  • 程序运转到最终平常甘休
  • 程序运营到利用System.exit(State of Qatar或Runtime.getRuntime(State of Qatar.exit(State of Qatar代码处停止程序
  • 程序推行进程中相遇未捕获的至极或错误而结束
  • 次第所在阳台强迫甘休了JVM进度

JVM进度结束,该进程四方内部存款和储蓄器中的状态将会放弃

java.lang.class

  • 有二个类很极度,它是全数类的类,它正是java.lang.class
  • 要采取二个类的时候,类加载器找到并加载这么些类,同期再次回到其Class对象;也等于说只要叁个类被加载了,那么就势必存在它的Class对象
  • 哪些获得二个类的Class对象?以String类为例
    • Class.forName(“java.lang.String”卡塔尔国:用Class类的静态方法forName(“包名+类名”卡塔尔(قطر‎来获得
    • String.class:通过调用二个类的class属性来获取
      • 相同用这种艺术
      • 代码更安全。程序在编写翻译阶段就足以检查要访问的Class对象是否存在。?不懂
      • 次第质量越来越好。因为不用调用方法。
    • String的实例.getClass(State of Qatar:通过Object类的叁个实例方法getClass(卡塔尔方法得到
  • 收获叁个类的Class对象后,就能够调用其方法得到该指标和该类的真人真事音讯了

获取类对象

  • Class.forName(String clazzName卡塔尔(قطر‎静态方法
  • 调用类的class属性,Person.class再次来到的正是Person的class对象(推荐应用)
  • 调用某些对象的getClass(State of Qatar方法

现实应用依然要依照实际来抉择,第一种艺术是相当轻松的,只要驾驭二个类名就足以了,其不会做此类是或不是存在的校验,第三种、第三种则会做校验

  1.2 类的加载

当程序积极采用有些类时,借使此类还没被加载到内部存款和储蓄器中,则系统会经过加载、连接、初阶化多个步骤来对此类实行早先化。

类的加载时将此类的class文件读入内部存储器,并为之创设一个java.lang.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设想机标准允许系统预先加载有些类。

  1.3 类的一而再

当类被加载后,系统会为之生成一个对应的Class对象,接着会进去连接阶段,连接阶段负担把类的二进制数据统一到JRE中。类的链接可分为如下多少个阶段。

  1. 表达:验证阶段用于核查被加载的类是还是不是有不易的内部构造,并和任何类和谐一致
  2. 预备:类酌量阶段则负责为类的类变量分配内部存款和储蓄器,并安装私下认可开始值
  3. 释疑:将类的二进制数据中的变量实行标志引用替换来直接援用

  1.4 类的起头化

再累舒畅化阶段,虚构机担任对类举办最初化,首要正是对类变量实行起头化。在Java类中对类变量钦定起先值有三种艺术:①证明类变量时钦赐初叶值;②行使静态发轫化块为类变量内定发轫值。

JVM初始化一个类蕴含如下步骤

  1. 加载并三番五次该类
  2. 先开首化其一贯父类
  3. 各种实践起首化语句

当施行第2步时,系统对间接父类的初叶化也依照1~3,就那样类推

Class首要措施

  • 布局器:以下用“para”代表Class<?>…parameterTypes,那是个数可变的形参列表
    • Constructor
      getConstructor(para卡塔尔国:再次来到该Class对象对应类的、带钦定形参的public布局器
    • Constructor<?>[]
      getConstructors(卡塔尔(قطر‎:再次来到对应类的有着public布局器
    • Constructor
      getDeclaredConstructor(para卡塔尔:再次来到对应类的、带内定形参列表的布局器,无论是怎么访谈权限
    • Constructor<?>[]
      getDeclaredConstructors(卡塔尔国:再次来到对应类的享有布局器,无论访谈权限
  • 方法:
    • Method getMethod(String
      name,para卡塔尔:再次来到对应类的、钦点方法名、钦点形参列表的public方法
    • Method[] getMethods(卡塔尔国:重临钦赐类的具有public方法
    • Method getDeclaredMethod(String
      name,para卡塔尔国:再次回到对应类的、钦赐方法名、钦定形参列表的法子,无论访谈权限
    • Method[]
      getDeclaredMethods(State of Qatar:重回对应类的有所办法,无论访谈权限
  • 分子变量
    • Field getField(String
      name卡塔尔国:重返对应类的、钦命名称的public成员变量
    • Filed[] getFields(卡塔尔国:重临对应类的富有public成员变量
    • Field getDeclaredField(String
      name卡塔尔国:重回对应类的、钦赐名称的成员变量,无论访问权限
    • Field[]
      getDeclaredFields(State of Qatar:再次来到对应类的保有成员变量,无论访谈权限
  • 注解
    • <A extends Annotation> A
      getAnnotation(Class<A>AnnotationClass卡塔尔(قطر‎:获取对应类的内定的注明,不设有则赶回null
    • <A extends Annotation> A
      getDeclaredAnnotation(Class<A>AnnotationClass):获取直接修饰该对应类的、钦赐的注解,子虚乌有则赶回null
    • Annotation[] getAnnotations(State of Qatar:重临对应类上的保有证明
    • Annotation[]
      getDeclaredAnnotations():返回直接修饰该对应类的享有表明
    • <A extends Annotation> A[]
      getAnnotationsByType(Class<A>AnnotationClass):针对重复注解效益,重临修饰该对应类的、钦定项指标四个注明
    • <A extends Annotation> A[]
      getDeclaredAnnotationsByType(Class<A>AnnotationClass):针对重复注解功能,获取直接修饰对应类的、钦定项目标注明
  • 内部类
    • Class<?>[]
      getDeclaredClasses(State of Qatar:再次来到对应类里含有全体内部类
  • 外部类:
    • Class<?> getDeclaringClass(卡塔尔国:再次来到对应类的四方的外部类
  • 接口:
    • Class<?> getInterfaces(卡塔尔(قطر‎:重返对应类所达成的有着接口
  • 父类:
    • Class<?super T>
      getSuperclass(卡塔尔国:重回对应来的父类的Class对象
  • 修饰符:
    • int
      getModifiers(State of Qatar:重返对应类或接口的享有修饰符对应的常量,应利用Modifier工具类的措施解码,技巧取得真正的修饰符
  • 所在包:
    • Package getPackage(State of Qatar:获取对应类所在的包
  • 类名:
    • String getName(卡塔尔(قطر‎:重临对应类的名称,全局限制名(即满含包名卡塔尔(قطر‎
    • String getSimpleName(卡塔尔(قطر‎:重临对应类的称呼,不包罗包名的类名
  • is方法
    • boolean isAnnotation:是还是不是评释类型
    • boolean isAnnotationPresent(Class<? extends Annotation>
      annotationClassState of Qatar:对应类是还是不是接纳了Annotation修饰
    • boolean isAnonymousClass(卡塔尔国:对应类是不是是一个佚名类
    • boolean isArray(卡塔尔(قطر‎:对应类是或不是是八个数组
    • boolean isEnum(卡塔尔国:对应类是不是是三个枚举
    • boolean isInterface(State of Qatar:对应类是或不是是一个接口
    • boolean isInstance(Object
      obj卡塔尔(قطر‎:决断该obj是还是不是对应类的实例,可以完全代表instanceof
  • 连锁方法现身说法:以Strin类为例

    package testpack;

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

    public class Test1 {

    public static void main(String[] args)throws Exception{ 
        Class clazz=String.class;
    
        System.out.println("---------------------------------下面是String的成员变量部分---------------------------------");
        System.out.println("-----------所有的public成员变量-----------");
        Field[] pfs=clazz.getFields();
        for (Field f:pfs) {
            System.out.println(f);
        }
        System.out.println("-----------所有成员变量-----------");
        Field[] fs=clazz.getDeclaredFields();
        for (Field f:fs) {
            System.out.println(f);
        }
    
        System.out.println("---------------------------------下面是String的构造器部分---------------------------------");
        System.out.println("String的无参构造:"+clazz.getConstructor(null));
        System.out.println("String以byte[]为参数的构造器:"+clazz.getConstructor(byte[].class));
        System.out.println("String以StringBuffer为参数的构造器:"+clazz.getConstructor(StringBuffer.class));
        System.out.println("---------------所有构造器-----------------");
        Constructor[] cs=clazz.getDeclaredConstructors();
        for(Constructor c:cs){
            System.out.println(c);
        }
    
        System.out.println("---------------------------------下面是String的方法部分---------------------------------");
        System.out.println("String的名为intern的无参方法:"+clazz.getMethod("intern",null));
        System.out.println("String的名为valueOf的参数为int的方法:"+clazz.getMethod("valueOf",int.class));
        System.out.println("--------------所有方法--------------------");
        Method[] ms=clazz.getDeclaredMethods();
        for (Method m:ms) {
            System.out.println(m);
        }
        System.out.println();
    
        System.out.println("---------------------------------下面是String的注解部分---------------------------------");
        System.out.println("---------下面是String的所有注解---------------");
        Annotation[] as=clazz.getAnnotations();
        for (Annotation a:as) {
            System.out.println(a);                      //没有输出:因为String类没有注解(但String类内部的一些元素有注解)
        }
        System.out.println("---------------------------------下面是String的所有内部类---------------------------------");
        Class[] css=clazz.getDeclaredClasses();
        for (Class c:css) {
            System.out.println(c);
        }
        System.out.println("---------------------------------下面是String实现的所有接口---------------------------------");
        Class[] is=clazz.getInterfaces();
        for (Class i:is) {
            System.out.println(i);
        }
        System.out.println("---------------------------------其他---------------------------------");
        System.out.println("String的直接父类:"+clazz.getSuperclass());
        System.out.println("String的修饰符:"+clazz.getModifiers());
        System.out.println("String所在的包:"+clazz.getPackage());
        System.out.println("String的全局限定名:"+clazz.getName());
        System.out.println("String的类名:"+clazz.getSimpleName());
    }
    

    }

获得类的新闻

  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扩充目录中的JAPRADO包的类,它的父类加载器是跟类加载器

System
ClassLoader,它担当在JVM运转时加载来自Java命令的-classpath选项、java.class,path系统品质,或CLASSPATH钦定的jar包和类历经。系统可通过ClassLoader的静态方法或区该种类类加载器。若无极其钦命,则客户自定义的类加载器皆是类加载器作为父加载器

至于参数的反射:since1.8

  • 布局方法和情势中带有形参列表,Java1.8增添了Parameter类来陈说参数
  • 地方Class对象关于布局器和艺术的重临值分别是:Constructor和Method,那四个类是Executable类的子类
  • Executable的机要情势有:
    • boolean isVarArgs(卡塔尔:是还是不是带有可变多少的形参
    • int getModifiers(卡塔尔:获取修饰符
    • int getParameterCount(State of Qatar:获取形参数量
    • Parameter[] getParameters(卡塔尔:获取具有形参
  • Parameter的重要情势
    • int getModifiers(卡塔尔(قطر‎:获取形参的修饰符
    • String getName(State of Qatar:获取形参名
    • Type getParameterizedType(卡塔尔(قطر‎:获取带泛型的形参类型
    • Class<?> getType(卡塔尔:获取形参类型
    • boolean
      isNamePresent(卡塔尔国:所在类的class文件中是不是包蕴了形参名音讯;

      • 日常情状下,编写翻译的时候都不分包形参名,除非加上“-parameters”选项
    • boolean isVarArgs(卡塔尔(قطر‎:该参数是还是不是为个数可变的形参
  • 见示例:

    package testpack;

    import java.lang.reflect.Constructor;
    import java.lang.reflect.Parameter;

    public class Test1 {

    public static void main(String[] args)throws Exception{ 
        Class clazz=String.class;
        Constructor c=clazz.getConstructor(byte[].class,int.class,int.class);
        System.out.println("该构造器的形参个数:"+c.getParameterCount());
        Parameter[] ps=c.getParameters();
        for (Parameter p:ps) {
            System.out.println("该参数是:"+p);
            System.out.println("该参数的修饰符:"+p.getModifiers());
            System.out.println("该参数的形参名:"+p.getName());
            System.out.println("形参类型:"+p.getType());
            System.out.println("是否有形参名信息:"+p.isNamePresent());
            System.out.println("是否是个数可变的形参:"+p.isVarArgs());
            System.out.println("--------------------------");
        }
    }
    

    }

取得类构造器

  • Connstructor<T> getConstructor(Class<?>...parameterTypes):再次回到此Class对象对应类的带内定形参的public布局器
  • Constructor<?>[] getConstructors():重临此Class对象对应类的持有public构造器
  • Constructor<T>[] getDeclaredConstructor(Class<?>...parameterTypes):重临此class对象对应类的带钦点参数的布局器,与布局器的会见权限毫无干系
  • Constructor<?>[] getDeclaredConstructors():重返此class对象对应类的全数结构器,与布局器的拜访权限非亲非故

  2.2 类加运载飞机制

JVM类加运载飞机制至关心尊崇要有三种

  • 一同负担。正是当类加载器担任加载某些Class时,该Class所依附的和所援用的其余Class也将由此类加载器肩负载入,除非显式使用其它叁个类加载器来载入
  • 父类委托。所谓父类委托,便是先让父类加载器试图加载该Class。唯有在父类加载器不只怕加载该类时才尝试从自个儿的类路线中加载该类
  • 缓存机制。缓存机制将会确认保障具备加载过的Class都会被缓存,当程序须求选取时,先从缓存中搜寻该Class,当缓存中荒诞不经该Class,系统菜才读取该类对应的二进制数据,并将其转为Class对象,存入缓存区中。那正是怎么校订了Class后,必得再度开动JVM,程序所做的改进才会收效的由来。

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

  1. 检测此Class是还是不是载入过(即缓存区中是还是不是有此ClassState of Qatar,倘使有则一向进去第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(State of Qatar方法来落到实处自身的载入计策,以至重写loadClass(卡塔尔国方法来促成和煦的载入进程。

获取类成员方法

  • Method getMethod(String name,Class<?>...parameterTypes):再次回到此class对象对应类的带钦点形参的public方法
  • Method[] getMethods():再次回到此class对象所表示的类的装有public方法
  • Method getDeclaredMethod(string name,Class<?>...parameterTypes):再次回到此class对象对应类的带钦点形参的主意,与措施访问权限非亲非故
  • Method[] getDeclaredMethods():重临此class对象对应类的成套方法,与办法的拜见权限无关

  2.3 创设并行使自定义的类加载器

JVM除跟类加载器之外的保有类加载器都以ClassLoader子类的实例,开拓者能够透过拓宽ClassLoader的子类,仁同一视写该ClassLoader所包含的章程达成自定义的类加载器。ClassLoader犹如下多少个举足轻重措施。

  • loadClass(String name,boolean
    resolve卡塔尔国:该办法为ClassLoader的入口点,依照钦定名称来加载类,系统便是调用ClassLoader的该形式来赢得钦点类的class对象
  • findClass(String nameState of Qatar:根据钦点名称来查找类

一经需借使兑现自定义的ClassLoader,则足以因而重写以上五个格局来落实,平日推荐重写findClass(State of Qatar方法并不是loadClass(卡塔尔方法。

classLoader(卡塔尔(قطر‎方法的实行步骤:

  1. findLoadedClass(State of Qatar:来检查是还是不是加载类,倘诺加载直接重回。
  2. 父类加载器上调用loadClass(State of Qatar方法。就算父类加载器为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类

此类时系统类加载器和进展类加载器的父类(此处的父类,是指类与类之间的的存续关系)。U大切诺基LClassLoader功用相比强硬,它能够从地点文件系统获取二进制文件来加载类,也得以从远程主机获取二进制文件加载类。

此类提供四个构造器

  • 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能够健康加载到驱动类

赢得类成员变量

  • Field getField(String name):再次来到此class对象对应类的钦命名称的public成员变量
  • Field[] getFields():再次来到此class对象对应类的具备public成员变量
  • Field getDeclaredField(String name):再次回到此class对象对应类的内定名称的分子变量,与成员变量访谈权限毫无干系
  • Field[] getDeclaredFields():重回此class对象对应类的整套分子变量,与成员变量的拜谒权限非亲非故

三. 通过反射查看类消息

Java程序中的好多对象在运行时都会现出收到外界传入的一个对象,该对象编写翻译时类型是Object,但前后相继又要求调用该目的运维时的主意。

  • 第一种做法是一旦编写翻译时和周转时都知道该目的的的品种的切切实实音信,这种情景下,能够先用instanceof(卡塔尔(قطر‎运算符举行判别,再选取强迫类型转变将其调换来运营时类型的变量就能够
  • 第二种做法是编写翻译时根本十分的小概知道该指标和类大概归于那多少个类,程序只依附运营时消息来开采该目的和类的真实性消息,那就亟须选取反射

收获类表明

  • <A extends Annotation>A getAnnotation(Class<A>annotationClass):尝试得到该class对象对应类上村子的内定项指标Annotation,若是该项目申明一纸空文,则赶回null
  • <A extends Annotation>A getDeclaredAnnotation(Class<A>annotationClass):那是Java
    第88中学新增加的,该措施赢得第一手修饰该class对象对应类的钦点项指标Annotation,倘诺荒诞不经,则赶回null
  • Annotation[] getAnnotations():再次来到修饰该class对象对应类上存在的有所Annotation
  • Annotation[] getDeclaredAnnotations():再次回到修饰该Class对象对应类上设有的拥有Annotation
  • <A extends Annotation>A[] getAnnotationByType(Class<A>annotationClass):该方式的功力与前方介绍的getAnnotation(卡塔尔(قطر‎方法基本相符,但出于Java8日增了再度声明功用,由此必要使用该情势赢得修饰该类的钦定项目标八个Annotation
  • <A extends Annotation>A[] getDeclaredAnnotationByType(Class<A>annotationClass):该方法发作用与前边介绍的getDeclaredAnnotations(State of Qatar方法平时,也是因为Java8的再一次注明的成效,须要采取该情势赢得第一手修饰该类的钦定项目标八个Annotation

  3.1 获得class对象

各类类被加载后,系统会为此类生成四个应和的Class对象,通过该Class对象能够访谈到JVM中的那么些类。获得Class对象平日三种方式

  1. 动用Class类的forName(String
    clazz卡塔尔国静态方法。字符串参数字传送入全节制类名(必得加多包名),大概会抛出ClassNotFoundexception分外。
  2. 调用有个别类的class属性来获取该类的的Class对象。
  3. 调用有些对象的getClass(State of Qatar方法,该格局是Object类的贰个方法。

对于第一种方式,第三种的优势:

  • 代码更安全。程序在编写翻译阶段就足以检查必要拜谒的Class对象是否存在。
  • 前后相继质量更加好。这的种形式无需调用方法,所以质量更加好。

获得该类内部类

  • Class<?>[] getDeclaredClasses():重临该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(State of Qatar:获取该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(State of Qatar:重回此类或接口的兼具修饰符对应的常量,再次回到的大背头供给Modifier工具类的主意来解码,才得以得到真正的修饰符
  • Package getPackage(卡塔尔国:获取此类的包
  • String getName(卡塔尔:以字符串的花样再次来到该Class对象对应类的类名
  • String getSimpleName(State of Qatar:以字符串的样式再次来到该Class对象对应类的简单称谓

以下多少个章程来判断该类是不是为接口、枚举、注解类型

  • boolean
    isAnnotation(卡塔尔:重临此Class对象是或不是意味三个解说类型(有@interface定义)
  • boolean isAnnotationPresent(Class<? extends
    Annotation>annotationClassState of Qatar:判定此Class对象是否采纳了讲解修饰
  • boolean isAnonymousClass(State of Qatar:重临此Class对象是或不是为无名氏类
  • boolean isArray(卡塔尔(قطر‎:再次回到此Class对象是不是为数组类
  • boolean isEnum(State of Qatar:重返此Class对象是否为枚举类
  • boolean isInterface(卡塔尔:再次回到此Class对象是不是为接口
  • boolean isInstance(Object
    objState of Qatar:判定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)

获得该类对象所在的表面类

  • Class<?> getDeclaringClass():重临该Class对象对应类所在的表面类

  3.3 Java 8新添的法子参数反射

Java
8新添了叁个Executable抽象基类,该目的表示可试行的类成员,该类派生了Constructor和Method四个子类。

Executable抽象基类提供了大气办法来获取修饰该措施或结构器的评释音讯;还提供了is
VarArgs(卡塔尔国方法用于判定该情势或布局器是或不是带有数据可变的形参,以致经过getModifiers(卡塔尔(قطر‎方法得到该办法或构造器的修饰符。除却,还提供如下五个措施

  • int getParameterCount(卡塔尔国:获取该构造器或艺术的形参个数
  • Parameter[] getParameters(State of Qatar:获取该构造器或措施的保有形参

Parameter类是Java
8新扩大的api,提供了汪洋情势来获得表明该措施或参数个数的泛型新闻,还提供了之类方法赢得参数新闻

  • getModifiers(State of Qatar:获取修饰该形参的修饰符
  • String getName(State of Qatar:获取形参名
  • 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());
            }
        }
    }
}

图片 1

得到该类对象对应类所完结的接口

  • Class<?>[] getInterfaces():重临该Class对象对应类所完结的上上下下接口

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

Class对象能够得到该类的艺术,布局器,成员变量。程序能够经过Method对象来实行相应的情势,通过ConStructor对象调用对应的布局器成立实例,能通过Field对象直接待上访谈并改革对象的成员变量值。

获得该类对象对应类所世袭的父类

  • Class<? super T> getSuperclass():再次回到该Class对象对应类的超类的Class对象

3.4.1 成立对象

因此反射生成对象有三种方法。

  • 选拔Class对象的newInstance(卡塔尔(قطر‎方法来创造该Class对象对应类的实例,这种办法供给该Class对象的对应类有暗中同意构造器。
  • 先使用Class对象获得内定的Constructor对象,在调用Constructor对象的newInstance(State of Qatar方法来成立该Class对象对应类的实例。

赢得该类对象对应类的修饰符、所在包、类名等为主消息

  • int getModifiers():重回此类或接口的具备修饰符,修饰符由public、protected、private、final、static、abstract等相应的常量组成,再次来到的平头应运用Modifier工具类的法子来解码,才足以收获真是的修饰符
  • Package getPackage():获取该类的包
  • String getName():以字符串方式重回此CLass对象所表示的类的简单的称呼

3.4.2 调用方法

能够经过Class对象的getMethods(State of Qatar方法和getMethod(State of Qatar方法来博取全体方法和点名方法。

种种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"));
    }
}

认清该类是还是不是为接口、枚举、注明类型

  • boolean isAnnotation():再次来到此class对象是或不是代表一个讲明类型
  • boolean isAnnotationPresent(Class<? extends Annotation>annotationClass):推断此Class对象是还是不是利用类Annotation修饰
  • boolean isAnonymousClass():再次回到此class对象是不是是叁个无名氏类
  • boolean isArray():再次来到此class对象是否意味三个数组类
  • boolean isEnum():返回此class对象是还是不是意味二个枚举
  • boolean isInterface():重临此class对象是不是意味着多少个接口
  • boolean isInstance(Object obj):推断obj是不是是此class对象的实例,该方式可以完全代表instanceof操作符

    public interface Colorable {

     public void value();
    

    }

    public class ClassInfo {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        Class<Colorable> cls=Colorable.class;
        System.out.println(cls.getMethod("value"));
        System.out.println(cls.isAnnotation());
        System.out.println(cls.isInterface());
    }
    

    }

结果

public abstract void com.em.Colorable.value()
false
true

  3.4.3 访谈成员变量

经过Class对象的getFields(卡塔尔(قطر‎方法和get菲尔德(卡塔尔国方法能够收获该类包括的装有成员变量和钦点成员变量。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 valState of Qatar。

 

Java第88中学新增添的措施参数反射

  • int getParameterCount():获取该布局器或形式的形参个数
  • Parameter[] getParameters():获取该布局器或艺术的具备形参
  • getModifiers():获取修饰该形参的修饰符
  • String getName():获取形参名
  • Type getParameterizedType():获取带泛型的形参类型
  • Class<?>getType():获取形参类型
  • boolean isNamePresent():该办法再次回到该类的class文件中是不是包罗了艺术的形参名新闻
  • boolean isVarArgs():该办法用于剖断该参数是或不是为个数可变的形参

    public class Test {

    public void getInfo(String str,List<String>list){
        System.out.println("成功");
    }
    

    }

    public class ClassInfo {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        Class<Test> cls=Test.class;
        Method med=cls.getMethod("getInfo", String.class,List.class);
        System.out.println(med.getParameterCount());
        Parameter[] params=med.getParameters();
        System.out.println(params.length);
        for(Parameter par:params){
            System.out.println(par.getName());
            System.out.println(par.getType());
            System.out.println(par.getParameterizedType());
        }
    }
    

    }

结果

2
2
arg0
class java.lang.String
class java.lang.String
arg1
interface java.util.List
java.util.List<java.lang.String>

反射生成对象

  • 利用Class对象的newInstance(卡塔尔国方法创设Class对象的实例,该方法供给要有私下认可结构器(比较常用)
  • 先使用Class对象得到钦命的Constructor对象,在调用Constructor对象的newInstance(卡塔尔(قطر‎方法来创制该Class对象对应类的实例

反射调用方法

  • Object invoke(Object obj,Object...args):该格局中的obj是实施该方法的主调,后边的args是试行该办法时传出该办法的实参

    public class Test {

    public Test(String str) {
        System.out.println(str);
    }
    public void getInfo(String str){
        System.out.println(str);
    }
    

    }

    public class ClassInfo {

    public static void main(String[] args) throws Exception {
        Class<Test> cls=Test.class;
        Constructor<Test>construct=cls.getConstructor(String.class);
        Test test=construct.newInstance("初始化");
        Method med=cls.getMethod("getInfo", String.class);
        med.invoke(test, "调用方法成功");
    }
    

    }

结果

初始化
调用方法成功

接下去看官稳重看上面包车型客车栗子

public class Test {

    public Test(String str) {
        System.out.println(str);
    }
    //私有方法
    private void getInfo(String str){
        System.out.println(str);
    }
}

public class ClassInfo {

    public static void main(String[] args) throws Exception {
        Class<Test> cls=Test.class;
        Constructor<Test>construct=cls.getConstructor(String.class);
        Test test=construct.newInstance("初始化");
      //为啥使用这个方法呢?
        Method med=cls.getDeclaredMethod("getInfo", String.class);
      //为啥使用这个方法呢?
        med.setAccessible(true);
        med.invoke(test, "调用方法成功");
    }

}

结果

初始化
调用方法成功

setAccessible(boolean
flagState of Qatar:将值设为true,提醒该Method在使用是应当裁撤Java语言的拜谒权限检查

访问成员变量值

  • getXxx(Object obj):获取obj对象的该成员变量的值。此处的Xxx对应8种基本类型,要是该成员变量的类型是援引类型的,则去掉Xxx部分
  • setXxx(Object obj,Xxx val):将obj对象的该成员变量设置为val值。此处的Xxx对应第88中学基本项目,如若该成员变量的连串是援用类型,则废除set后边的Xxx

如上七个主意能够方法全数的积极分子变量,富含private的私有成员变量

public class Test {
    private int num;

    public Test(String str) {
        System.out.println(str);
    }
    private void getInfo(String str){
        System.out.println(str);
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }

}

public class ClassInfo {

    public static void main(String[] args) throws Exception {
        Class<Test> cls=Test.class;
        Constructor<Test>construct=cls.getConstructor(String.class);
        Test test=construct.newInstance("初始化");
        Method med=cls.getDeclaredMethod("getInfo", String.class);
        med.setAccessible(true);
        med.invoke(test, "调用方法成功");
        Field fld=cls.getDeclaredField("num");
        fld.setAccessible(true);
        fld.setInt(test, 12);
        System.out.println(fld.getInt(test));
    }

}

结果

初始化
调用方法成功
12

操作数组

java.lang.reflect包下有多少个Array类,其能够动态创制数组

static Object newInstance(Class<?>componentType,int...length):创造壹个颇有钦点的成分类型、钦赐维度的新数组

static xxx getXxx(Object array,int index):重临array数组中第index个因素。个中xxx是各样基本数据类型,若是数组元素是援用类型,则该格局成为get(卡塔尔国

static void setXxx(Object array,int index,xxx val):将array数组中低index
个成分的值设为val,此中xxx是种种基本数据类型,要是数组元素是引用类型,则该方式成为set(卡塔尔国

public class ArrayInfo {

    public static void main(String[] args) {
        Object arrays=Array.newInstance(String.class, 3);
        Array.set(arrays, 0, "第一个");
        Array.set(arrays, 1, "第二个");
        Array.set(arrays, 2, "第三个");
        System.out.println(Array.get(arrays, 2));
    }
}
You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图