Java基础（十一）—

一、概述

1、介绍

　　Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
　　加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子可以看到类的结构，所以，形象的称之为：反射。

2、动态语言与静态语言

　　动态语言：是一类在运行时可以改变其结构的语言。例如，新的函数、对象，甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang。
　　静态语言：与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
　　Java不是动态语言，但Java可以称之为"准动态语言"。即Java有一定的动态性，可以利用反射机制、字节码操作获得类似动态语言的特性。Java的动态性让编程更加灵活！

3、Java反射的功能

　　（1）在运行时判断任意一个对象所属的类。
　　（2）在运行时构造任意一个类的对象。
　　（3）在运行时判断任意一个类所具有的成员变量和方法。
　　（4）在运行时获取泛型信息。
　　（5）在运行时调用任意一个对象的成员变量和方法。
　　（6）在运行时处理注解。
　　（7）生成动态代理。

4、相关API

　　代码示例：类的实例化

 1 class Person {
 2     private String name;
 3     public int age;
 4     public void say() {
 5         System.out.println("say hello");
 6     }
 7
 8     private String eat(String food) {
 9         System.out.println("我正在吃:" + food);
10         return food;
11     }
12     // getter && setter
13     // 有参、无参构造器
14 }
15
16 // 未使用反射
17 public class Main {
18     public static void main(String[] args) {
19         // 1.创建类的对象
20         Person person = new Person("Tom", 18);
21         // 2.通过对象,调用属性及方法
22         person.age = 10;
23         System.out.println(person.toString());
24
25         person.say();
26         // 3.不可以通过对象调用私有结构
27         // person.name = "";
28         // person.eat();
29     }
30 }
31
32 // 使用反射
33 public class Main {
34     public static void main(String[] args) throws Exception {
35         // 1.创建类的对象
36         Class<Person> clazz = Person.class;
37         // 获取类的构造器
38         Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
39         Person person = constructor.newInstance("Tom", 12);
40         System.out.println(person.toString());
41
42         // 2.通过反射,调用属性及方法
43         Field age = clazz.getDeclaredField("age");
44         age.set(person, 10);
45         System.out.println(person.toString());
46
47         Method show = clazz.getDeclaredMethod("say");
48         show.invoke(person);
49     }
50 }

　　代码示例：调用私有结构

 1 public class Main {
 2     public static void main(String[] args) throws Exception {
 3         // 1.通过反射调用私有构造器
 4         Class<Person> clazz = Person.class;
 5         Constructor<Person> constructor = clazz.getDeclaredConstructor(String.class);
 6         constructor.setAccessible(true); // 设置构造器可见
 7
 8         Person person = constructor.newInstance("Jerry");
 9         System.out.println(person.toString());
10
11         // 2.通过反射调用私有属性
12         Field name = clazz.getDeclaredField("name");
13         name.setAccessible(true); // 设置属性可见
14         name.set(person, "mary");
15         System.out.println(person.toString());
16
17         // 3.通过反射调用私有方法
18         Method method = clazz.getDeclaredMethod("eat", String.class);
19         method.setAccessible(true); // 设置方法可见
20         String s = (String) method.invoke(person, "黄焖鸡");
21         System.out.println(s);
22     }
23 }

　　反射机制与面向对象中的封装性是不是矛盾的？如何看待这两个技术？
　　不矛盾。可以理解为，封装：我们已经提供了更好的方法给你（public），而你非要去走弯路（private）也可以，但是很没有必要。

二、理解Class类并获取Class实例

1、Class类

　　类的加载过程：程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class)，接着使用java.exe命令对某个字节码文件进行解释运行。即：将字节码文件加载到内存中，此过程就称为类的加载。
　　加载到内存中的类，就称为运行时类，此运行时类，就作为Class的一个实例。一个加载的类在 JVM 中只会有一个Class实例，换句话说，Class的实例就对应着一个运行时类。
　　加载到内存中的运行时类，会缓存一定的时间。在此时间之内，可以通过不同的方式来获取此运行时类。

2、获取Class实例

　　代码示例：获取Class实例的4种方式

 1 public class Main {
 2     public static void main(String[] args) throws Exception {
 3         // 方式一:调用运行时类的属性
 4         Class<Person> clazz1 = Person.class;
 5         System.out.println(clazz1);
 6
 7         // 方式二:通过运行时类的对象
 8         Person person = new Person();
 9         Class<? extends Person> clazz2 = person.getClass();
10         System.out.println(clazz2);
11
12         // 方式三:调用Class的静态方法
13         Class<?> clazz3 = Class.forName("com.lx.day01.Person");
14         System.out.println(clazz3);
15
16         // 方式四:使用类的加载器
17         ClassLoader classLoader = Main.class.getClassLoader();
18         Class<?> clazz4 = classLoader.loadClass("com.lx.day01.Person");
19         System.out.println(clazz4);
20
21         System.out.println(clazz1 == clazz2); // true
22         System.out.println(clazz1 == clazz3); // true
23         System.out.println(clazz1 == clazz4); // true
24     }
25 }

　　代码示例：Class实例对应的结构

 1 public class Main {
 2     public static void main(String[] args) {
 3         Class<Object> objectClass = Object.class; // 类
 4         Class<Comparable> comparableClass = Comparable.class; // 接口
 5         Class<String[]> aClass = String[].class; // 数组
 6         Class<int[][]> aClass1 = int[][].class; // 二维数组
 7         Class<ElementType> elementTypeClass = ElementType.class; // 枚举
 8         Class<Override> overrideClass = Override.class; // 注解
 9         Class<Integer> integerClass = int.class; // 基本数据类型
10         Class<Void> voidClass = void.class;
11         Class<Class> classClass = Class.class;
12
13         // 只要元素类型与维度一样,就是同一个Class
14         int[] a = new int[10];
15         int[] b = new int[100];
16         Class<? extends int[]> aClass2 = a.getClass();
17         Class<? extends int[]> aClass3 = b.getClass();
18         System.out.println(aClass2 == aClass3); // true
19     }
20 }

三、类的加载与ClassLoader的理解

1、类的加载过程

　　当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

　　加载：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个 Class 对象。这个加载的过程需要类加载器参与。
　　链接：将 Java 类的二进制代码合并到 JVM 的运行状态之中的过程。
　　（1）验证：确保加载的类信息符合 JVM 规范，例如：以 cafe 开头，没有安全方面的问题。
　　（2）准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
　　（3）解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。
　　初始化：执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译器自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的（类构造器是构造类信息的，不是构造该类对象的构造器）。
　　当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
　　虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步。即：保证一个类只会被加载一次。
　　代码示例：静态变量赋值

 1 public class Main {
 2     public static void main(String[] args) {
 3         System.out.println(A.m); // 300
 4     }
 5 }
 6
 7 class A {
 8     static int m = 100;
 9
10     static {
11         m = 300;
12     }
13 }
14 // 第二步:链接结束后 m = 0
15 /*
16  * 第三步:初始化后,m 的值由<clinit>方法执行决定。
17  * 这个 A 的类构造器<clinit>()方法由类变量的赋值和静态代码块中的语句按照顺序合并。
18  * 类似于<clinit>(){
19  *             m = 100;
20  *             m = 300;
21  *      }
22  */

2、ClassLoader的理解

　　类加载器的作用
　　（1）加载类：将 class 文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类的 java.lang.Class 对象，作为方法区中类数据的访问入口。
　　（2）类缓存：标准的 JavaSE 类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过 JVM 垃圾回收机制可以回收这些 Class 对象。

　　类加载器作用是用来把类（class）载进内存的。JVM 规范定义了如下类型的类的加载器。

四、调用运行时类

1、创建运行时类的对象

　　代码示例：创建运行时类的对象

 1 public class Main {
 2     public static void main(String[] args) throws Exception {
 3         // 1.获取Class对象
 4         Class<Person> clazz = Person.class;
 5         // 2.调用指定参数的构造器
 6         Constructor<Person> constructor = clazz.getConstructor(String.class, int.class);
 7
 8         // 3.创建运行时类的对象
 9         Person person = constructor.newInstance("牛牛", 18);
10         System.out.println(person); // Person{name='牛牛', age=18}
11     }
12 }

2、获取运行时类的结构

　　Class类：
　　public Class<?>[] getInterfaces()：获取类实现的全部接口。
　　public native Class<? super T> getSuperclass()：获取类所继承的父类。
　　public Type getGenericSuperclass()：获取带泛型的父类。
　　public Constructor<?>[] getConstructors()：获取类的所有public构造方法。
　　public Constructor<?>[] getDeclaredConstructors()：获取类声明的所有构造方法。
　　public Method[] getMethods()：获取类的所有public方法。
　　public Method[] getDeclaredMethods()：获取类声明的所有方法。
　　public Field[] getFields()：获取类的所有public的Field。
　　public Field[] getDeclaredFields()：获取类声明的所有Field。

　　Constructor类：
　　public int getModifiers()：取得修饰符。
　　public String getName()：取得方法名称。
　　public Class[] getParameterTypes()：取得参数的类型。

　　Method类：
　　public Class<?> getReturnType()：取得全部的返回值。
　　public Class<?>[] getParameterTypes()：取得全部的参数。
　　public int getModifiers()：取得修饰符。
　　public Class<?>[] getExceptionTypes()：取得异常信息。

　　Field类：
　　public int getModifiers()：以整数形式返回此Field的修饰符。
　　public Class<?> getType()：得到Field的属性类型。
　　public String getName()：返回Field的名称。

3、调用运行时类的指定结构

　　代码示例：同"调用私有结构"

五、反射的应用：动态代理

　　见《设计模式》