深入浅出：java反射机制的应用器

最新推荐文章于 2024-07-12 15:51:39 发布

最影评

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量219

点赞数

分类专栏： java 文章标签： java 反射

本文链接：https://blog.csdn.net/baidu_22790787/article/details/83552210

版权

java 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

java反射机制的应用器

java反射机制的应用器
- 请看代码
- JAVA 反射机制
Java 反射机制深入研究

java反射机制的应用器

开发的时候有时候会碰到这样的情况，我们在写程序的时候并不知道需要调用某个对象的哪个方法，只有程序运行后，我们才能够知道。或许我们需要根据客户端传过来的某个String 参数的值来判断我们应该执行哪个方法。在这种情况下JAVA 的反射执行就可以帮上忙了。下面是我做的一个简单的测试代码，提供给大家做个参考。

请看代码

import  java.lang.reflect.InvocationTargetException;
import  java.lang.reflect.Method;
/**
 *  @author  xiongdun
 *  测试 JAVA reflect 机制 
 */ 
public class TestRef {
	/**
    * @param args
    */ 
    public static void main(String[] args) {
    	TestBean test = new TestBean();
        Method[] methods = test.getClass().getMethods();
        test.setAbc("---");
        for (int i = 0; i < methods.length; i++) {
        	if (methods[i].getName().equalsIgnoreCase("getabc")) {
            	try {
                	System.out.println(methods[i].invoke(test));
	            } catch (IllegalArgumentException e) {
                	e.printStackTrace();
                } catch (IllegalAccessException e) {
                	e.printStackTrace();
                } catch (InvocationTargetException e) {
                	e.printStackTrace();
                }
        	}
    	}
	}
}

JAVA 反射机制

JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称为java 语言的反射机制。 Java 反射机制主要提供了以下功能：在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。

得到某个对象的属性

public Object getProperty(Object owner, String fieldName) throws Exception {
	Class ownerClass = owner.getClass();
	Field field = ownerClass.getField(fieldName);
    Object property = field.get(owner);
	return property;
}

Class ownerClass = owner.getClass() # 得到该对象的Class 。
Field field = ownerClass.getField(fieldName) # 通过Class 得到类声明的属性。
Object property = field.get(owner) # 通过对象得到该属性的实例，如果这个属性是非公有的，这里会报IllegalAccessException 。

得到某个类的静态属性

public Object getStaticProperty(String className, String fieldName) throws Exception {
	Class ownerClass = Class.forName(className);
  	Field field = ownerClass.getField(fieldName);
    Object property = field.get(ownerClass);
    return property;
}

Class ownerClass = Class.forName(className) ：首先得到这个类的Class 。
Field field = ownerClass.getField(fieldName) ：和上面一样，通过Class 得到类声明的属性。
Object property = field.get(ownerClass) ：这里和上面有些不同，因为该属性是静态的，所以直接从类的Class 里取。

执行某对象的方法

public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception { 
	Class ownerClass = owner.getClass();
    Class[] argsClass = new Class[args.length];
	for (int i = 0, j = args.length; i < j; i++) {
		argsClass[i] = args[i].getClass();
	}
	Method method = ownerClass.getMethod(methodName, argsClass);
	return method.invoke(owner, args);
}

Class owner_class = owner.getClass() ：首先还是必须得到这个对象的Class 。
5 ～9 行：配置参数的Class 数组，作为寻找Method 的条件。
Method method = ownerClass.getMethod(methodName, argsClass) ：通过Method 名和参数的Class 数组得到要执行的Method 。
method.invoke(owner, args) ：执行该Method ，invoke 方法的参数是执行这个方法的对象，和参数数组。返回值是Object ，也既是该方法的返回值。

执行某个类的静态方法

public Object invokeStaticMethod(String className, String methodName, Object[] args) throws Exception {
	Class ownerClass = Class.forName(className);
	Class[] argsClass = new Class[args.length];
	for (int i = 0, j = args.length; i < j; i++) {
		argsClass[i] = args[i].getClass();
	}
	Method method = ownerClass.getMethod(methodName, argsClass);
	return method.invoke(null, args);
}

基本的原理和实例3 相同，不同点是最后一行，invoke 的一个参数是null ，因为这是静态方法，不需要借助实例运行。

新建实例

public Object newInstance(String className, Object[] args) throws Exception {
	Class newoneClass = Class.forName(className);
	Class[] argsClass = new Class[args.length];
	for (int i = 0, j = args.length; i < j; i++) {
	argsClass[i] = args[i].getClass();
	}
	Constructor cons = newoneClass.getConstructor(argsClass);
	return cons.newInstance(args);
}

这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数，可以直接使用newoneClass.newInstance() 来实现。
Class newoneClass = Class.forName(className) ：第一步，得到要构造的实例的Class 。
第5 ～第9 行：得到参数的Class 数组。
Constructor cons = newoneClass.getConstructor(argsClass) ：得到构造子。
cons.newInstance(args) ：新建实例。

判断是否为某个类的实例

public boolean isInstance(Object obj, Class cls) {
	return cls.isInstance(obj);
}

得到数组中的某个元素

public Object getByArray(Object array, int index) {
	return Array.get(array,index);
}

Java 反射机制深入研究

Java 反射是 Java 语言的一个很重要的特征，它使得 Java 具体了 动态性 。
在 Java 运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于 Java 语言的反射（ Reflection ）机制。

Java 反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。
在运行时构造任意一个类的对象。
在运行时判断任意一个类所具有的成员变量和方法。
在运行时调用任意一个对象的方法。

Reflection 是 Java 被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过 Reflection APIs 取得任何一个已知名称的 class 的内部信息，包括其 modifiers （诸如 public, static 等等）、 superclass （例如 Object ）、实现之 interfaces（例如 Serializable ），也包括 fields 和 methods 的所有信息，并可于运行时改变 fields 内容或调用 methods 。
一般而言，开发者社群说到动态语言，大致认同的一个定义是： “ 程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言” 。从这个观点看， Perl ， Python ， Ruby 是动态语言， C++ ， Java ， C# 不是动态语言。

尽管在这样的定义与分类下 Java 不是动态语言，它却有着一个非常突出的动态相关机制： Reflection 。这个字的意思是 “ 反射、映象、倒影 ” ，用在 Java 身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的 classes 。换句话说， Java 程序可以加载一个运行时才得知名称的 class ，获悉其完整构造（但不包括 methods 定义），并生成其对象实体、或对其 fields 设值、或唤起其methods 。这种 “ 看透 class” 的能力（ the ability of the program to examine itself ）被称为 introspection （内省、内观、反省）。 Reflection 和 introspection 是常被并提的两个术语。

在 JDK 中，主要由以下类来实现 Java 反射机制，这些类都位于 java.lang.reflect 包中：

Class 类：代表一个类。
Field 类：代表类的成员变量（成员变量也称为类的属性）。
Method 类：代表类的方法。
Constructor 类：代表类的构造方法。
Array 类：提供了动态创建数组，以及访问数组的元素的静态方法。
下面给出几个例子看看 Reflection API 的实际运用：

一、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等

在 java.lang.Object 类中定义了 getClass() 方法，因此对于任意一个 Java 对象，都可以通过此方法获得对象的类型。 Class 类是Reflection API 中的核心类，它有以下方法

getName() ：获得类的完整名字。
getFields() ：获得类的 public 类型的属性。
getDeclaredFields() ：获得类的所有属性。
getMethods() ：获得类的 public 类型的方法。
getDeclaredMethods() ：获得类的所有方法。
getMethod(String name, Class[] parameterTypes) ：获得类的特定方法， name 参数指定方法的名字
parameterTypes 参数指定方法的参数类型。
getConstructors() ：获得类的 public 类型的构造方法。
getConstructor(Class[] parameterTypes) ：获得类的特定构造方法， parameterTypes 参数指定构造方法的参数类型。
newInstance() ：通过类的不带参数的构造方法创建这个类的一个对象。

下面给出一个综合运用的例子：

public class RefConstructor {
	public static void main(String args[]) throws Exception {
		RefConstructor ref = new RefConstructor();
        ref.getConstructor();
    }
    public void getConstructor() throws Exception {
		Class c = null;
		c = Class.forName("java.lang.Long");
		Class cs[] = {java.lang.String.class};
        System.out.println("/n-------------------------------/n");
        Constructor cst1 = c.getConstructor(cs);
        System.out.println("1 、通过参数获取指定 Class 对象的构造方法： ");
        System.out.println(cst1.toString());
        Constructor cst2 = c.getDeclaredConstructor(cs);
        System.out.println("2 、通过参数获取指定 Class 对象所表示的类或接口的构造方法： ");
        System.out.println(cst2.toString());
        Constructor cst3 = c.getEnclosingConstructor();
        System.out.println("3 、获取本地或匿名类 Constructor 对象，它表示基础类的立即封闭构造方法。 ");
        if (cst3 != null) {
        	System.out.println(cst3.toString());
        } else {
        	System.out.println("-- 没有获取到任何构造方法！ ");
        }
        Constructor[] csts = c.getConstructors();
        System.out.println("4 、获取指定 Class 对象的所有构造方法： ");
        for (int i = 0; i < csts.length; i++) {
            System.out.println(csts[i].toString());
        }
        System.out.println("/n-------------------------------/n");
        Type types1[] = c.getGenericInterfaces();
        System.out.println("1 、返回直接实现的接口： ");
        for (int i = 0; i < types1.length; i++) {
            System.out.println(types1[i].toString());
        }
        Type type1 = c.getGenericSuperclass();
        System.out.println("2 、返回直接超类： ");
        System.out.println(type1.toString());
        Class[] cis = c.getClasses();
        System.out.println("3 、返回超类和所有实现的接口： ");
        for (int i = 0; i < cis.length; i++) {
            System.out.println(cis[i].toString());
        }
        Class cs1[] = c.getInterfaces();
        System.out.println("4 、实现的接口 ");
        for (int i = 0; i < cs1.length; i++) {
            System.out.println(cs1[i].toString());
        }
        System.out.println("/n-------------------------------/n");
        Field fs1[] = c.getFields();
        System.out.println("1 、类或接口的所有可访问公共字段： ");
        for (int i = 0; i < fs1.length; i++) {
            System.out.println(fs1[i].toString());
        }
        Field f1 = c.getField("MIN_VALUE");
        System.out.println("2 、类或接口的指定已声明指定公共成员字段： ");
        System.out.println(f1.toString());
        Field fs2[] = c.getDeclaredFields();
        System.out.println("3 、类或接口所声明的所有字段： ");
        for (int i = 0; i < fs2.length; i++) {
            System.out.println(fs2[i].toString());
        }
        Field f2 = c.getDeclaredField("serialVersionUID");
        System.out.println("4 、类或接口的指定已声明指定字段： ");
        System.out.println(f2.toString());
        System.out.println("/n-------------------------------/n");
        Method m1[] = c.getMethods();
        System.out.println("1 、返回类所有的公共成员方法： ");
        for (int i = 0; i < m1.length; i++) {
            System.out.println(m1[i].toString());
        }
        Method m2 = c.getMethod("longValue", new Class[]{});
        System.out.println("2 、返回指定公共成员方法： ");
        System.out.println(m2.toString());
    }
}

输出结果：输出结果很长，这里不再给出。

二、运行时复制对象

例程 ReflectTester 类进一步演示了 Reflection API 的基本使用方法。 ReflectTester 类有一个 copy(Object object) 方法，这个方法能够创建一个和参数 object 同样类型的对象，然后把 object 对象中的所有属性拷贝到新建的对象中，并将它返回

这个例子只能复制简单的 JavaBean ，假定 JavaBean 的每个属性都有 public 类型的 getXXX() 和 setXXX() 方法。

public class ReflectTester {
	public Object copy(Object object) throws Exception {
		// 获得对象的类型
        Class<?> classType = object.getClass();
        System.out.println("Class:" + classType.getName());
        // 通过默认构造方法创建一个新的对象
        Object objectCopy = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
        // 获得对象的所有属性
        Field fields[] = classType.getDeclaredFields();
        for (int i = 0; i < fields.length; i++) {
            Field field = fields[i];
            String fieldName = field.getName();
            String firstLetter = fieldName.substring(0, 1).toUpperCase();
            // 获得和属性对应的 getXXX() 方法的名字
            String getMethodName = "get" + firstLetter + fieldName.substring(1);
            // 获得和属性对应的 setXXX() 方法的名字
            String setMethodName = "set" + firstLetter + fieldName.substring(1);
            // 获得和属性对应的 getXXX() 方法
            Method getMethod = classType.getMethod(getMethodName, new Class[]{});
            // 获得和属性对应的 setXXX() 方法
            Method setMethod = classType.getMethod(setMethodName, new Class[]{field.getType()});
            // 调用原对象的 getXXX() 方法
            Object value = getMethod.invoke(object, new Object[]{});
            System.out.println(fieldName + ":" + value);
            // 调用拷贝对象的 setXXX() 方法
            setMethod.invoke(objectCopy, new Object[]{value});
        }
        return objectCopy;
    }
    
    public static void main(String[] args) throws Exception {
        Customer customer = new Customer("Tom", 21);
        customer.setId(new Long(1));
        Customer customerCopy = (Customer) new ReflectTester().copy(customer);
        System.out.println("Copy information:" + customerCopy.getId() + " " + customerCopy.getName() + " " + customerCopy.getAge());
    }
}

class Customer {
    private Long id;
    private String name;
    private int age;
    
    public Customer() {

    }
    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

输出结果：
Class:com.langsin.reflection.Customer
id:1
name:Tom
age:21
Copy information:1 Tom 21
Process finished with exit code 0

解说：
ReflectTester 类的 copy(Object object) 方法依次执行以下步骤
（ 1 ）获得对象的类型：
Class classType=object.getClass();
System.out.println(“Class:”+classType.getName());
（ 2 ）通过默认构造方法创建一个新对象：
Object objectCopy=classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
以上代码先调用 Class 类的 getConstructor() 方法获得一个 Constructor 对象，它代表默认的构造方法，然后调用 Constructor 对象的 newInstance() 方法构造一个实例。
（ 3 ）获得对象的所有属性：
Field fields[]=classType.getDeclaredFields();
Class 类的 getDeclaredFields() 方法返回类的所有属性，包括 public 、 protected 、默认和 private 访问级别的属性
（ 4 ）获得每个属性相应的 getXXX() 和 setXXX() 方法，然后执行这些方法，把原来对象的属性拷贝到新的对象中

三、用反射机制调用对象的方法

public class InvokeTester {
	public int add(int param1, int param2) {
		return param1 + param2;
	}

    public String echo(String msg) {
		return "echo: " + msg;
    }

    public static void main(String[] args) throws Exception {
        Class<?> classType = InvokeTester.class;
        Object invokeTester = classType.newInstance();
        // Object invokeTester = classType.getConstructor(new
        // Class[]{}).newInstance(new Object[]{});
        // 获取 InvokeTester 类的 add() 方法
        Method addMethod = classType.getMethod("add", new Class[]{int.class, int.class});
        // 调用 invokeTester 对象上的 add() 方法
        Object result = addMethod.invoke(invokeTester, new Object[]{new Integer(100), new Integer(200)});
        System.out.println((Integer) result);
        // 获取 InvokeTester 类的 echo() 方法
        Method echoMethod = classType.getMethod("echo", new Class[]{String.class});
        // 调用 invokeTester 对象的 echo() 方法
        result = echoMethod.invoke(invokeTester, new Object[]{"Hello"});
        System.out.println((String) result);
    }
}

在例程 InvokeTester 类的 main() 方法中，运用反射机制调用一个 InvokeTester 对象的 add() 和 echo() 方法
add() 方法的两个参数为 int 类型，获得表示 add() 方法的 Method 对象的代码如下：


Method addMethod=classType.getMethod("add",new Class[]{int.class,int.class});

Method 类的 invoke(Object obj,Object args[]) 方法接收的参数必须为对象，如果参数为基本类型数据，必须转换为相应的包装类型的对象。 invoke() 方法的返回值总是对象，如果实际被调用的方法的返回类型是基本类型数据，那么 invoke() 方法会把它转换为相应的包装类型的对象，再将其返回。

在本例中，尽管 InvokeTester 类的 add() 方法的两个参数以及返回值都是 int 类型，调用 add Method 对象的 invoke() 方法时，只能传递 Integer 类型的参数，并且 invoke() 方法的返回类型也是 Integer 类型， Integer 类是 int 基本类型的包装类：
Object result=addMethod.invoke(invokeTester,
new Object[]{new Integer(100),new Integer(200)});
System.out.println((Integer)result); //result 为 Integer 类型

四、动态创建和访问数组

java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。

例程 ArrayTester1 类的 main() 方法创建了一个长度为 10 的字符串数组，接着把索引位置为 5 的元素设为 “hello” ，然后再读取索引位置为 5 的元素的值

public class ArrayTester1 {
	public static void main(String args[]) throws Exception {
		Class<?> classType = Class.forName("java.lang.String");
		// 创建一个长度为 10 的字符串数组
		Object array = Array.newInstance(classType, 10);
		// 把索引位置为 5 的元素设为 "hello"
		Array.set(array, 5, "hello");
		// 获得索引位置为 5 的元素的值
		String s = (String) Array.get(array, 5);
		System.out.println(s);
	}
}

例程 ArrayTester2 类的 main() 方法创建了一个 5 x 10 x 15 的整型数组，并把索引位置为 [3][5][10] 的元素的值为设 37 。

public class ArrayTester2 {
	public static void main(String args[]) {
		int[] dims = new int[]{5, 10, 15};
		// 创建一个具有指定的组件类型和维度的新数组。
		Object array = Array.newInstance(Integer.TYPE, dims);
		Object arrayObj = Array.get(array, 3);
	
		Class<?> cls = arrayObj.getClass().getComponentType();
		System.out.println(cls);
		arrayObj = Array.get(arrayObj, 5);
		Array.setInt(arrayObj, 10, 37);
		int arrayCast[][][] = (int[][][]) array;
		System.out.println(arrayCast[3][5][10]);
	}
}

深入认识 Class 类

众所周知 Java 有个 Object 类，是所有 Java 类的继承根源，其内声明了数个应该在所有 Java 类中被改写的方法： hashCode() 、equals() 、 clone() 、 toString() 、 getClass() 等。其中 getClass() 返回一个 Class 类的对象。

Class 类十分特殊。它和一般 classes 一样继承自 Object ，其实体用以表达 Java 程序运行时的 classes 和 interfaces ，也用来表达 enum 、 array 、 primitive Java types（ boolean, byte, char, short, int, long, float, double ）以及关键词 void 。当一个 class 被加载，或当加载器（ class loader）的 defineClass() 被 JVM 调用， JVM 便自动产生一个 Class object 。如果您想借由 “ 修改 Java 标准库源码 ” 来观察 Class object 的实际生成时机（例如在 Class 的 constructor 内添加一个 println() ），不能够！因为 Class 并没有 public constructor
Class 是 Reflection 起源。针对任何您想探勘的 class ，唯有先为它产生一个 Class object ，接下来才能经由后者唤起为数十多个的Reflection APIs

Java 允许我们从多种途径为一个 class 生成对应的 Class 对象。参看本人的《深入研究 java.long.Class 类》一文。

欲生成对象实体，在 Reflection 动态机制中有两种作法，一个针对 “ 无自变量 ctor” ，一个针对 “ 带参数 ctor” 。如果欲调用的是 “带参数 ctor“ 就比较麻烦些，不再调用 Class 的 newInstance() ，而是调用 Constructor 的 newInstance() 。首先准备一个Class[] 做为 ctor 的参数类型（本例指定为一个 double 和一个 int ），然后以此为自变量调用 getConstructor() ，获得一个专属 ctor 。接下来再准备一个 Object[] 做为ctor 实参值（本例指定 3.14159 和 125 ），调用上述专属 ctor 的 newInstance() 。

动态生成 “Class object 所对应之 class” 的对象实体；无自变量。
这个动作和上述调用 “ 带参数之 ctor” 相当类似。首先准备一个 Class[] 做为参数类型（本例指定其中一个是 String ，另一个是Hashtable ），然后以此为自变量调用 getMethod() ，获得特定的 Method object 。接下来准备一个 Object[] 放置自变量，然后调用上述所得之特定 Method object 的 invoke() 。

为什么获得 Method object 时不需指定回返类型？

因为 method overloading 机制要求 signature 必须唯一，而回返类型并非 signature 的一个成份。换句话说，只要指定了method 名称和参数列，就一定指出了一个独一无二的 method 。

四、运行时变更 field 内容

与先前两个动作相比， “ 变更 field 内容 ” 轻松多了，因为它不需要参数和自变量。首先调用 Class 的 getField() 并指定 field 名称。获得特定的 Field object 之后便可直接调用 Field 的 get() 和 set() 。

public class RefFiled  {
	public double x;
    public Double y;
    public static void main(String args[]) throws NoSuchFieldException, IllegalAccessException {
		Class c = RefFiled.class;
        Field xf = c.getField("x");
        Field yf = c.getField("y");
		RefFiled obj = new RefFiled();
		System.out.println(" 变更前 x=" + xf.get(obj));
        // 变更成员 x 值
        xf.set(obj, 1.1);
        System.out.println(" 变更后 x=" + xf.get(obj));
        System.out.println(" 变更前 y=" + yf.get(obj));
        // 变更成员 y 值
        yf.set(obj, 2.1);
        System.out.println(" 变更后 y=" + yf.get(obj));
    }
}

运行结果：
变更前 x=0.0
变更后 x=1.1
变更前 y=null
变更后 y=2.1

	Process finished with exit code 0
	private static Object check(Object obj,String flag) throws Exception {
		Class ts = obj.getClass();
		Field[] fs = ts.getDeclaredFields();
		Method[] ms = ts.getDeclaredMethods();
		StringBuffer fd = new StringBuffer();
		Map<String,Object> getMethodMap=new HashMap<String,Object>();
		Map<String,Method> setMethodMap=new HashMap<String,Method>();

		String methodName="";
		String value="";
		for(int i = 0;i < fs.length; i++) {
			if (java.lang.String.class != fs[i].getType()) {
				fd.append(fs[i].getName());

			}
		}

        for (int i = 0;i < ms.length; i++) {
			methodName=ms[i].getName().toLowerCase();
				if (methodName.indexOf("get") != -1) {
					getMethodMap.put(methodName.substring(3), ms[i].invoke(obj, null));
				} else {
					setMethodMap.put(methodName.substring(3), ms[i]);
				}
			}
			Set keySet = getMethodMap.keySet();
			Iterator it = keySet.iterator();
			String key = "";
			while (it.hasNext()) {
				key = it.next().toString();
				if (fd.indexOf(key) == -1 && getMethodMap.get(key) != null) {
					value=getMethodMap.get(key).toString().replaceAll(",", "").replaceAll(" ", "");
					if("".equals(value)||flag.equals(value)) {
						((Method) setMethodMap.get(key)).invoke(obj, new Object[]{null});                              
					} else {
						((Method) setMethodMap.get(key)).invoke(obj, new Object[]{value});                                  
					}
				}
			}
		}
    }
	return obj;
}

最影评

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
深入浅出：java反射机制的应用器

java反射机制的应用器java反射机制的应用器请看代码JAVA 反射机制Java 反射机制深入研究Java 反射机制主要提供了以下功能：在 JDK 中，主要由以下类来实现 Java 反射机制，这些类都位于 java.lang.reflect 包中：一、通过 Class 类获取成员变量、成员方法、接口、超类、构造方法等二、运行时复制对象三、用反射机制调用对象的方法四、动态创建和访问数组深入认识 C...
复制链接

扫一扫