JAVA反射机制

JAVA反射机制

Class类

而class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时，将其加载进内存。

每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。注意：这里的Class类型是一个名叫Class的class。它长这样：

public final class Class {
    private Class() {}
}

以String类为例，当JVM加载String类时，它首先读取String.class文件到内存，然后，为String类创建一个Class实例并关联起来：

Class cls = new Class(String);

Class实例是JVM内部创建的，只有JVM能创建Class实例，自己的程序无法创建。所以，JVM持有的每个Class实例都指向一个数据类型（class或interface

由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，我们就可以通过这个Class实例获取到该实例对应的class的所有信息。

这种通过Class实例获取class信息的方法称为反射（Reflection）。

如何获取一个class的Class实例？有三个方法：

方法一：直接通过一个class的静态变量class获取：

Class cls = String.class;

方法二：如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取：

String s = "Hello";
Class cls = s.getClass();

方法三：如果知道一个class的完整类名，可以通过静态方法Class.forName()获取：

Class.forName是一个静态方法，同样可以用来加载类。该方法有两种形式：Class.forName(String name, boolean initialize, ClassLoader loader)和 Class.forName(String className)。第一种形式的参数 name表示的是类的全名；initialize表示是否初始化类；loader表示加载时使用的类加载器。第二种形式则相当于设置了参数 initialize的值为 true，loader的值为当前类的类加载器。

Class cls = Class.forName("java.lang.String");

Class实例可以用==比较两个实例

Class实例几个基本方法

方法	作用
getName()	获取类的全类名
getSimpleName()	获取源代码中给出“底层类”的简称
getPackage().getName()	获取包名
isInterface()	判断是不是接口
isEnum	判断是不是枚举
isArray()	判断是不是数组
isPrimitive()	判断是不是基本类型

可以用Class实例创建对应类型的实例

// 获取String的Class实例:
Class cls = String.class;
// 创建一个String实例:
String s = (String) cls.newInstance();

访问字段

Class类访问字段方法

Field getField(name)	根据字段名获取某个public的field（包括父类）
Field getDeclaredField(name)	根据字段名获取当前类的某个field（不包括父类）
Field[] getFields()	获取所有public的field（包括父类）
Field[] getDeclaredFields()	获取当前类的所有field（不包括父类）

Field对象的主要基本方法

方法	功能
Field.getName()	返回字段名称
Field.getType()	返回字段类型，也是一个Class实例，例如，String.class
Field.getModifiers()	回字段的修饰符，它是一个int，不同的bit表示不同的含义
Field.setAccessible(true)	设置属性操作。为属性赋值前需要设置可操作，破坏了封装性可以为私有字段赋值。（不管字段是不是public都允许访问）
Field.set(obj,obj)	为属性设置值，第一个参数为需要设置值的对象实体，第二个为参数
Field.get(obj)	获取属性值

如果要获取一个字段值顺序大概分为以下几部分
1、获取Class实例对象
2、获取Field实例对象的字段
3、用get（获取类的实例）方法获取

调用方法

我们已经能通过Class实例获取所有Field对象，同样的，可以通过Class实例获取所有Method信息。Class类提供了以下几个方法来获取Method：

方法	作用
Method getMethod(name, Class…)	获取某个public的Method（包括父类）
Method getDeclaredMethod(name, Class…)	获取当前类的某个Method（不包括父类）
Method[] getMethods()	获取所有public的Method（包括父类）
Method[] getDeclaredMethods()	获取当前类的所有Method（不包括父类）

一个Method对象包含一个方法的所有信息

方法	作用
getName()	返回方法名称
getReturnType()	返回方法返回值类型，也是一个Class实例，例如：String.class
getParameterTypes()	返回方法的参数类型，是一个Class数组，例如：{String.class, int.class}
getModifiers()	返回方法的修饰符，它是一个int，不同的bit表示不同的含义
Method.setAccessible(true)	设置属性操作。为属性赋值前需要设置可操作，破坏了封装性可以为私有字段赋值。（不管字段是不是public都允许访问）

调用方法

当我们获取到一个Method对象时，就可以对它进行调用。

String s = "Hello world";
String r = s.substring(6); // "world"

如果用反射来调用substring方法，需要以下代码：

public class Main {
    public static void main(String[] args) throws Exception {
        // String对象:
        String s = "Hello world";
        // 获取String substring(int)方法，参数为int:
        Method m = String.class.getMethod("substring", int.class);
        // 在s对象上调用该方法并获取结果:
        String r = (String) m.invoke(s, 6);
        // 打印调用结果:
        System.out.println(r);
    }
}

其中invoke（）方法为调用Method实例方法

调用构造方法

如果通过反射来创建新的实例，可以调用Class提供的newInstance()方法：

Person p = Person.class.newInstance();

调用Class.newInstance()的局限是，它只能调用该类的public无参数构造方法。如果构造方法带有参数，或者不是public，就无法直接通过Class.newInstance()来调用。

为了调用任意的构造方法，Java的反射API提供了Constructor对象，它包含一个构造方法的所有信息，可以创建一个实例。Constructor对象和Method非常类似，不同之处仅在于它是一个构造方法，并且，调用结果总是返回实例：

方法	作用
getConstructor(Class…)：	获取某个public的Constructor；
getDeclaredConstructor(Class…)	获取某个Constructor；
getConstructors()	获取所有public的Constructor；
getDeclaredConstructors()	获取所有Constructor。

获取继承关系

有了Class实例，我们就可以获取它的父类的Class

Class.getSuperclass（）；//获得父类的实例。

Object的父类为null，除Object，其他任何非接口的Class都有父类类型。

获取interface

getInterfaces（）只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型：

对interface类型的Class用getSupperclass()返回的是null，获取接口的父接口要用getInterfaces()：

继承关系
如果是两个Class实例，要判断一个向上转型是否成立，可以调用

ClassB.isAssignableFrom(ClassA)：//判断ClassA赋值给B，若A为B的子类则返回true。B为A的子类返回false。

动态代理

有一种方式是动态代码，我们仍然先定义了接口Hello，但是我们并不去编写实现类，而是直接通过JDK提供的一个Proxy.newProxyInstance()创建了一个Hello接口对象。这种没有实现类但是在运行期动态创建了一个接口对象的方式，我们称为动态代码。JDK提供的动态创建接口对象的方式，就叫动态代理。

public class Main {
    public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if (method.getName().equals("morning")) {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(
            Hello.class.getClassLoader(), // 传入ClassLoader
            new Class[] { Hello.class }, // 传入要实现的接口
            handler); // 传入处理调用方法的InvocationHandler
        hello.morning("Bob");
    }
}

interface Hello {
    void morning(String name);
}

在运行期动态创建一个interface实例的方法如下：

一、定义一个InvocationHandler实例，它负责实现接口的方法调用；
二、通过Proxy.newProxyInstance()创建 1、 interface实例，它需要3个参数：
2、使用的ClassLoader，通常就是接口类的ClassLoader；
3、需要实现的接口数组，至少需要传入一个接口进去；
三、用来处理接口方法调用的InvocationHandler实例。
将返回的Object强制转型为接口。