`

java反射详解

 
阅读更多

来源:http://www.hxstrive.com/article/111.htm

 

一、在Java运行时环境中,对于任意一个类,能否知道这个类有哪些属性和方法?对于任意一个对象,能否调用它的任意一个方法?答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射(Reflection)机制。

 

二、反射能干什么?

    a、在运行时判断任意一个对象所属的类。

    b、在运行时构造任意一个类的对象。

    c、在运行时判断任意一个类所具有的成员变量和方法。

    d、在运行时调用任意一个对象的方法(包括私有方法,但是破坏了封装性)

 

三、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是常被并提的两个术语

 

五、Java Reflection API 简介

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

    a、Class类:代表一个类。

    b、Field 类:代表类的成员变量(成员变量也称为类的属性)。

    c、Method类:代表类的方法。

    d、Constructor 类:代表类的构造方法。

    e、Array类:提供了动态创建数组,以及访问数组的元素的静态方法

 

1、例程Reflect类演示了Reflection API的基本作用,它读取命令行参数指定的类名,然后打印这个类所具有的方法信息

package reflected;
import java.lang.reflect.Method;
/**
 * 演示反射机制
 * @author HuangXin
 * 通过类的全名,获得类中的所有方法
 */
public class Reflect {
    public static void main(String[] args)throws Exception{
        Class<?> classType = Class.forName(args[0]);//获得指定类的class对象
        Method[] methods = classType.getDeclaredMethods();//返回classType对象中的所有已经声明的方法
        for(Method m : methods){//打印所有的方法名
            System.out.println(m);
        }
    }
}

 运行:java Reflect java.lang.String

2、例程ReflectTester 类进一步演示了Reflection API的基本使用方法。ReflectTester类有一个copy(Object object)方法,这个方法能够创建一个和参数object 同样类型的对象,然后把object对象中的所有属性拷贝到新建的对象中,并将它返回。这个例子只能复制简单的JavaBean,假定JavaBean 的每个属性都有public 类型的getXXX()和setXXX()方法。

package reflected;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
/**
 * 演示使用反射机制调用getter和settled方法,操作属性
 * @author HuangXin
 *
 */
public class RefelctTester {
    //复制一份副本
    public Object copy(Object object) throws Exception{
        Class<?> classType = object.getClass();
        //使用与所有的构造方法
        Object objectType = classType.getConstructor(new Class[]{}).newInstance(new Object[]{});
        //Object objectType = classType.newInstance();
        //等价于
        //Object objectType = classType.newInstance();
        //获得所有的属性
        Field[] fields = classType.getDeclaredFields();
        for(int i=0;i<fields.length;i++){
            Field field = fields[i];
            String fieldName = field.getName();
            String first = fieldName.substring(0,1).toUpperCase();
            String getMethodName = "get" + first + fieldName.substring(1);
            String setMethodName = "set" + first + fieldName.substring(1);
            Method getMeth = classType.getMethod(getMethodName,new Class[]{});
            Method setMeth = classType.getMethod(setMethodName,new Class[]{field.getType()});
            Object value = getMeth.invoke(object, new Object[]{});
            setMeth.invoke(objectType, new Object[]{value});
        }
        return objectType;
    }
 
    public static void main(String[] args) throws Exception {
        User user = new User();
        user.setId(new Long(1));
        user.setUsername("zhangjia");
        user.setAge(new Integer(22));
        User userCopy = (User)new RefelctTester().copy(user);
        System.out.println(userCopy.getId()+","+userCopy.getUsername()+","+userCopy.getAge());
        System.out.println(user.getId()+","+user.getUsername()+","+user.getAge());
    }
}
 
class User{
    private Long id;
    private String username;
    private int age;
     
    public User(){
     
    }
     
    public Long getId() {
        return id;
    }
     
    public void setId(Long id) {
        this.id = id;
    }
     
    public String getUsername() {
        return username;
    }
     
    public void setUsername(String username) {
        this.username = username;
    }
     
    public int getAge() {
        return age;
    }
     
    public void setAge(int age) {
        this.age = age;
    }
}

(1)获得对象的类型:ReflectTester 类的copy(Object object)方法依次执行以下步骤

    Class classType=object.getClass();

    System.out.println("Class:"+classType.getName());

 

    在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():通过类的不带参数的构造方法创建这个类的一个对象。

 

(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()方法,然后执行这些方法,把原来对象的属性拷贝到新的对象中

 

3、在例程InvokeTest类的main()方法中,运用反射机制调用一个InvokeTester对象的add()和echo()方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package reflected;
import java.lang.reflect.Method;
/**
 * 演示用反射机制调用类中的方法
 * @author
 
 */
public class InvokeTest {
    public int add(int sum1,int sum2){
        return sum1+sum2;
    }
     
    public String echo(String message){
        return "goods:"+message;
    }
     
    public static void main(String[] args) throws  Exception {
        //获得INnvokeTest类的Class对象
        Class<?> classType = InvokeTest.class;
        //创建classType对象的实例(此种方式只能创建默认的构造方法,即没有参数的构造方法)
        Object invokeTester = classType.newInstance();
        //返回指定的方法,方法可以用方法名和参数列表区别
        Method addMethod = classType.getMethod("add",new Class[]{int.class,int.class});
        //调用方法
        Object result = addMethod.invoke(invokeTester, new Object[]{100,200});
        System.out.println((Integer)result);
        //等价一下代码
        //InvokeTest i = new InvokeTest();
        //int result = i.add(100,200);
        //System.out.println(result);
        Method echoMethod = classType.getMethod("echo",new Class[]{String.class});
        Object result2 = echoMethod.invoke(invokeTester, new Object[]{"huangxin"});
        System.out.println((String)result2);
    }
}

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类型

 

4、java.lang.Array 类提供了动态创建和访问数组元素的各种静态方法。例程ArrayTester1 类的main()方法创建了一个长度为10 的字符串数组,接着把索引位置为5 的元素设为“hello”,然后再读取索引位置为5 的元素的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package com.langsin.reflection;
import java.lang.reflect.Array;
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);
    }
}

 

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.langsin.reflection;
import java.lang.reflect.Array;
public class ArrayTester2 {
    public static void main(String args[]){
        int[] dims = new int[] { 51015 };
        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, 1037);
        int arrayCast[][][] = (int[][][]) array;
        System.out.println(arrayCast[3][5][10]);
    }
}

 

六、Class

    众所周知Java有个Object class,是所有Java classes的继承根源,其内声明了数个应该在所有Java class中被改写的methods:hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class object。

 

    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 object:

a、运用getClass()注:每个类都有此函数

1
2
String str = "abc";
Class c1 = str.getClass();

 

b、运用Class.getSuperclass()

1
2
3
Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();

 

c、运行static method Class.forName()(最常用)

1
Class c1 = Class.forName("java.lang.String");

 

d、运用.class语法

1
2
Class c1 = String.class;
Class c5 = int[].class;

 

e、运用primitive wrapper classes的TYPE语法

1
2
Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;

实例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package reflected;
import java.awt.Button;
public class GetSuperClassTest {
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Button button = new Button();
        Class<?> c1 = button.getClass();//返回button的class对象
        System.out.println(c1);
        Class<?> c2 = c1.getSuperclass();//返回button的父对象
        System.out.println(c2);
        Class<?> c3 = c2.getSuperclass();//返回button的父对象的父对象
        System.out.println(c3);
    }
}

 

七、运行时生成instances

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

如果是无参构造方法:

1
2
Class c = Test.class;
Object obj = c.newInstance();

 

有参构造方法:

1
2
3
4
5
Class c = Test.class;
Class[] classType = {Integer.class,String.class};
Constructor constructor = c.getConstructor(classType);
Object[] param = {23,"haha"};
Object obj = constructor.newInstance(param);

 

八、运行时调用methods

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

 

    为什么获得Method object时不需指定回返类型?因为method overloading机制要求signature必须唯一,而回返类型并非signature的一个成份。换句话说,只要指定了method名称和参数列,就一定指出了一个独一无二的method。如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
Class c = Test.calss;
Class types = new Class[2];
types[0] = Class.forName("java.lang.String");
types[1] = Class.forName("java.lang.Integer");
Methoethod = c.getMethod("testMethod",types);
Test obj = new Test();
Object[] param = {"haha",23};
Object r = method.invoke(obj,param);
 
// ******************************
package reflected;
import java.lang.reflect.Method;
@SuppressWarnings("unchecked")
public class MethodTest {
    public static void test(Object obj)throws Exception{
        Class<MyMethod> type = (Class<MyMethod>)obj.getClass();
        Object objectType = type.getConstructor(new Class[]{}).newInstance(new Object[]{});
        Method method = type.getMethod("prin",new Class[]{});
        method.invoke(objectType, new Object[]{});
        method = type.getMethod("add"new Class[]{int.class,int.class});
        Object result = method.invoke(objectType, new Object[]{3,4});
        System.out.println(result);
        System.out.println(result.getClass().getName());
    }
 
    public static void main(String[] args) {
        MyMethod p = new MyMethod();
        try {
            test(p);
        catch (Exception e) {
            e.printStackTrace();
        }
    }
}
 
class MyMethod{
    public MyMethod(){}
 
    public void prin(){
        System.out.println("Hello World!");
    }
     
    public int add(int x,int y){
        return x + y;
    }
}

 

 

 

 

 

分享到:
评论

相关推荐

    JAVA反射详解

    ### JAVA反射详解 Java反射是Java编程语言的一个强大特性,允许程序在运行时检查和操作类、接口、字段和方法等。本文章旨在深入解析Java反射机制,包括其原理、应用以及常见用法。 #### 了解Class对象 在Java中,...

    JAVA 反射详解PPT

    Java反射机制是Java编程语言中的一个重要特性,它允许程序在运行时检查和操作类、接口、对象等的内部信息。通过反射,我们可以动态地创建对象、访问和修改字段、调用方法,甚至执行私有方法和访问包内可见的元素。...

    Java 反射详解

    Java反射是Java编程语言中的一个强大特性,它允许运行时的程序访问并操作类、接口、字段和方法等对象,即使这些对象在编译时并未被明确地引用。这一特性使得Java具有高度的动态性,使得代码能够在运行时检查类的信息...

    java反射详解例子

    "java反射机制详解" Java 反射机制是 Java 语言中的一种功能,它允许程序员在运行时检查和修改一个类的结构和行为。 Java 反射机制提供了一种获取类的信息、创建对象、调用方法和获取字段值的方式。 在 Java 中,...

    Java反射详解.pdf

    反射机制是Java语言中一个非常重要的特性,它允许程序在运行时通过特定的API动态地访问对象的属性和方法。反射机制是Java编程的强大工具之一,但它也带来了安全性和性能问题,因此需要谨慎使用。在Java中,反射主要...

    java反射详解1

    Java反射是Java语言的一个强大特性,它允许程序在运行时动态地获取类的信息(如类名、方法、字段等)并进行操作。反射在许多场景下都非常有用,例如在框架开发、插件系统、序列化、动态代理等方面。本文将通过三个...

    java反射详解 fly

    Java反射是Java编程语言中的一个强大特性,它允许运行时检查类、接口、字段和方法的信息,甚至在程序运行过程中动态地创建对象和调用方法。这个特性使得Java具有高度的灵活性,尤其在处理元数据、插件系统、序列化、...

    java反射 详解 入门到掌握

    Java反射是Java编程语言中的一个强大工具,它允许程序在运行时检查并操作类、接口、字段和方法的信息。这使得开发者能够在不事先知道具体类名或方法名的情况下,动态地创建对象并调用方法。Java反射机制是Java动态性...

    Java 反射详解(包含私有方法属性的调用)

    Java反射是Java编程语言中的一个强大特性,它允许在运行时检查类、接口、字段和方法的信息,并且能够在运行时动态地创建对象和调用方法。这个特性使得Java程序具有了高度的灵活性和动态性,尤其在框架开发、插件系统...

    JAVA反射详细讲解

    Java反射详解 在Java编程语言中,反射是一个强大的工具,它允许程序在运行时检查类、接口、字段和方法的信息,甚至能够在运行时创建和访问这些对象。这种能力使得Java成为一种动态语言,增强了代码的灵活性和可扩展...

    java 反射机制详解

    Java 反射机制是 Java 语言中的一个重要特性,它允许程序在运行时动态地获取类的信息(如类名、属性、方法等)并调用对象的方法,甚至修改对象的状态。这一机制极大地增强了 Java 程序的灵活性和可扩展性,尤其是在...

    JAVA反射机制详解视频

    (通过反射获取无参构造方法并使用) (通过反射获取带参构造方法并使用) (通过反射获取私有构造方法并使用) (通过反射获取成员变量并使用) (通过反射获取无参无返回值成员方法并使用) (通过反射获取带参带返回值成员...

    java反射原理详解

    Java反射机制是Java语言的一种强大的特性,它允许程序在运行时动态地获取类的信息并操作类的对象。在Java中,反射主要涉及到`java.lang.Class`类、`java.lang.reflect`包中的类(如Constructor、Method、Field)以及...

    java反射机制详解与应用

    Java反射机制是Java语言的一项强大功能,它允许程序在运行时动态地获取类的信息并操作类的对象。这一特性使得Java具有高度的灵活性和强大的扩展性,尤其是在开发框架和库时,反射机制起到了至关重要的作用。本文将...

    Java常见笔试、面试题目深度剖析 反射详解

    Java反射详解是Java编程中一个重要的高级特性,它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java的笔试和面试中,反射是一个常见的考察点,因此理解并掌握反射机制对于开发者来说至关...

    java反射机制详解

    ### Java反射机制详解 #### 一、反射机制是什么 反射机制是Java编程语言的一个核心特性,它允许程序在运行时动态地获取类的信息,并且能够动态地创建对象和调用对象的方法。简单来说,反射机制使得Java程序可以...

    Java反射机制详解

    Java反射机制是Java编程语言中的一个重要特性,它允许程序在运行时动态地获取类的信息并调用其方法。反射机制提供了对Java类和对象的元数据的访问,从而增加了代码的灵活性和动态性。 首先,要理解Java反射的预备...

Global site tag (gtag.js) - Google Analytics