JAVA编程思想——类型信息(反射)

一、反射与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