反射，是一个相对底层的内容。
未来这个内容你几乎不自己写？为什么呢？
因为你会用各种框架，框架的底层实现就是反射。
学习今天的内容，能帮你理解框架的实现机制。为以后学框架打基础。
类加载器
反射
动态代理（先讲代理设计模式，再讲动态代理）
//类(我们自己写的类以及系统提供的类)是怎么加载到内存中的？
加载类（.class文件）的过程：
1、JVM读取.class文件，并进行校验文件的正误
2、加载你的静态属性或者静态方法
3、初始化对象（初始化块、构造方法的执行）。
什么时候加载一个类呢？
1、创建对象的时候(首次创建的时候才加载这个类)。Person p = new Person();
2、使用静态属性的时候（赋值以及取值） Person.count = 100;
3、调用静态方法的时候
4、当创建子类对象的时候（你是父类）。
系统用什么加载的类呢？----类加载器。
类加载器的作用：把.class文件读入内存。//这个过程就是加载。
在java中一共有3种类加载器
Bootstrap ClassLoader 根加载器（加载系统的核心类库 rt.jar），无法获取
Extension ClassLoader 扩展类加载器（加载扩展的jar包ext文件夹下面的所有jar包）
System ClassLoader 系统类加载器（就是你自己写的类，用这个加载器。
你配置的classPath环境变量所指向的位置。）
反射：
普通类是描述对象的。Person类，用于描述每一个Person对象应该有哪些属性和方法。
你可能有很多个类，例如：String，Person，ArrayList,InputStreamReader
//上述的所有类，都有共性，都有行为，都有属性
如果要描述这些类，应该怎么描述呢？使用Class类
Class类：用来描述类的类，可以描述这个类有几个属性，有几个方法，几个构造放，几个接口。。。
在Java变成语言里，任何数据类型（包括基本数据类型）都有一个Class对象描述它。
想要深入学习Class类，第一件事就获取一个Class类型的对象。
获取Class对象有3种方式
方式1：类名.class属性
方式2：对象.getClass()方法
方式3：Class.forName(“类名（含包名）”)
什么是反射呢?
在程序运行过程中，一旦你知道一个类（类名），你就可以获取这个类的所有属性和方法
同时，你还可以创建这个类的对象以及调用所有属性（包括私有的）和所有方法（包括私有的）。
这套机制就叫反射。
反射的基础就是Class对象。有了Class对象才能做你想实现的功能。
回顾总结
反射（reflect）：
在程序运行过程中（运行期），如果你知道一个类的名字，你可以
获取这个类的全部属性和方法，并且能够访问属性和方法。
实际上反射可以访问：
属性（Field）：public、默认的、protected、private修饰的
成员属性以及类属性（static）。
//批量获取属性：
//（1）获取所有的public属性（含父类继承过来的）。
getFields()
//（2）获取所有的属性（切记：不含继承的）
getDeclaredFields()
//（3）获取指定的public属性（含父类继承过来的）
getField(String fieldName)
//（4）获取指定的属性（切记：不含继承的）
getDecalaredField(String fieldName)
方法（Method）：public、默认的、protected、private修饰的方法
//（1）获取所有public方法（含父类继承过来的）
//（2）获取所有方法（切记：不含继承的）
//（3）获取指定的public方法（含父类继承过来的）
//（4）获取指定的方法（切记：不含继承的）
构造器（Constructor）：public、默认的、protected、private
//（1）获取所有public构造方法
//（2）获取所有的构造方法
//（3）获取指定的public构造方法
//（4）获取指定的构造方法
父类（Class）：父类也是一个Class。
接口（Class）：Java中接口被当作Class来处理了。
获取泛型
获取注解
反射的用途：
（1）访问你的私有属性和方法。
第一步：获取私有属性或方法
第二步：设置属性或方法的setAccessable为true。（关闭JVM对访问修饰符的检查）
第三步：设置属性或调用方法
（2）绕过泛型的检查
第一步：获取要使用的方法（Method）
第二步：调用方法
（3）很多框架都是通过读文件（例如：XML文件、properties文件）让你的代码更灵活。
反射的应用：动态（Dynamic）代理（Proxy）
代理？----设计模式
动态代理？
//
package com.lanou3g.proxy;
public interface BossInterface {
public abstract void meet(); //见面
public abstract void consume(); //消费
}
//
package com.lanou3g.proxy;
public class CoalBoss implements BossInterface{
@Override
public void meet() {
System.out.println("煤老板在见面");
}
@Override
public void consume() {
System.out.println("煤老板在消费");
}
}
//
package com.lanou3g.proxy;
public class CoalBossProxy implements BossInterface {
private CoalBoss boss;
public CoalBossProxy(CoalBoss boss) {
super();
this.boss = boss;
}
@Override
public void meet() {
System.out.println("见面前的一些准备工作");
boss.meet();
System.out.println("做见面后的事宜");
}
@Override
public void consume() {
System.out.println("提前预定。。。");
boss.consume();
System.out.println("买单");
}
}
//
package com.lanou3g.proxy;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
CoalBoss cb = new CoalBoss();
// cb.consume();
// cb.meet();
CoalBossProxy cbp = new CoalBossProxy(cb);
cbp.meet();
cbp.consume();
}
}
自动代理
package com.lanou3g.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxy implements InvocationHandler {
private Object target; //目标对象----需要使用代理的对象。
//（例如：煤老板（CoalBoss）、钢铁老板等）
public DynamicProxy(Object target) {
super();
this.target = target;
}
//获取代理对象。
public Object newProxy() {
return Proxy.newProxyInstance(
target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}
//代理对象 调用接口中的方法时，会执行下面的代码。
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("前期的处理代码");
Object o = method.invoke(target, args);//原始方法的执行
System.out.println("后续的处理代码");
return o;
}
}
//
package com.lanou3g.proxy;
public interface Interface1 {
public abstract void test();
}
//
package com.lanou3g.proxy;
public class A implements Interface1 {
@Override
public void test() {
System.out.println("测试动态代理好不好用");
}
}
//
package com.lanou3g.proxy;
public class TestProxy {
public static void main(String[] args) {
A a = new A();
DynamicProxy dp3 = new DynamicProxy(a);
Interface1 proxy = (Interface1) dp3.newProxy();
proxy.test();
}
}