一、反射与RTTI
RTTI：这个类型必须在编译的时候已知或者存在，如果不知道对象的确切类型，RTTI可以告诉你。
反射（个人认为就是能够利用Class获取或者调用.class这个文件中的数据）：当我们从程序外（网络，磁盘中）在程序运行的时候获取这些数据，发现这些数据是个类，并且不知道该类的类型，那么我们怎么使用这些数据呢。
所以说根本区别是：RTTI在编译的时候会检查和打开.class文件，但是在反射中.class文件是不可获取的，所以在运行时打开和检查.class文件
二、使用
利用反射获取类的方法和构造方法
ublic class UseReflection {
public static void main(String[]args){
try {
Class c = Class.forName("String");
Method[]methods = c.getMethods();//获取c这个对象的所有方法
Constructor[]constructors = c.getConstructors();//获取c这个对象的所有构造方法
for (Method method:methods){
method.toString();
constructors.toString();
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
View UseReflection
三、动态代理
①、代理
作用：将额外的操作从“实际”对象中分离到不同的地方。（特别是当有时候准备使用这个功能，有时候又不需要使用这个功能的时候，这就很容易修改）。
（感觉就是扩展了这个方法，但是又不是直接在方法内增加，并且还能够选择用或者不用）
步骤：1、将需要的操作封装为一个接口 2、主类继承这个接口，然后实现 3、创建代理继承接口，然后获取主类，在实现方法的时候，调用新方法然后再调用主类的同样的方法。
public interface Proxy {
void doSomething();
void somethingElse(String make);
}
代理接口
//主类继承了代理类,并重写了该方法
public class Child implements Proxy{ @Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("Play");
} @Override
public void somethingElse(String make) {
// TODO Auto-generated method stub
System.out.println("eat fruit");
} }
主类
//代理类，继承了代理接口，并获取主类对象向上转型为代理，然后在相应方法内，重新调用
public class SimpeProxy implements Proxy{
private Proxy mProxy; public SimpeProxy(Proxy proxy){
mProxy = proxy;
} @Override
public void doSomething() {
// TODO Auto-generated method stub
System.out.println("Footboll");
//调用主类的该方法
mProxy.doSomething();
} @Override
public void somethingElse(String make) {
// TODO Auto-generated method stub
System.out.println("Footboll"+make);
mProxy.somethingElse(make);
} }
代理类
public class AchieveProxy {
public static void main(String[] args) {
// TODO Auto-generated method stub
complete(new Child());//未使用代理
complete(new SimpeProxy(new Child()));//使用代理
}
public static void complete(Proxy proxy){
proxy.doSomething();
proxy.somethingElse("make cake");
}
}
实现逻辑类
②、动态代理
使用：1、用到的类：InvocationHandler接口，和Proxy类
步骤：1、同样将需要的操作封装成一个接口 2、创建相关类并继承接口 3、创建代理类，该类继承InvocationHandler接口，实现invoke()方法，该方法实现代理的逻辑。
4、在主线程中调用代理
示例：
代理接口和主类不变就不写了。
//继承接口
public class DynamicProxy implements InvocationHandler {
private Object mChild;
public DanamicProxy(Object child){
mChild = child;
}
//实现接口的方法。
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub System.out.println("我是代理，大家好"+"proxy "+proxy.getClass().getSimpleName());
//绑定该方法，参数1、是被被代理对象 参数2、是传送到该方法的值
return method.invoke(mChild, args);
}
}
/*
*方法的使用原理：参数1、当前的代理对象 参数2、正在被使用的方法 参数3、对于该方法传入的参数。
*
*/
DynaicProxy
//创建被代理对象
Child child = new Child();
//创建代理对象
DanamicProxy dana = new DanamicProxy(child);
//连接代理与被代理对象 参数1、获取类加载器 参数2、获取代理的接口 参数3、获取代理对象
Proxy proxy = (Proxy)java.lang.reflect.Proxy.newProxyInstance(child.getClass().getClassLoader(), new Class[]{Proxy.class}, dana);
//调用代理对象的方法
complete(proxy); public static void complete(Proxy proxy){
proxy.doSomething();
proxy.somethingElse("make cake");
}
实现逻辑
原理：Proxy类通过反射获取接口的方法，在继承InvcationHandler的类中，当代理调用接口的方法的时候，就会触发invoke()方法，并将用到的方法和参数传入，然后再用用到的方法调用invoke()调用被代理类的相应方法。
动态代理的优点：①、只需要在invoke()中实现逻辑就可以了，不用因为有多个方法需要代理，就需要重写一堆方法。 ②、代理可以被多个类使用，而不是继承特定接口的类。
最近用到的Retrofit应该就是用到了动态代理。
RTTI的新发现：
Child child = new Child();
Proxy proxy = (Proxy)child;
System.out.println(proxy.getClass().getName());
//答案居然是Child。 说明反射是根据指针来的，向上转型无法改变其name