对于一般的开发者，很少需要直接使用Java反射机制来完成功能开发，但是反射是很多框架譬如 Spring， Mybatis 实现的核心，反射虽小，能量却很大。

本文主要介绍反射相关的概念以及API的使用，关于反射的应用将在下一篇文章中介绍

反射(Reflection) 是 Java 在运行时（Run time）可以访问、检测和修改它本身状态或行为的一种能力，它允许运行中的 Java 程序获取自身的信息，并且可以操作类或对象的内部属性。

Class 类介绍：Java虚拟机为每个类型管理一个Class对象，包含了与类有关的信息，当通过 javac 编译Java类文件时，生成的同名 .class 文件保存着该类的 Class 对象，JVM 加载一个类即是加载该 .class 文件。

Class 和 java.lang.reflect 一起对反射提供了支持，java.lang.reflect 包中最常用的几个类的关系如下：

其中最主要的三个类 Field、Method 和 Constructor 分别用于描述类的域、方法和构造器，它们有一个共同的父类 AccessibleObject，它提供了访问控制检查的功能。

• Field ：描述类的域（属性），可以使用 get() 和 set() 方法读取和修改 Field 对象关联的字段；
• Method ：描述类的方法，可以使用 invoke() 方法调用与 Method 对象关联的方法；
• Constructor ：描述类的构造器，可以用 Constructor 创建新的对象。

下面将通过几个程序来学习Java反射机制。

我们特别定义两个类，Person和Employee，其中Employee继承自Person，且各自都有一个private，protected，public修饰的域（属性），Employee还有private，public修饰的方法

public class Person {
    public String name; // 姓名 公有
    protected String age;   // 年龄 保护
    private String hobby;   // 爱好   私有
public Person(String name,String age,String hobby) {
    this.name = name;
    this.age = age;
    this.hobby = hobby;
}
public String getHobby() {
    return hobby;
}
}
public class Employee extends Person {

public static Integer totalNum = 0; // 员工数

public int empNo;   // 员工编号 公有

protected String position;  // 职位 保护

private int salary; // 工资   私有
public void sayHello() {
    System.out.println(String.format("Hello,我是 %s,今年 %s 岁,爱好是%s,我目前的工作是%s,月入%s元\n",name,age,getHobby(),position,salary));
}
private void work() {
    System.out.println(String.format("My name is %s,工作中勿扰.",name));
}
public Employee(String name,String hobby,int empNo,String position,int salary) {
    super(name,hobby);
    this.empNo = empNo;
    this.position = position;
    this.salary = salary;
    Employee.totalNum++;
}
}

<h3 id="获取-class-对象">获取 Class 对象

获取 Class 对象的方式有三种：使用 Class 类的 forName 静态方法；直接获取某一个对象的 class；调用某个对象的 getClass() 方法

public class ClassTest {
    public static void main(String[] args) throws ClassNotFoundException,IllegalAccessException,InstantiationException {
        Class c1 = Class.forName("reflect.Employee");   // 第1种，forName 方式获取Class对象
        Class c2 = Employee.class;      // 第2种，直接通过类获取Class对象
        Employee employee = new Employee("小明","18","写代码",1,"Java攻城狮",100000);
        Class c3 = employee.getClass();    // 第3种，通过调用对象的getClass()方法获取Class对象
    if (c1 == c2 && c1 == c3) {     // 可以通过 == 比较Class对象是否为同一个对象
        System.out.println("c1、c2、c3 为同一个对象");
        System.out.println(c1);     // class reflect.Employee
    }
}
}

通过反射来生成对象主要有两种方式

• 使用Class对象的newInstance()方法来创建Class对象对应类的实例
• 先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建实例

public class NewInstanceTest {
    public static void main(String[] args) throws IllegalAccessException,InstantiationException,NoSuchMethodException,InvocationTargetException {
        Class c = Date.class;
        Date date1 = (Date) c.newInstance();    // 第1种方式：使用Class对象的newInstance()方法来创建Class对象对应类的实例
        System.out.println(date1);      // Wed Dec 19 22:57:16 CST 2018
    long timestamp =date1.getTime();
    Constructor constructor = c.getConstructor(long.class); 
    Date date2 = (Date)constructor.newInstance(timestamp);  // 第2种方式：先通过Class对象<a href="https://www.jb51.cc/tag/huoqu/" target="_blank" class="keywords">获取</a>指定的Constructor对象，再<a href="https://www.jb51.cc/tag/diaoyong/" target="_blank" class="keywords">调用</a>Constructor对象的newInstance()<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>来创建实例
    System.out.println(date2);  // Wed Dec 19 22:57:16 CST 2018
}
}

上面我们定义了两个类，现在有个需求：获取Employee的类名，构造器签名，所有的方法，所有的域（属性）和值，然后打印出来。该通过什么方式来实现呢？

没错，猜对了，就是通过反射来获取这些类的信息，在上面介绍中我们知道JVM虚拟机为每个类型管理一个Class对象，

为了完成我们的需求，我们需要知道一些API如下：

获取类信息的部分api">获取类信息的部分API

String getName() 获取这个Class的类名

Constructor[] getDeclaredConstructors() 返回这个类的所有构造器的对象数组，包含保护和私有的构造器；相近的方法 getConstructors() 则返回这个类的所有公有构造器的对象数组，不包含保护和私有的构造器

Method[] getDeclaredMethods() 返回这个类或接口的所有方法，包括保护和私有的方法，不包括超类的方法；相近的方法 getMethods() 则返回这个类及其超类的公有方法的对象数组，不含保护和私有的方法

Field[] getDeclaredFields() 返回这个类的所有域的对象数组，包括保护域和私有域，不包括超类的域；还有一个相近的API getFields()，返回这个类及其超类的公有域的对象数组，不含保护域和私有域

int getModifiers() 返回一个用于描述Field、Method和Constructor的修饰符的整形数值，该数值代表的含义可通过Modifier这个类分析

Modifier 类 它提供了有关Field、Method和Constructor等的访问修饰符的信息，主要的方法有：toString(int modifiers)返回整形数值modifiers代表的修饰符的字符串；isAbstract是否被abstract修饰；isVolatile是否被volatile修饰；isPrivate是否为private；isProtected是否为protected；isPublic是否为public；isStatic是否为static修饰；等等，见名知义

public class ReflectionTest {
    public static void main(String[] args) throws ClassNotFoundException {
        String name;
        if (args.length > 0) {
            name = args[0];
        } else {
            Scanner in = new Scanner(System.in);
            System.out.println("输入一个类名（e.g. java.util.Date）："); // reflect.Employee
            name = in.next();
        }
        try {
            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("class " + name);
            if (superCl != null && superCl != Object.class) {
                System.out.print(" extends " + superCl.getName());
            }
            System.out.println("\n{");
        printConstructors(cl); // 打印构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
        System.out.println();
        printMethods(cl);   // 打印<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
        System.out.println();
        printFields(cl);    // 打印<a href="https://www.jb51.cc/tag/shuxing/" target="_blank" class="keywords">属性</a>
        System.out.println("}");
    } catch (ClassNotFoundException e) {
        e.printStackTrace();
    }
    System.exit(0);
}

/**
 * 打印Class对象的所有构造<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
 */
public static void printConstructors(Class cl) {
    Constructor[] constructors = cl.getDeclaredConstructors();

    for (Constructor c : constructors) {
        String name = c.getName();
        System.out.print("  ");
        String modifiers = Modifier.toString(c.getModifiers());
        if (modifiers.length() > 0) {
            System.out.print(modifiers + " ");
        }
        System.out.print(name + "(");
        // 打印构造参数
        Class[] paramTypes = c.getParameterTypes();
        for (int i = 0; i < paramTypes.length; i++) {
            if (i > 0) {
                System.out.print(",");
            }
            System.out.print(paramTypes[i].getName());
        }
        System.out.println(");");
    }
}

/**
 * 打印Class的所有<a href="https://www.jb51.cc/tag/fangfa/" target="_blank" class="keywords">方法</a>
 */
public static void printMethods(Class cl) {
    Method[] methods = cl.getDeclaredMethods();
    //Method[] methods = cl.getMethods();
    for (Method m : methods) {
        Class retType = m.getReturnType();  // 返回类型
        System.out.print("  ");
        String modifiers = Modifier.toString(m.getModifiers());
        if (modifiers.length() > 0) {
            System.out.print(modifiers + " ");
        }
        System.out.print(retType.getName() + " " + m.getName() + "(");
        Class[] paramTypes = m.getParameterTypes();
        for (int i = 0; i < paramTypes.length; i++) {
            if (i > 0) {
                System.out.print(",");
            }
            System.out.print(paramTypes[i].getName());
        }
        System.out.println(");");
    }
}

/**
 * 打印Class的所有<a href="https://www.jb51.cc/tag/shuxing/" target="_blank" class="keywords">属性</a>
 */
public static void printFields(Class cl) {
    Field[] fields = cl.getDeclaredFields();
    for (Field f: fields) {
        Class type = f.getType();
        System.out.print("  ");
        String modifiers = Modifier.toString(f.getModifiers());
        if (modifiers.length()> 0) {
            System.out.print(modifiers + " ");
        }
        System.out.println(type.getName() + " " + f.getName() + ";");
    }
}
}

运行程序，然后在控制台输入一个我们想分析的类的全名，譬如 reflect.Employee，可得到下面的输出

输入一个类名（e.g. java.util.Date）：
reflect.Employee
public class reflect.Employee extends reflect.Person
{
  private reflect.Employee(java.lang.String,java.lang.String,java.lang.String);
  public reflect.Employee(java.lang.String,int,int);
public static void main([Ljava.lang.String;);

public void sayHello();

private void work();
public static java.lang.Integer totalNum;

public int empNo;

protected java.lang.String position;

private int salary;

}

上面的输出中我们得到的类的构造器，所有方法和所有的域（属性），包括修饰符，名称和参数类型都是准确的，看来反射机制能完成我们的需求。

小结一下，我们通过 getDeclaredConstructors() 获取构造器信息，通过 getDeclaredMethods() 获得方法信息，通过 getDeclaredFields() 获得域信息，再通过 getModifiers() 和 Modifier类 获得修饰符信息，汇总起来就得到了整个类的类信息。

内容">运行时查看对象数据域的实际内容

上面我们已经获取到了类的信息，现在又有一个需求：在运行时查看对象的数据域的实际值。这个场景就像我们通过IDEA调试程序，设置断点拦截到程序后，查看某个对象的属性的值。

我们知道java反射机制提供了查看类信息的API，那么它应该也提供了查看Field域实际值和设置Field域实际值的API，没错，猜对了，确实有相关的API，但是有个疑问，有一些属性是private修饰的私有域，这种是否也能直接查看和设置呢？看完下面的API即可知道答案

内容的相关api">运行时查看对象数据域实际内容的相关API

Class getComponentType() 返回数组类里组件类型的 Class，如果不是数组类则返回null

boolean isArray() 返回这个类是否为数组，同类型的API还有 isAnnotation、isAsciiDigit、isEnum、isInstance、isInterface、isLocalClass、isPrimitive 等

int Array.getLength(obj) 返回数组对象obj的长度

Object Array.get(obj,i) 获取数组对象下标为i的元素

boolean isPrimitive() 返回这个类是否为8种基本类型之一，即是否为boolean,byte,char,short,long,float,和double 等原始类型

Field getField(String name) 获取指定名称的域对象

AccessibleObject.setAccessible(fields,true) 当访问 Field、Method 和 Constructor 的时候Java会执行访问检查，如果访问者没有权限将抛出SecurityException，譬如访问者是无法访问private修饰的域的。通过设置 setAccessible(true) 可以取消Java的执行访问检查，这样访问者就获得了指定 Field、Method 或 Constructor 访问权限

Class Field.getType() 返回一个Class 对象，它标识了此 Field 对象所表示字段的声明类型

Object Field.get(Object obj) 获取obj对象上当前域对象表示的属性的实际值，获取到的是一个Object对象，实际使用中还需要转换成实际的类型，或者可以通过 getByte()、getChar、getInt() 等直接获取具体类型的值

void Field.set(Object obj,Object value) 设置obj对象上当前域表示的属性的实际值

内容程序">查看对象数据域实际内容程序

了解完上述相关API之后，我们敲出下面的程序来验证

public class ObjectAnalyzer {
    private ArrayList