JAVA的反射机制==>用反射分析类的实现

反射的概念：能够分析具体类的能力的程序称为反射

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

反射机制的作用：

    1、在程序运行中分析类的能力
    2、在运行中查看对象

1、反射机制==>检查类的结构：

预备知识：java.lang.reflect包中有三个类Field、Method、Constructor分别用来描述类的域（属性/字段）、方法、构造器

1、用反射分析类的能力（代码实现）

package 反射机制;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Scanner;
/**
 * 利用反射分析类的能力
 */
public class ReflectionTest {

    public static void main(String[] args) {
        // 从命令行或参数读取用户输入
        String name;
        if(args.length>0) name=args[0];
        else{
            Scanner in=new Scanner(System.in);
            System.out.println("输入类名  （例如：java.util.Date）:");
            name=in.next();
        }

        try {
            //获取类名所对应的Class对象
            Class cl=Class.forName(name);
            Class supercl=cl.getSuperclass();
            //获取类修饰符
            String modifiers=Modifier.toString(cl.getModifiers());
            if(modifiers.length()>0)
                System.out.print(modifiers+" ");
            System.out.print("calss "+name);
            if(supercl!=null&&supercl!=Object.class)
                System.out.print(" extends "+supercl.getName());
            System.out.print("{\n");

            printConstructors(cl);
            System.out.println();
            printMethods(cl);
            System.out.println();
            printFields(cl);
            System.out.println("}");

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } 

    }

    /**
     * 输出所有的构造方法
     */
    public static void printConstructors(Class cl){
        //获取所有的构造方法对象
        Constructor[] constructors=cl.getDeclaredConstructors();
        for(Constructor c:constructors){
            String name=c.getName();
            System.out.print("  ");
            //返回一个整数，用不同的位描述public和static这样的修饰符使用状况
            int mod=c.getModifiers();
            //将修饰符打印出来
            String modifiers=Modifier.toString(mod);
            if(modifiers.length()>0)
                System.out.print(modifiers+' ');
            System.out.print(name+'(');

            //输出参数类型
            Class[] paramTypes=c.getParameterTypes();
            for(int j=0;jif(j>0)
                    System.out.print(", ");
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }
    /**
     * 输出类的所有方法
     * @param cl
     */
    public static void printMethods(Class cl){
        Method[] methods=cl.getDeclaredMethods();
        for(Method m:methods){
            Class retType=m.getReturnType();
            String name=m.getName();

            System.out.print("  ");
            //输出声明、返回类型、方法名
            String modifiers=Modifier.toString(m.getModifiers());
            if(modifiers.length()>0)
                System.out.print(modifiers+' ');
            System.out.print(retType.getName()+" "+name+"(");
            //输出参数类型
            Class[] paramTypes=m.getParameterTypes();
            for(int j=0;jif(j>0)
                    System.out.print(", ");
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }
    /**
     * 输出类的所有域（属性）
     * @param cl
     */
    public static void printFields(Class cl){
        Field[] fields=cl.getDeclaredFields();
        for(Field f:fields){
            //返回域所属类型的对象
            Class type=f.getType();
            String name=f.getName();
            System.out.print("  ");
            String modifiers=Modifier.toString(f.getModifiers());
            if(modifiers.length()>0)
                System.out.print(modifiers+' ');
            System.out.println(type.getName()+" "+name+";");
        }
    }
}

输出结果：

输入类名  （例如：java.util.Date）:
java.util.Date
public calss java.util.Date{
    public java.util.Date(int, int, int, int, int, int);
    public java.util.Date(java.lang.String);
    public java.util.Date();
    public java.util.Date(long);
    public java.util.Date(int, int, int);
    public java.util.Date(int, int, int, int, int);

    public boolean after(java.util.Date);
    public boolean before(java.util.Date);
    public boolean equals(java.lang.Object);
    public java.lang.String toString();
    public int hashCode();
    public java.lang.Object clone();
    public int compareTo(java.util.Date);
    public volatile int compareTo(java.lang.Object);
    private void readObject(java.io.ObjectInputStream);
    private void writeObject(java.io.ObjectOutputStream);
    private final sun.util.calendar.BaseCalendar$Date normalize(sun.util.calendar.BaseCalendar$Date);
    private final sun.util.calendar.BaseCalendar$Date normalize();
    public static long parse(java.lang.String);
    public int getDate();
    public static java.util.Date from(java.time.Instant);
    public long getTime();
    private static final java.lang.StringBuilder convertToAbbr(java.lang.StringBuilder, java.lang.String);
    private final sun.util.calendar.BaseCalendar$Date getCalendarDate();
    private static final sun.util.calendar.BaseCalendar getCalendarSystem(int);
    private static final sun.util.calendar.BaseCalendar getCalendarSystem(sun.util.calendar.BaseCalendar$Date);
    private static final sun.util.calendar.BaseCalendar getCalendarSystem(long);
    public int getDay();
    public int getHours();
    private static final synchronized sun.util.calendar.BaseCalendar getJulianCalendar();
    static final long getMillisOf(java.util.Date);
    public int getMinutes();
    public int getMonth();
    public int getSeconds();
    private final long getTimeImpl();
    public int getTimezoneOffset();
    public int getYear();
    public void setDate(int);
    public void setHours(int);
    public void setMinutes(int);
    public void setMonth(int);
    public void setSeconds(int);
    public void setYear(int);
    public java.lang.String toGMTString();
    public java.time.Instant toInstant();
    public java.lang.String toLocaleString();
    public void setTime(long);
    public static long UTC(int, int, int, int, int, int);

    private static final sun.util.calendar.BaseCalendar gcal;
    private static sun.util.calendar.BaseCalendar jcal;
    private transient long fastTime;
    private transient sun.util.calendar.BaseCalendar$Date cdate;
    private static int defaultCenturyStart;
    private static final long serialVersionUID;
    private static final [Ljava.lang.String; wtb;
    private static final [I ttb;
}

上述代码在运行过程中分别分析了一个类的构造器、方法、域