Java中的反射

一，反射是什么

　　Java反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象， 都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为Java语言的反射机制。

　　“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C# 不是动态语言。但是Java有着一个非常突出的动态相关机制：Reflection，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完 全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对 象实体、或对其fields设值、或唤起其methods。

二， 反射能干什么

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

　　• 在运行时构造任意一个类的对象

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

　　• 在运行时调用任意一个对象的方法

三，包含类型信息的类-Class

1，如何获得Class对象

　　在程序运行时，系统始终为所有的对象维护一个被称为运行时的类型标识，它保存着每个对象所属的类足迹，虚拟机利用运行时信息选择相应的方法执行。保存这些信息的类被称为Class，有三种方法获得Class对象

　　a，使用Object.getClass方法，该方法返回一个Class类型的实例。

　　b，使用静态方法forName获得类名对应的Class对象，需要注意的是该方法会抛出一个异常，需要对其进行捕获。

String className = "java.util.Date";
Class cl = Class.forName(className);　　

　　c，若T是任意的Java类型，T.class返回一个匹配的Class对象。

Class cl1 = Date.class;
Class cl2 = int.class;
Class cl3 = Double[].class;

　　虚拟机为每一个类型管理一个Class对象，可以利用==操作符比较不同的Class对象是否相等。

2，Class类的重要API

　　静态方法forName以类名作为参数，返回一个Class对象

　　getFields，getMethods和getConstructors分别返回类提供的public域，方法和构造器数组，其中包括超类的成员。

　　getDeclareFields，getDeclareMethods和getDeclareConstructors分别返回类中声明的全部域，方法和构造器，包括私有和保护成员，但是不包括超类的成员。

四， 利用反射分析类
1，核心类概述

　　java.lang.reflect中有三个类Field，Method和Constructor分别用于描述类的域，方法和构造器。

　　三个类都有getName方法返回条目的名称，都有getModifiers方法返回一个整型数值表示public和static修饰符的使用状况。对于返回的整型值，可以调用java.lang.reflect.Modifier类的静态方法，比如isPublic，isPrivate或isFinal等进行判断，还可以使用Modifier.toString将修饰符打印出来。

　　Field类有一个getType方法用来返回描述域所属类型的Class对象。

　　Method具有能够报告参数和返回类型的方法。

　　Constructor具有能够报告参数类型的方法。

2，使用步骤

　　a，使用第三点中的任意一种方法获得Class对象。

　　b，通过Class对象调用getDeclareFields获得域数组，Method和Constructor与之类似。

　　c，遍历该数组，解析出修饰符，参数类型，返回类型等信息。

3，示例

import java.lang.*;
import java.lang.reflect.*;
import java.util.*;

public class test
{
    public static void main(String[] args)
    {
        String className = "java.lang.Double";
/*
        if(args.length == 0)
        {
            Scanner in = new Scanner(System.in);
            className = in.next();
        }
        else
        {
            className = args[0]; }
*/
        try
        {
            Class cl = Class.forName(className);
            String modifiers = Modifier.toString(cl.getModifiers());
            System.out.printf(modifiers);
            System.out.printf(" class " + className);
            System.out.println();
            System.out.println("{");
            printFields(cl);
            System.out.println();
            printConstructors(cl);
            System.out.println();
            printMethods(cl);
            System.out.println();
            System.out.println("}");
        }
        catch(ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }
    public static void printFields(Class cl)
    {
        Field[] fields = cl.getDeclaredFields();
        for(Field field: fields)
        {   
            String modifiers = Modifier.toString(field.getModifiers());
            System.out.println("    " + modifiers + " " +
                (field.getType()).getName() + " " + field.getName() + ";");
        }
    }
    public static void printMethods(Class cl)
    {
        Method[] methods = cl.getDeclaredMethods();
        for(Method method: methods)
        {
            String modifiers = Modifier.toString(method.getModifiers());
            System.out.printf(" " + modifiers + " " + method.getReturnType().getName()
                + " " + method.getName() + "(");
            Class[] paraTypes = method.getParameterTypes();
            for(int i = 0; i < paraTypes.length; ++i)
            {
                if(i > 0)
                    System.out.printf(", ");
                System.out.printf(paraTypes[i].getName());
            }
            System.out.println(");");
            //System.out.println(method.toString());
        }
    }
    public static void printConstructors(Class cl)
    {
        Constructor[] constructors = cl.getDeclaredConstructors();
        for(Constructor constructor: constructors)
        {
            String modifiers = Modifier.toString(constructor.getModifiers());
            System.out.printf(" " + modifiers + " " + constructor.getName()
                + " " + "(");
            Class[] paraTypes = constructor.getParameterTypes();
            for(int i = 0; i < paraTypes.length; ++i)
            {
                if(i > 0)
                    System.out.printf(", ");
                System.out.printf(paraTypes[i].getName());
            }
            System.out.println(");");
        }
    }
}

输出结果为：

public final class java.lang.Double
{
    public static final double POSITIVE_INFINITY;
    public static final double NEGATIVE_INFINITY;
    public static final double NaN;
    public static final double MAX_VALUE;
    public static final double MIN_NORMAL;
    public static final double MIN_VALUE;
    public static final int MAX_EXPONENT;
    public static final int MIN_EXPONENT;
    public static final int SIZE;
    public static final int BYTES;
    public static final java.lang.Class TYPE;
    private final double value;
    private static final long serialVersionUID;

    public java.lang.Double (double);
    public java.lang.Double (java.lang.String);

    public boolean equals(java.lang.Object);
    public static java.lang.String toString(double);
    public java.lang.String toString();
    public int hashCode();
    public static int hashCode(double);
    public static double min(double, double);
    public static double max(double, double);
    public static native long doubleToRawLongBits(double);
    public static long doubleToLongBits(double);
    public static native double longBitsToDouble(long);
    public volatile int compareTo(java.lang.Object);
    public int compareTo(java.lang.Double);
    public byte byteValue();
    public short shortValue();
    public int intValue();
    public long longValue();
    public float floatValue();
    public double doubleValue();
    public static java.lang.Double valueOf(java.lang.String);
    public static java.lang.Double valueOf(double);
    public static java.lang.String toHexString(double);
    public static int compare(double, double);
    public static boolean isNaN(double);
    public boolean isNaN();
    public static boolean isInfinite(double);
    public boolean isInfinite();
    public static boolean isFinite(double);
    public static double sum(double, double);
    public static double parseDouble(java.lang.String);

}