java反射

Java 反射 API
什么是反射：
   1、在运行时根据一个类的对象或类名解析出生成该对象的类定义，包括：
             1）类名；
             2）类所在包名；
             3）类中定义的所有方法---包括格方法的访问修饰符、参数个数、参数类型、返回值的类型、抛出异常；
             4）类的所有属性：---包括这些属性的数据类型、访问修饰符。
   2、使用该类做通常一切。
一、实例：
import java.lang.reflect.*;
public class DumpMethods {
    public static void main(String args[]) {
        try {
            Class c = Class.forName(args[0]);
            Method m[] = c.getDeclaredMethods();
            for (int i = 0; i < m.length; i++)
                System.out.println(m[i].toString());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}
按如下语句执行：
java DumpMethods java.util.Stack





它的结果输出为：
public java.lang.Object java.util.Stack.push(java.lang.Object)
public synchronized java.lang.Object java.util.Stack.pop()
public synchronized java.lang.Object java.util.Stack.peek()
public boolean java.util.Stack.empty()
public synchronized int java.util.Stack.search(java.lang.Object)
二、Reflection APIs
java.lang.reflect包中定义了以下用于反射的类：
Class
Package
Method
Constructor
Field
类，其中Class是核心类，其常用方法如下：

功能 方法 返回值类型
获得类所在包 getPackage() Package
获得导入的包 无直接对应之API。
获得访问修饰符 int getModifiers()
Modifier.toString(int)
Modifier.isInterface(int) int
String
bool
获得类名或接口 名称getName() String
获得类型参数 getTypeParameters() TypeVariable <Class>[]
获得类的超类 getSuperClass() Class
获得接口 getInterfaces() Class[]
获得内部类 getDeclaredClasses() Class[]
获得外部类 getDeclaringClass() Class
获得类的构造函数
构造函数getDeclaredConstructors() 不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。 Constructor[]
获得所有方法
操作函数getDeclaredMethods() 不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。 Method[]
获得所有属性 getDeclaredFields()不论 public 或private 或其它access level，皆可获得。另有功能近似之取得函数。 Field[]
Reflection APIs 的全部。

三、反射步骤
关键---获得Class对象
有如下多种渠道

Class object 诞生渠道 示例
运用getClass()
注：每个class 都有此函数 String str = "abc";
Class c1 = str.getClass();
运用取得父类
Class.getSuperclass()2 Button b = new Button();
Class c1 = b.getClass();
Class c2 = c1.getSuperclass();
运用static method
Class.forName()
（最常被使用） Class c1 = Class.forName ("java.lang.String");
Class c2 = Class.forName ("java.awt.Button");
Class c3 = Class.forName ("java.util.LinkedList$Entry");

运用
.class 语法 Class c1 = String.class;
Class c2 = java.awt.Button.class;
Class c3 = Main.InnerClass.class;
Class c4 = int.class;
Class c5 = int[].class;
运用
primitive wrapper classes
的TYPE 语法 Class c1 = Boolean.TYPE;
Class c2 = Byte.TYPE;
Class c3 = Character.TYPE;
Class c4 = Short.TYPE;
Class c5 = Integer.TYPE;
Class c6 = Long.TYPE;
Class c7 = Float.TYPE;
Class c8 = Double.TYPE;
Class c9 = Void.TYPE;
图2：Java 允许多种渠道Class object。

四、实例：
(一) 找出类的所有方法：
import java.lang.reflect.*;
public class method1 {
    private int f1(Object p, int x) throws NullPointerException {
        if (p == null)
            throw new NullPointerException();
        return x;
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("method1");
            Method methlist[] = cls.getDeclaredMethods();
            for (int i = 0; i < methlist.length; i++) {
                Method m = methlist[i];
                System.out.println("name = " + m.getName());
                System.out.println("decl class = " + m.getDeclaringClass());
                Class pvec[] = m.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println("param #" + j + " " + pvec[j]);
                Class evec[] = m.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j + " " + evec[j]);
                System.out.println("return type = " + m.getReturnType());
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}
(二) 找出类的构造方法：
import java.lang.reflect.*;
public class constructor1 {
    public constructor1() {
    }
    protected constructor1(int i, double d) {
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("constructor1");
            Constructor ctorlist[] = cls.getDeclaredConstructors();
            for (int i = 0; i < ctorlist.length; i++) {
                Constructor ct = ctorlist[i];
                System.out.println("name = " + ct.getName());
                System.out.println("decl class = " + ct.getDeclaringClass());
                Class pvec[] = ct.getParameterTypes();
                for (int j = 0; j < pvec.length; j++)
                    System.out.println("param #" + j + " " + pvec[j]);
                Class evec[] = ct.getExceptionTypes();
                for (int j = 0; j < evec.length; j++)
                    System.out.println("exc #" + j + " " + evec[j]);
                System.out.println("-----");
            }
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}
(三) 执行找出的方法：
import java.lang.reflect.*;
public class method2 {
    public int add(int a, int b) {
        return a + b;
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("method2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Method meth = cls.getMethod("add", partypes);
            method2 methobj = new method2();
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = meth.invoke(methobj, arglist);
            Integer retval = (Integer) retobj;
            System.out.println(retval.intValue());
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}
(四) 创建新对象：
import java.lang.reflect.*;
public class constructor2 {
    public constructor2() {
    }
    public constructor2(int a, int b) {
        System.out.println("a = " + a + " b = " + b);
    }
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("constructor2");
            Class partypes[] = new Class[2];
            partypes[0] = Integer.TYPE;
            partypes[1] = Integer.TYPE;
            Constructor ct = cls.getConstructor(partypes);
            Object arglist[] = new Object[2];
            arglist[0] = new Integer(37);
            arglist[1] = new Integer(47);
            Object retobj = ct.newInstance(arglist);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}
(五) 改变属性值：
import java.lang.reflect.*;
public class field2 {
    public double d;
    public static void main(String args[]) {
        try {
            Class cls = Class.forName("field2");
            Field fld = cls.getField("d");
            field2 f2obj = new field2();
            System.out.println("d = " + f2obj.d);
            fld.setDouble(f2obj, 12.34);
            System.out.println("d = " + f2obj.d);
        } catch (Throwable e) {
            System.err.println(e);
        }
    }
}