30.1 Java进阶之反射概念，反射作用，Class类，程序运行时分析类的能力

注意：本博客总结自《Java核心技术卷Ⅰ》

1. 反射的概念

1.1 什么是反射？

在java核心技术中的定义是：使用反射机制编写的程序是能够分析类能力的程序。
Java反射的内容主要在java.lang.reflect包中。

1.2 我们可以用反射机制来做什么？（4点）

• 在程序运行时分析类的能力：查看类方法，属性
• 在程序运行时查看对象和操作对象：
  • 基于反射自由创建对象
  • 构建出无法直接访问的类
  • set或者get到无法访问的成员变量
  • 调用不可访问的方法
• 实现通用的数组操作代码，实现泛型数组操作代码
• 利用Method对象实现类似函数指针的功能

我们先了解上面反射机制能做什么，随着我们下面的学习，我们将逐步实现上面提到的点。
我们要注意的是使用反射的主要人员是开发工具的构造者，而不是应用程序员。这意味着反射对于工具级别的开发人员是非常重要的。

2.Class,Field,Method,Constructor,Modifier类学习

对上面的定义总感觉有些云里雾里的感觉，似懂非懂，下面我们以实例出发来理解反射。

2.1 Class类

2.1.1 如何获得Class对象

在程序运行期间，Java运行时系统始终为所有的对象保存了一个被称为运行时的类型标识信息，这个信息跟踪着每个对象所属的类，Java虚拟机就是根据这个类型标识信息选择要执行的方法。
我们可以通过专门的Java类来访问这些类型标识信息，Class类就是其中之一。(Class保存这些信息)
如何得到Class实例（三种方式）
有以下三种方式：

方式一：调用Object种的getClass()方法
public Class<?> createClass1(){
    Object o = new Object();
    return o.getClass();
}

方式二：调用不可变类Class中的静态方法forName()
public Class<?> createClass2() throws ClassNotFoundException {
    String className="java.util.Random";
    Class<?> cl = Class.forName(className);//这里的className的内容必须类名或接口名才有效
    return cl;
}

方式三：直接Class cl=T.class;
public Class<?> createClass3(){
    return Object.class;
}

测试之：

public static void main(String[] args) throws ClassNotFoundException {
    System.out.println(createClass1().getName());
    System.out.println(createClass2().getName());
    System.out.println(createClass3().getName());
}

2.1.2 虚拟机为每个类型管理一个唯一的Class对象

由于每个类拥有的Class对象是唯一的，所以我们可以利用==运算符实现两个Class对象的比较。
例如：e.getClass()==Employee.class 的结果，如果e是Employee实例，这个测试将通过，如果e是Employee某个子类的实例，则不通过，这与 instanceof 不同。
例如：

public static void equalsClassTest(){
    Class<?> oneClass = Object.class;
    Class<?> twoClass = Integer.class;
    Class<?> three = new Object().getClass();
    System.out.println(oneClass==twoClass);
    System.out.println(oneClass==three);
}

2.1.3 使用Class对象新建一个实例对象

public static void createInstance() throws InstantiationException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {
    Class cl = ArrayList.class;
    ArrayList one = (ArrayList) cl.newInstance();
    one.add(10);
    ArrayList two = (ArrayList) cl.getConstructor().newInstance();
    two.add(11);
    System.out.println(one);
    System.out.println(two);
}

反射库提供了一个非常丰富且精心设计的工具集，以便能够动态操纵Java代码的程序。

2.2 利用反射来分析类能力

如果我们想要用反射机制来分析类的能力，我们除了需要Class类之外，还需要：
Field,Method,Constructor,Modifier四个类

下面介绍这些类中的一些要用到的方法(先了解即可)：

2.2.1 Class 中常用方法学习

//返回一个包含Field对象的数组，这些对象记录了这个类或其父类的公有域。
Field[] getFields();

//返回包含Field对象的数组，这些对象记录了这个类的全部域。
Field[] getDeclaredFields();

//返回包含Method对象的数组，其包含所有的公有方法，包括父类的。
Method[] getMethods();

//返回包含Method对象的数组，其包含所有的方法，但不包括包括父类的。
Method[] getDeclareMethods();

//返回包含Constructor对象的数组，其中包含了Class对象所描述的所有公有构造方法。
Constructor[] getConstructors();

//返回包含Constructor对象的数组，其中包含了Class对象所描述的所有构造方法。
Constructor[] getDeclaredConstructors();

2.2.2 Field类

包含类的属性定义信息并提供相应的操作。
常用方法

//获得Field描述的字段的名称定义
public String getName()
//从对象obj中获取变量名称为Filed.getName()的值
public Object get(Object obj)  
//将对象obj中变量名称为Filed.getName()的值设置为指定值
public void set(Object obj, Object value)

使用实例

public static void getFiled() throws IllegalAccessException {
    Class<?> cl = ArrayList.class;
    ArrayList arrayList = new ArrayList();
    Field [] fields = cl.getDeclaredFields();
    AccessibleObject.setAccessible(fields,true);
    for(Field field:fields){
        System.out.println(field.getName()+":"+ field.get(arrayList));
        if(field.getName().equals("size")){
            System.out.println("修改size的值为12");
            field.set(arrayList,12);
            System.out.println("修改后的值"+field.getName()+":"+ field.get(arrayList));
        }

    }
}

2.2.3 Method类

包含类的方法定义信息，并提供相应的操作。
常用方法

//获得方法的名称
public String getName()
//获得方法参数的Class数组
public Class<?>[] getParameterTypes()
//获得方法返回类型Class
public Class<?> getReturnType()
//对对象obj执行名称为getName的方法
public Object invoke(Object obj, Object... args)

使用实例：

public static void MethodTest() throws InvocationTargetException, IllegalAccessException {
    Class<?> cl = ArrayList.class;
    ArrayList arrayList = new ArrayList();
    Method[] methods = cl.getDeclaredMethods();
    for(Method method:methods){
        System.out.println("方法名称"+method.getName());
        System.out.println("方法参数:");
        Class[] params = method.getParameterTypes();
        for(Class zl :params){
            System.out.print(zl.getName()+",");
        }
        System.out.println();
        System.out.print("返回参数：");
        System.out.println(method.getReturnType().getName());
        if(method.getName().equals("add")){
            if(params.length==1){
                System.out.println("执行add(E e)方法，向数组添加Test");
                method.invoke(arrayList,"Test");
                System.out.println("查询数组的第一个元素"+arrayList.get(0));
            }
        }
    }
}

2.2.4 Constructor类

包含类的构造器信息，并提供相应的操作。
常用方法

//获得方法的名称
public String getName()
//获得方法参数的Class数组
public Class<?>[] getParameterTypes()
//使用构造器创建对象
public T newInstance(Object ... initargs)

使用实例：

public static void constructorStudy() throws InvocationTargetException, InstantiationException, IllegalAccessException {
    Class<?> cl = ArrayList.class;
    ArrayList arrayList = null;
    Constructor[] constructors = cl.getConstructors();
    for(Constructor constructor:constructors){
        System.out.println("构造器名称："+constructor.getName());
        Class[] classes = constructor.getParameterTypes();
        System.out.println("构造器参数：");
        for(Class zl:classes){
            System.out.print(zl.getName()+" , ");
        }
        if(classes.length==0){
            System.out.println("使用ArrayList的无参构造方法创建对象");
            arrayList = (ArrayList) constructor.newInstance();
            arrayList.add("Test");
            System.out.println(arrayList);
        }
        System.out.println();
    }
}

2.2.5 Modifier类

可以通过此类获取类，属性，方法，构造器的访问修饰符
具体用法如下：

public static void modifierTest(){
    Class cl = ArrayList.class;
    System.out.println("该类的修饰符为："+Modifier.toString(cl.getModifiers()));
    Field[] fields = cl.getDeclaredFields();
    for(Field field:fields){
        System.out.println("属性 "+field.getName()+"的修饰符为："+Modifier.toString(field.getModifiers()));
    }
    Method[] methods = cl.getDeclaredMethods();
    for(Method method:methods){
        System.out.println("方法 "+method.getName()+"的修饰符为："+Modifier.toString(method.getModifiers()));
    }
    Constructor[] constructors = cl.getConstructors();
    for(Constructor constructor:constructors){
        System.out.println("构造器 "+constructor.getName()+"的修饰符为："+Modifier.toString(constructor.getModifiers()));
    }
}

2.2.6 综合Demo实例展示

下面是用上面的类来写的一个反射Demo
Demo的主要内容是在程序中分析java.util.Date类的能力。

完整代码如下：

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

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("Enter class name (e.g：java.util.Date): ");
            name = in.next();
        }
        try {
            Class cl = Class.forName(name);//得到此类的Class实例
            Class supercl = cl.getSuperclass();//得到其父类的Class对象

            /*返回cl修饰符的字符串表示
              int getModifiers();返回一个整数，描述调用对象的修饰符
              Modifier.toString(int modifiers);返回此修饰符的字符串表示
             */
            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.print("\n{\n");
            //打印cl的构造方法
            printConstructors(cl);
            System.out.println();
            //打印cl的其他方法
            printMethods(cl);
            System.out.println();
            //cl中的所有域
            printFields(cl);
            System.out.println("}");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        System.exit(0);
    }


    /**
     * 打印出参数cl中描述的构造器信息
     * @param cl
     */
    public static void printConstructors(Class cl) {
        //得到包含cl中的全部构造器的一个Constructor对象数组
        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[] getParameterTypes(); 返回一个Class对象数组，其中各个对象表示参数的类型
            Class[] paramTypes = c.getParameterTypes();
            for (int j = 0; j < paramTypes.length; j++) {
                if (j > 0) System.out.print(", ");
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

    /**
     * 打印出cl描述的类的方法信息
     * @param cl
     */
    public static void printMethods(Class cl) {
        //得到这个类中的全部方法数组
        Method[] methods = cl.getDeclaredMethods();

        for (Method m : methods) {
            Class retType = m.getReturnType();//返回一个用于表示返回类型的Class对象
            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; j < paramTypes.length; j++)
            {
                if (j > 0) System.out.print(", ");
                System.out.print(paramTypes[j].getName());
            }
            System.out.println(");");
        }
    }

    /**
     * 打印出cl描述的类的属性信息
     * @param cl
     */
    public static void printFields(Class cl){
        Field[] fields = cl.getDeclaredFields();//返回包含Field对象的数组，这些对象对应这个类的全部字段

        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 + ";");
        }
    }
}

3.项目代码地址

Java基础学习/src/main/java/Progress/exa30_1 · 严家豆/Study - 码云 - 开源中国 (gitee.com)