Java基础教程(26)--反射

一.类

  对于每一种类型的对象，Java虚拟机都会实例化一个java.lang.Class类的不可变实例。该实例提供了获取对象的运行时属性的方法，包括它的成员和类型信息。Class类还提供了创建新实例的方法。最重要的是，它是所有反射API的入口。下面介绍最常用的涉及到类的反射操作。

1.获取Class对象

对象.getClass()

  如果要从一个对象获取它的对应的Class对象，最简单的方法就是调用getClass()方法，这个方法继承自Object类，因此每个对象都可以调用这个方法：

import java.util.HashSet;
import java.util.Set;
import static reflect.ReflectDemo.E.A;

public class ReflectDemo {
    static enum E {A, B}
    public static void main(String[] args) {
        Class c1 = "foo".getClass();
        Class c2 = A.getClass();
        byte[] bytes = new byte[1024];
        Class c3 = bytes.getClass();
        Set<String> s = new HashSet<>();
        Class c4 = s.getClass();
    }
}

类名.class

  如果类型没有可用实例，可以通过“类名.class”来获取Class对象：

import java.util.Set;
import static reflect.ReflectDemo.E.A;

public class ReflectDemo {
    static enum E {A, B}
    public static void main(String[] args) {
        Class c1 = String.class;
        Class c2 = E.class;
        Class c3 = byte[].class;
        Class c4 = Set.class;
    }
}

  需要注意的是，当对基本数据类型的变量调用getClass()方法时，会产生编译错误，但是可以对基本数据类型使用“.class”，例如：

boolean b = true;
Class c1 = b.getClass();             //编译错误

Class c2 = boolean.class;

Class.forName()

  如果类的完全限定类名可用，则可以使用Class类的静态方法forName来获取Class实例，例如：

Class c = Class.forName("com.maconn.ReflectDemo");

  如果找不到完全限定类名对应的类型，则该方法会抛出一个ClassNotFound异常。此外，这种方式不能用于基本数据类型，下面的程序将会抛出异常：

try {
    Class c = Class.forName("int");
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

基本类型包装类的TYPE域

  每个基本数据类型以及void都有一个包装类，这些类都包含一个静态域TYPE，该域的值就是被包装的基本类型。例如：

Class c = Integer.TYPE;

2.获取类的信息

  一个类可能含有以下修饰元素：

• public、protected或private：控制类的访问权限
• abstract：限制类必须要被继承
• static：仅用于内部类。创建该类对象时，无需先创建外部类的实例。
• final：限制类不能被继承
• strictfp：限制该类内部所有浮点运算严格按照IEEE-754规范执行。
• 注解：为类提供一些额外的信息或标记。

注：strictfp 的意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运 行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个 类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确， 而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。（节选自《Java语言中关键字strictfp的用途》一文，原文链接https://blog.csdn.net/redv/article/details/326444）。

  下面通过一个程序来演示获取类信息的一些方法，该程序打印出了String类的各项信息：

import java.lang.annotation.Annotation;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;
import java.util.List;

import static java.lang.System.out;

public class ClassDeclarationSpy {
    public static void main(String[] args) {
        try {
            Class c = String.class;
            out.format("Class:%n  %s%n%n", c.getCanonicalName());
            out.format("Modifiers:%n  %s%n%n",
                    Modifier.toString(c.getModifiers()));

            out.format("Type Parameters:%n");
            TypeVariable[] tv = c.getTypeParameters();
            if (tv.length != 0) {
                out.format("  ");
                for (TypeVariable t : tv)
                    out.format("%s ", t.getName());
                out.format("%n%n");
            } else {
                out.format("  -- No Type Parameters --%n%n");
            }

            out.format("Implemented Interfaces:%n");
            Type[] intfs = c.getGenericInterfaces();
            if (intfs.length != 0) {
                for (Type intf : intfs)
                    out.format("  %s%n", intf.toString());
                out.format("%n");
            } else {
                out.format("  -- No Implemented Interfaces --%n%n");
            }

            out.format("Inheritance Path:%n");
            List<Class> l = new ArrayList<Class>();
            printAncestor(c, l);
            if (l.size() != 0) {
                for (Class<?> cl : l)
                    out.format("  %s%n", cl.getCanonicalName());
                out.format("%n");
            } else {
                out.format("  -- No Super Classes --%n%n");
            }

            out.format("Annotations:%n");
            Annotation[] ann = c.getAnnotations();
            if (ann.length != 0) {
                for (Annotation a : ann)
                    out.format("  %s%n", a.toString());
                out.format("%n");
            } else {
                out.format("  -- No Annotations --%n%n");
            }
        } catch (ClassNotFoundException x) {
            x.printStackTrace();
        }
    }

    private static void printAncestor(Class<?> c, List<Class> l) {
        Class<?> ancestor = c.getSuperclass();
        if (ancestor != null) {
            l.add(ancestor);
            printAncestor(ancestor, l);
        }
    }
}

  下面是该程序的输出：

Class:
  java.lang.String

Modifiers:
  public final

Type Parameters:
  -- No Type Parameters --

Implemented Interfaces:
  interface java.io.Serializable
  java.lang.Comparable<java.lang.String>
  interface java.lang.CharSequence
  interface java.lang.constant.Constable
  interface java.lang.constant.ConstantDesc

Inheritance Path:
  java.lang.Object

Annotations:
  -- No Annotations --

  需要注意的是，并非所有的注解都可以通过反射获得。只有那些使用了元注解@Retention{RetentionPolicy.RUNTIME}的注解才会保留到运行时。

3.发现成员

  可以通过获得的class对象来进一步获取类的成员，例如成员变量、成员方法和构造器。下面依次介绍获取这些成员的方法。

获取域

方法	描述	继承的成员	私有的成员
getDeclaredField​(String name)	根据名称获取该类声明的成员变量	不包含	包含
getDeclaredFields()	获取该类声明的所有成员变量	不包含	包含
getField(String name)	根据名称获取成员变量	包含	不包含
getFields()	获取所有的成员变量	包含	不包含

获取方法

方法	描述	继承的成员	私有的成员
getDeclaredMethod​(String name, Class<?>... parameterTypes)	根据名称和参数类型获取该类声明的方法	不包含	包含
getDeclaredMethods()	获取该类声明的所有方法	不包含	包含
getMethod​(String name, Class<?>... parameterTypes)	根据名称和参数类型获取成员方法	包含	不包含
getMethod​s()	获取所有的成员方法	包含	不包含

获取构造器

方法	描述	私有的成员
getDeclaredConstructor​(Class<?>... parameterTypes)	根据参数类型获取指定的构造器	包含
getDeclaredConstructors()	获取所有的构造器	包含
getConstructor​(Class<?>... parameterTypes)	根据参数类型获取指定的构造器	不包含
getConstructors()	获取所有的构造器	不包含

二.成员

  反射API中定义了一个表示成员的接口Member，Field、Method和Constructor类都实现了这个接口。在上一节中已经对获取这三种成员的方法进行了简单的了解，本节将会对三种成员的方法进行介绍。

1.域

  在反射API中，使用Field类来表示对象的域。上文中已经介绍了如何通过Class对象来获取Field对象，现在我们来讨论有关Field类的内容。

获取域的类型

  通过Field类的getType和getGenericType可以获取当前域的类型。不同的是，getType方法返回的是Class对象，而getGenericType返回的则是Type类型的对象。此外，如果某个域是泛型类型的，getType方法不能准确地返回该域的类型，而getGenericType则可以返回该域的泛型类型。

Type是java.lang.reflect包中的一个接口，该接口表示所有类型的高级公共接口，Class类就是Type接口的一个实现类。Type包括原始类型、参数化类型、数组类型、类型变量和基本类型。

  下面的例子依次打印出了对每个域调用getType和getGenericType的结果：

import java.lang.reflect.Field;
import java.util.List;

public class FieldSpy<T> {
    public String name  = "Alice";
    public List<Integer> list;
    public T val;

    public static void main(String... args) {
        try {
            Class<?> c = FieldSpy.class;
            Field f1 = c.getField("name");
            System.out.println("Field name:");
            System.out.format("Type: %s%n", f1.getType());
            System.out.format("GenericType: %s%n", f1.getGenericType());
            Field f2 = c.getField("list");
            System.out.println("Field list:");
            System.out.format("Type: %s%n", f2.getType());
            System.out.format("GenericType: %s%n", f2.getGenericType());
            Field f3 = c.getField("val");
            System.out.println("Field val:");
            System.out.format("Type: %s%n", f3.getType());
            System.out.format("GenericType: %s%n", f3.getGenericType());
        } catch (NoSuchFieldException x) {
            x.printStackTrace();
        }
    }
}

  上面的程序会产生以下输出：

Field name:
Type: class java.lang.String
GenericType: class java.lang.String
Field list:
Type: interface java.util.List
GenericType: java.util.List<java.lang.Integer>
Field val:
Type: class java.lang.Object
GenericType: T

  val域的类型是Object，这是因为编译器会在编译期间擦除有关泛型类型的所有信息。在这种情况下，将会使用类型变量的上界代替，在这个例子中，就是Object。

获取值

  可以获取当前Field所表示的域在指定对象的上的值。若该域是引用类型，则使用get(Object obj)方法，该方法会返回一个Object对象；若该域是基本数据类型，则可以使用getXxx(Object obj)方法，Xxx为Boolean、Byte、Char、Double、Float、Int、Long、Short中的一种。

  下面的程序分别获取了foo和bar域的值：

import java.lang.reflect.Field;

public class FieldDemo {
    private String foo;
    private int bar;

    public FieldDemo(String stringField, int intField) {
        this.foo = stringField;
        this.bar = intField;
    }

    public static void main(String[] args) {
        Class<?> c = FieldDemo.class;
        FieldDemo fieldDemo = new FieldDemo("foo", 1);
        try {
            Field stringField = c.getDeclaredField("foo");
            System.out.println(stringField.get(fieldDemo));
            Field intField = c.getDeclaredField("bar");
            System.out.println(intField.getInt(fieldDemo));
        } catch (NoSuchFieldException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

  也可以为指定对象的域设置值。若该域是引用类型，则使用set(Object obj, Object value)方法；若该域是基本数据类型，则可以使用getXxx(Object obj, Xxx value)方法，Xxx为Boolean、Byte、Char、Double、Float、Int、Long、Short中的一种。例如，可以通过下面的代码为上面的foo域和bar域设置值：

Field stringField = c.getDeclaredField("foo");
stringField.set(c, "fool");
Field intField = c.getDeclaredField("bar");
intField.set(c, 2);

获取其他信息

• <T extends Annotation> T getAnnotation​(Class<T> annotationClass)
  
  返回该域上指定类型的注解。
• <T extends Annotation> T[] getAnnotationsByType​(Class<T> annotationClass)
  
  返回指定类型的注解，用数组返回。该方法可用于获取重复注解。
• Class<?> getDeclaringClass()
  
  返回声明该域的类。
• int getModifiers()
  
  用一个整数返回该域的修饰符。该整数需要使用Modifier类来解码。
• String getName()
  
  返回该域的名称。
• boolean isSynthetic()
  
  若该域是编译器自动生成的则返回true，否则返回false。

2.方法

  在反射API中，使用Method类来表示方法。下面是对Method类中一些常见方法的介绍。

获取方法的信息

• <T extends Annotation> T getAnnotation​(Class<T> annotationClass)
  
  返回作用于该方法的指定类型的注解。
• Annotation[] getDeclaredAnnotations()
  
  返回直接出现在该方法上的注解。
• Class<?> getDeclaringClass()
  
  返回声明该方法的类。
• Type[] getGenericExceptionTypes()
  
  返回该方法抛出的异常
• Type[] getGenericParameterTypes()
  
  返回该方法的参数类型。
• Class<?> getReturnType()
  
  返回该方法的返回值类型。
• Type getGenericReturnType()
  
  返回该方法的返回值类型。不能准确地返回使用了泛型的返回值类型。
• String getName()
  
  返回方法名称。

调用方法

  通过Method类的invoke方法可以对指定对象调用方法。下面是invoke方法的签名：

    Object invoke​(Object obj, Object... args)

  第一个参数是要调用方法的对象，后面的可变参数则是该方法需要接收的参数。下面的程序获取了一个方法并调用了它：

import java.lang.reflect.Method;

public class MethodInvokeDemo {
    public static void main(String[] args) {
        try {
            Method method = Foo.class.getMethod("bar", int.class, int.class);
            Foo foo = new Foo();
            method.invoke(foo, 1, 2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Foo {
    public void bar(int a, int b) {
        System.out.println(a + b);
    }
}

3.构造器

  在反射API中，使用Constructor类来表示构造器。因为Constructor类中的大部分方法都和Method类相似，此处不再赘述。这里主要讲述如何通过Constructor类来构造类的实例。

  Constructor类的newInstance​(Object... initargs)方法可以用于创建新的实例。实际上，Class类也有一个newInstance方法，但是推荐使用Constructor类的newInstance方法来创建实例，而后者已经被标记为Deprecated，不建议使用，这是因为：

• Class.newInstance()只能调用类的无参构造器，而Constructor.newInstance​(Object... initargs)可以调用类的任何构造器。
• Class.newInstance()要求构造函数必须可见，而在某些情况下Constructor.newInstance()可以调用private构造函数。

  下面的程序通过Constructor类的newInstance创建了Person类的一个实例：

import java.lang.reflect.Constructor;

public class NewInstanceDemo {
    public static void main(String[] args) {
        Class<Person> c = Person.class;
        try {
            Constructor<Person> constructor = c.getConstructor(String.class, int.class);
            Person p = constructor.newInstance("foo", 26);
            System.out.println(p);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{name=" + name + ", age=" + age + "}";
    }
}

  对于Field、Method和Constructor所表示的成员来说，如果当前所在的类没有对这些成员的访问权限，那么也无法通过反射去访问这些成员。这种情况下，需要手动调用这些成员的setAccessible(boolean flag)方法将flag设置为true才能继续访问。

三.数组和枚举

1.数组

  数组是对一组固定数量的、相同类型的元素的引用，这些元素的类型可以是基本数据类型，也可以是引用类型。反射API中提供了访问数组类型，创建新数组，获取和设置元素的值的方法。

识别数组

  如果我们对数组引用调用.getClass()方法，会返回什么？下面来做一个实验：

public class ArrayDemo {
    public static void main(String[] args) {
        byte[] b = {1, 2, 3};
        Integer[] i = {4, 5, 6};
        String[] s = {"Hello", "World"};
        System.out.println(b.getClass());
        System.out.println(i.getClass());
        System.out.println(s.getClass());
    }
}

  上面的程序将会输出：

class [B
class [Ljava.lang.Integer;
class [Ljava.lang.String;

  与一般的类不同的是，数组的类型前面都会加上左方括号（[）。如果是二维数组，则会有两个左方括号，依次类推。如果是基本数据类型的数组，方括号右边只有一个大写字母，这个字母就是对应的基本类型的首字母。如果是引用类型，方括号右边是一个大写字母L然后加上数组元素的完全限定类名，以及最后的分号。

  虽然可以根据getClass()返回的结果来判断一个对象是不是数组，但是这样并不直观。Class类提供了一个isArray()方法，通过这个方法可以直接判断某个对象是不是数组类型。

创建数组

  反射API中使用Array类来表示数组。通过这个类的newInstance​(Class<?> componentType, int length)方法可以快速创建一个数组：

public static Object createArray(Class<?> c, int length) {
    return Array.newInstance(c, length);
}

  上面的方法根据指定的类型和长度创建了一个数组并返回了对数组的引用，调用者需要将其强制转换为真正类型的数组来使用，例如Integer[]。

获取和设置值

  Array类提供了许多get和set方法。其中get(Object array, int index)用来从引用类型的数组中获取值，而getXxx(Object array, int index)则用于从基本数据类型的数组中获取值；set(Object array, int index, Object value)用来给引用类型的数组赋值，而setXxx(Object array, int index, Object value)则用于给基本数据类型的数组赋值。下面是一个例子：

public class ArrayAssignmentDemo {
    public static void main(String[] args) {
        int[] i = new int[2];
        String[] s = new String[2];
        Array.setInt(i, 0, 1);
        Array.set(s, 0, "Hello");
        System.out.println(Array.getInt(i, 0));
        System.out.println(Array.get(s, 0));
    }
}

2.枚举

  反射API中提供了以下几个枚举专用的方法：

• Class.isEnum()
  
  若该类是枚举类型，则返回true。
• Class.getEnumConstants()
  
  按照声明的顺序返回枚举类型中的所有枚举常量。
• java.lang.reflect.Field.isEnumConstant()
  
  若该域是枚举类型，则返回true。