正文开始 ----------
1. Java反射机制概述
1.1 反射机制的概述
Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于 Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。
加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。
1.1.1 动态语言 vs 静态语言
1、动态语言
是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。
主要动态语言：Object-C、C#、JavaScript、PHP、Python、Erlang
2. 静态语言
与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、C、C++。
Java不是动态语言，但Java可以称之为“准动态语言”。即Java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性。
Java的动态性让编程的时候更加灵活！
1.1.2 反射的应用场景
在运行时判断任意一个对象所属的类
在运行时构造任意一个类的对象
在运行时判断任意一个类所具有的成员变量和方法
在运行时获取泛型信息
在运行时调用任意一个对象的成员变量和方法
在运行时处理注解
生成动态代理
2. 理解Class类和获取Class类
2.1 理解Class类
在Object类中定义了以下的方法，此方法将被所有子类继承：
● public final Class getClass()
以上的方法返回值的类型是一个Class类，此类是Java反射的源头，实际上所谓反射从程序的运行结果来看也很好理解，
即：可以通过对象反射求出类的名称。
对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言，JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
Class本身也是一个类
Class 对象只能由系统建立对象
一个加载的类在 JVM 中只会有一个Class实例
一个Class对象对应的是一个加载到JVM中的一个.class文件
每个类的实例都会记得自己是由哪个 Class 实例所生成
通过Class可以完整地得到一个类中的所有被加载的结构
Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
2.2 Class类的常用方法
2.3 反射的应用举例
• String str = “test4.Person”;
• Class clazz = Class.forName(str);
• Object obj = clazz.newInstance();
• Field field = clazz.getField(“name”);
• field.set(obj, “Peter”);
• Object name = field.get(obj);
• System.out.println(name);
test4.Person是test4包下的Person类
2.4 获取Class类的实例(四种方法)
1）**前提：**若已知具体的类，通过类的class属性获取，该方法最为安全可靠，
程序性能最高
Class clazz = String.class;
2）**前提：**已知某个类的实例，调用该实例的getClass()方法获取Class对象
Class clazz = “www.manman.com”.getClass();
3）**前提：**已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException
Class clazz = Class.forName(“java.lang.String”);
4）其他方式
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);
2.5 哪些类型可以有Class对象 ？
代码实现
Class c1 = Object.class; Class c2 = Comparable.class; Class c3 = String[].class; Class c4 = int[][].class; Class c5 = ElementType.class; Class c6 = Override.class; Class c7 = int.class; Class c8 = void.class; Class c9 = Class.class; int[] a = new int[10]; int[] b = new int[100]; Class c10 = a.getClass(); Class c11 = b.getClass(); // 只要元素类型与维度一样，就是同一个Class System.out.println(c10 == c11);
3. 类的加载与ClassLoader的理解
3.1 类加载器
很多开发人员都遇到过java.lang.ClassNotFoundException或java.lang.NoClassDefError，想要更好的解决这类问题，或者在一些特殊的应用场景，比如需要支持类的动态加载或需要对编译后的字节码文件进行加密解密操作，那么需要你自定义类加载器，因此了解类加载器及其类加载机制也就成了每一个Java开发人员的必备技能之一。
1、类加载器分为：
（1）引导类加载器（Bootstrap Classloader）又称为根类加载器
它负责加载jre/rt.jar核心库 它本身不是Java代码实现的，也不是ClassLoader的子类，获取它的对象时往往返回null
（2）扩展类加载器（Extension ClassLoader）
它负责加载jre/lib/ext扩展库 它是ClassLoader的子类
（3）应用程序类加载器（Application Classloader）
它负责加载项目的classpath路径下的类 它是ClassLoader的子类
（4）自定义类加载器
当你的程序需要加载“特定”目录下的类，可以自定义类加载器； 当你的程序的字节码文件需要加密时，那么往往会提供一个自定义类加载器对其进行解码 后面会见到的自定义类加载器：tomcat中
2、Java系统类加载器的双亲委托模式
简单描述：
下一级的类加载器，如果接到任务时，会先搜索是否加载过，如果没有，会先把任务往上传，如果都没有
应用程序类加载器 把 扩展类加载器视为父加载器，
扩展类加载器 把 引导类加载器视为父加载器。
不是继承关系，是组合的方式实现的。
3.1.1 查看某个类的类加载器对象
（1）获取默认的系统类加载器
ClassLoader ClassLoader.getSystemClassLoader()
（3）获取某个类加载器的父加载器
ClassLoader ClassLoader对象.getParent()
示例代码：
package com.manman.loader; import org.junit.Test; public class TestClassLoader { @Test public void test01(){ ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader(); System.out.println("systemClassLoader = " + systemClassLoader); } @Test public void test02()throws Exception{ ClassLoader c1 = String.class.getClassLoader(); System.out.println("加载String类的类加载器：" + c1); ClassLoader c2 = Class.forName("sun.util.resources.cldr.zh.TimeZoneNames_zh").getClassLoader(); System.out.println("加载sun.util.resources.cldr.zh.TimeZoneNames_zh类的类加载器：" + c2); ClassLoader c3 = TestClassLoader.class.getClassLoader(); System.out.println("加载当前类的类加载器：" + c3); } @Test public void test03(){ ClassLoader c1 = TestClassLoader.class.getClassLoader(); System.out.println("加载当前类的类加载器c1=" + c1); ClassLoader c2 = c1.getParent(); System.out.println("c1.parent = " + c2); ClassLoader c3 = c2.getParent(); System.out.println("c2.parent = " + c3); } }
3.2 类的加载过程
当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化
代码演示
public class ClassLoadingTest { public static void main(String[] args) { System.out.println(A.m); } } class A { static { m = 300; } static int m = 100; } //第二步：链接结束后m=0 //第三步：初始化后，m的值由<clinit>()方法执行决定 // 这个A的类构造器<clinit>()方法由类变量的赋值和静态代码块中的语句按照顺序合并 产生，类似于 // <clinit>(){ // m = 300; // m = 100; // }
3.3 什么时候会进行类初始化 ？
public class ClassLoadingTest { public static void main(String[] args) { // 主动引用：一定会导致A和Father的初始化 // A a = new A(); // System.out.println(A.m); // Class.forName("com.atguigu.java2.A"); // 被动引用 A[] array = new A[5];//不会导致A和Father的 初始化 // System.out.println(A.b);//只会初始化 Father // System.out.println(A.M);//不会导致A和 Father的初始化 } static { System.out.println("main所在的类"); } } class Father { static int b = 2; static { System.out.println("父类被加载"); } } class A extends Father { static { System.out.println("子类被加载"); m = 300; } static int m = 100; static final int M = 1; }
类加载的作用 ： 将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成一个代表这个类java.lang.Class对象，作为方法区中类数据的访问入口。
类缓存 :标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象
3.4 ClassLoader的理解
类加载器作用是用来把类(class)装载进内存的。JVM 规范定义了如下类型的类的加载器。
4. 创建运行类的对象
4.1 有了Class对象，可以做什么
**创建类的对象：**调用Class对象的newInstance()方法
要求：
1）类必须有一个无参数的构造器。
2）类的构造器的访问权限需要足够。
难道没有无参的构造器就不能创建对象了吗？
不是！只要在操作的时候明确的调用类中的构造器，并将参数传递进去之后，才可以实例化操作。
步骤如下：
1）通过Class类的**getDeclaredConstructor(Class … parameterTypes)**取得本类的指定形参类型的构造器
2）向构造器的形参中传递一个对象数组进去，里面包含了构造器中所需的各个参数。
3）通过Constructor实例化对象。
以上是反射机制运用最多的地方
//1.根据全类名获取对应的Class对象 String name = “com.manman.java.Person"; Class clazz = null; clazz = Class.forName(name); //2.调用指定参数结构的构造器，生成Constructor的实例 Constructor con = clazz.getConstructor(String.class,Integer.class); //3.通过Constructor的实例创建对应类的对象，并初始化类属性 Person p2 = (Person) con.newInstance("Peter",20); System.out.println(p2);
