在学习反射之前，我们先来学习一些基本知识。

RTTI

运行时类型识别(RTTI, Run-Time Type Identification)是Java中非常有用的机制，在Java运行时，RTTI维护类的相关信息。

为什么讲这个东西呢，因为我们今天的主题——反射，也是一种形式的 RTTI。可能有些同学对 RTTI 有些陌生，其实说白了，就是编译的时候不知道（或者不需要知道）类的详细，但是运行的时候需要具体执行代码。

这个概念有点抽象，我给大家举个例子，比如说我们的父类引用指向子类对象，然后调用了方法 a()，这个时候是由于 RTTI 来根据子类是否重写方法 a()来判断是执行子类的方法 a()，还是执行父类的方法 a()。

可能有同学会说上面这不就是动态绑定么，没错，就是动态绑定，但是这也属于 RTTI 机制。

再比如，向上转型、向下转型、instanceof 这些都属于RTTI，因为这些都牵涉到运行时类的识别。

而我们用到的反射也属于 RTTI 机制，但是和传统的 RTTI 又有一部分区别。

传统的 RTTI 有3种实现方式：

向上转型或向下转型，在 java 中，向下转型需要强制类型转换。
CLass 对象（用了 Class 对象，并且只是用 CLass 对象 cast 成指定的类）
instanceof

传统的 RTTI 与反射最主要的区别：
最主要的区别在于传统的 RTTI 在编译期需要.class文件，而反射不需要。

Class 类

Class 类又称“类的类”（Class of classes）。如果说类是对象的抽象和集合的话，那么 Class 类就是对类的抽象和集合。（认真理解这一句话）

每一个 Class 类的对象代表一个其他的类。比如下面程序中，Class 类的对象 c1代表了 Human 类，c2代表了 Woman 类。

public class ClassTest {

    public static void main(String[] args) {
        Human human = new Human();
        Class c1 = human.getClass();
        System.out.println(c1.getName());

        Human woman = new Woman();
        Class c2 = woman.getClass();
        System.out.println(c2.getName());

    }

}

class Human {

}

class Woman extends Human {

}

打印结果就不贴出来了~~

当我们在调用对象的 getClass 方法时，就得到对应 Class 对象的引用。

在 c2中，即使我们将 Women 对象的引用向上转换为 Human 对象的引用，对象所指向的 Class 类对象依然是 Woman。

Java 中每个对象都有相应的 Class 类对象，因此，我们随时能通过 Class 对象知道某个对象“真正”所属的类。无论我们对引用进行怎样的类型转换，对象本身所对应的 Class 对象都是同一个。当我们通过某个引用调用方法时，Java 总能找到正确的 Class 类中所定义的方法并且执行该 Class 类中的代码。由于 Class 对象的存在，Java 不会因为类型的向上转换而迷失。这就是多态的原理。

获取Class 类的三种方法

对象.getClass()
类名.class;
Class.forName()

Class 类的方法

Class 对象记录了相应类的信息，比如类的名字，类所在的包等等。

方法很多，具体方法可以去看 API 文档（在 java.lang包下），这里我介绍几个最常用的方法。

public String getName()获取类名
public String getPackage()获取包名
public Class getSuperclass()获取父类 class
public Fields[] getFields() 获取所有公共字段
public Methods[] getMethods()获取所有公共方法
public Annotation[] getAnnotations获取所有注解
public Class[] getClasses() 获取所有内部类（包含父类）
public Constructor[] getConstructors()获取所有公共构造方法
getDeclared***() 获取所有属性（包含非公共的）

Class类的加载

当Java创建某个类的对象，比如Human类对象时，Java会检查内存中是否有相应的Class对象。

如果内存中没有相应的Class对象，那么Java会在.class文件中寻找Human类的定义，并加载Human类的Class对象。

在Class对象加载成功后，其他Human对象的创建和相关操作都将参照该Class对象。

反射操作的相关类

上面我们看 Class 类的方法的时候返回了以下几个对象。

Constructor
Method
Field

接下来，我们来看看这几个类吧~

AccessibleObject

咦，这特么又是什么类，说好的Constructor、Method、Field 呢
别急。
AccessibleObject 是这三个对象的基类。它提供了将反射的对象标记为在使用时取消默认 Java 语言访问控制检查的能力。对于公共成员、默认（打包）访问成员、受保护成员和私有成员，在分别使用 Field、Method 或 Constructor 对象来设置或获取字段、调用方法，或者创建和初始化类的新实例的时候，会执行访问检查。

setAccessible(boolean flag)
flag 的值为 true 则指示反射的对象在使用时应该取消 Java 语言访问检查，也就是我们所说的暴力反射。不原理不过就是关闭了 Java 语言访问权限检查而已。
isAccessible()
获取是否需要检查访问权限。

Constructor

Constructor 提供了关于类的单个构造方法的信息。

方法名	介绍
getAnnotation(Classannotation)	如果存在该元素的指定类型的注解，则返回这个注解
getDeclaredAnnotations()	返回直接存在于此方法上的所有注解
getDeclaringClass()	返回 Class 对象，该对象为此构造方法构造的类
getExceptionTypes()	返回抛出的异常类的 class列表
getGenericExceptionTypes()	返回抛出的异常列表
getGenericParameterTypes()	方法参数类型列表
getModifiers()	以 int 型的方式返回访问权限
getName()	返回构造方法的名称
getParameterAnnotations()	返回方法参数的注解列表，由于一个参数可能有多个注解，所以是二维数组
isVarArgs()	是否带有可变数量参数
newInstance(Object... initargs)	使用此构造器创建一个实例。

Method

Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。

方法名	介绍
getAnnotation(Classannotation)
getDeclaredAnnotations()
getDeclaringClass()
getDefaultValue()	返回此 Method 实例表示的注释成员的默认值
getExceptionTypes()
getGenericExceptionTypes()
getGenericParameterTypes()
getModifiers
getName()
getParameterAnnotations()
isVarArgs()
invoke(Object obj, Object... args)	对带有指定参数的指定对象调用由此 Method 对象表示的底层方法

空白描述同 Constructor

Field

Field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段。

方法名	介绍
get(Object obj)	返回指定对象上此字段的值
getAnnotation(Classannotation)
getBoolean(Object obj)	获取一个静态或实例 boolean 字段的值
getByte(Object obj)	获取一个静态或实例 type 字段的值
getChar(Object obj)	获取 char 类型或另一个通过扩展转换可以转换为 char 类型的基本类型的静态或实例的值
getDeclaredAnnotation()
getDeclaringClass()
getDouble(Object obj)	同上
getFloat(Object obj)	同上
getGenericType()	返回一个 Type 对象，它表示此 Field 对象所表示字段的声明类型
getInt(Object obj)	同上
getLong(Object obj)	同上
getModifiers()
getName()
getType()	返回一个 Class 对象，它表示了此 Field 对象所表示字段的声明类型
set(Object obj,Object value)	将指定对象变量上此 Field 对象表示的字段设置为指定的新值

空白描述同 Constructor

结束

额，反射好像讲完了。。。
用法的例子就不举了，反正就这么点东西。
我给大家看两个我在学习反射过程中记录的两个问题吧。

问题一

public class ClassTest {    
    public static void main(String[] args) throws Exception {
        Class humanClass = Human.class();             Human woman = new Woman();
        Method m = humanClass.getDeclaredMethod("test");
        m.setAccessible(true);
        m.invoke(woman);
    }
}

class Human {
    private void test(){
        System.out.println("test()执行");
    }
}

class Woman extends Human {
}

注意：class 用的是Human 类的，暴力反射了Human 类的test 方法，但是我 invoke 传的对象是一个 Woman 类。
问：m.invoke(women);方法能否正常调用 test 方法。

问题二

public class InnerClass {
    public static void main(String[] args) throws Exception {

        Class<?> aClass = Class.forName("com.example.admin.materialdesign.test.A$B");
        System.out.println(aClass.getName());
        Object o = aClass.newInstance();
        System.out.println(o.getClass().getName());

    }
}

public class A {
    public class B{
    }
}

已知类 A 和A 的内部类 B，问：main 方法能否正常运行，如果会报错，会是哪一行代码，为什么？

以上两个问题是我在反射学习的过程中莫名其妙的遇到的，其中第二个问题跟内部类有关，既然讲到这里，那就顺便在这里把内部类也一块儿学了吧，反正反射章节的内容也不多，内部类也是个小知识点，我也是在思考第二个问题的过程中学习了内部类。

内部类

Java 运行我们在类的内部定义一个类。如果这个类是没有 static 修饰，那么这样一个嵌套在内部的类成为内部类。内部类被认为是外部对象的一个成员。在定义内部类时，我们同样有访问权限控制。

在使用内部类时，我们要先创建外部对象。由于内部类是外部对象的一个成员，我们可以在对象的内部自由使用内部类,比如：

public class A {
    private int age;

    public void add(){
        B b = new B();
        b.add();
    }

    private class B{

        private void add(){
            age++;
        }

    }
}

上面的例子中，B 为内部类。该内部类有 private 的访问权限，因此只能在 Human 内部使用。这样，B 类就成为一个被 A 专用的内部类。
由于 B 被认为是 A 的一个成员，所以可以互相调用。

如果我们修改 B 类的权限为 public，内部类也能从外部访问，比如：

A a = new A();
A.B b = a.new B();
b.add();

我们在创建一个内部类对象的时候，必须是基于一个外部类对象，格式如上。这里的 B 看起来有点像代理模式的感觉，hahah~

看到这里，我们可以深入理解：内部类对象必须依附与某个外部类对象。
与此同时，内部类对象可以访问它所依附的外部类对象的成员（即使是 private 的成员）。从另一个角度说，内部类对象创建时带有创建时的环境信息，这有点像 Python 语言中的闭包。

内部 static 类

我们可以在类的内部定义 static 类，这样的类称为嵌套 static 类。

我们可以直接创建嵌套 static 类的对象，而不需要依附于外部类的某个对象。相应的，也无法调用对象的非静态方法，无法修改或读取外部对象的数据。

好像跟创建一个新的类没什么区别。。。如果硬要说有区别，嵌套static 类扩展了类的命名空间。比如 A.B = new A.B();。

这里顺便提一下类的加载过程吧，我自己的理解，不一定正确，哈哈哈哈哈~

比如说 new Bean();

1.先在堆内存中寻找 Bean 对象的 Class字节码（如果有就执行3），如果没有，则找到。class 文件，将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区中的运行时数据结构，在堆中生成一个代表这个类的 Class 对象，作为方法区数据的访问入口。
2.准备阶段：正式为类变量（static）分配并设置类变量初始值的阶段，这些内存都在方法区中进行分配，执行静态代码块。
3.初始化：执行类构造方法的过程。注意这个阶段父类如果还没初始化，则先初始化父类。

整个流程是这样的

如果有父类且未加载,则优先加载父类（同过程1）
优先执行静态代码块（也就是优先加载字节码，父类先执行）
父类的构造方法永远优先子类执行

问题解答

上面提了两个比较坑的问题，同学们应该有好好思考吧，如果没有思考的先思考一会再往下看。

首先，在说我的答案之前，先申明，我的答案未必对，仅仅是我的个人想法，欢迎在评论区拍砖。

1.父类字节码暴力获取父类的 private 方法，然后 invoke 的对象传了子类的实例

先回顾一下题目的代码：

public class ClassTest {    
    public static void main(String[] args) throws Exception {
        Class humanClass = Human.class();             Human woman = new Woman();
        Method m = humanClass.getDeclaredMethod("test");
        m.setAccessible(true);
        m.invoke(woman);
    }
}

class Human {
    private void test(){
        System.out.println("test()执行");
    }
}

class Woman extends Human {
}

首先，我们必须明确一点，父类的 private 方法，子类是无法继承的。因为子类.getDeclaredMethods();并不能取到父类的 private 方法。

所以？这里会报错？

不不不，上面的 test 方法会被正常执行。我们再来看看 Method.invoke()方法中，这个参数的描述。

* @param receiver  the object the underlying method is invoked from

我英语不怎么好，但是看起来就是要调用receiver参数的 Method.getName()这个方法啊。。。。

mmp，不饶路子了，我也没找到答案，我的猜想是这样的
Method.invoke(Object receiver);中的 method 是从Human的Class 中取到的，所有在执行的时候大概是把receiver对象强转成了Human，又因为 Woman 是 Human 的子类，所以强转不会出错，所以成功调用了 Human 的 test 方法。

2.越过外部类，直接调用内部类的构造创建一个内部类对象

我们先回顾一下问题代码

public class InnerClass {
    public static void main(String[] args) throws Exception {

        Class<?> aClass = Class.forName("com.example.admin.materialdesign.test.A$B");
        System.out.println(aClass.getName());
        Object o = aClass.newInstance();
        System.out.println(o.getClass().getName());

    }
}

public class A {
    public class B{
    }
}

这个问题其实看过我上面关于内部类的介绍并且理解的同学应该已经知道答案了。aClass.newInstance();会报错。
我们来一步一步分析：
首先我们直接反射内部类 B 的字节码，由于 B 是 A 的内部类，所以会先加载 A 类的字节码，也就是说 A 的静态代码块会被调用、静态字段会被初始化。
然后打印了 aClass 的 name，字节码都获取到了，获取字节码的 name 肯定不会报错。
然后调用了 newInstance 方法创建一个内部类实例，这里就有问题了，我们刚刚在介绍内部类的时候说过，内部类对象必须依附与某个外部类对象、内部类被认为是外部对象的一个成员，所以，直接创建的内部类因为缺少外部环境，必然出错。

我们再来用反证法证明一下，假如可以创建成功。
现有一个这样的内部类组合，代码如下：

public class A {
    private int age;

    public void add(){
        B b = new B();
        b.add();
    }

    private class B{

        private void add(){
            age++;
        }

    }
}

假如我们直接通过反射创建了内部类 B 的对象 b，那么调用 b.add();方法，方法中的 age 是什么鬼？所以，内部类对象必须依附与某个外部类对象，不允许被单独创建。

Java基础（十八）反射