一、反射与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(); } } }
三、动态代理
①、代理
作用:将额外的操作从“实际”对象中分离到不同的地方。(特别是当有时候准备使用这个功能,有时候又不需要使用这个功能的时候,这就很容易修改)。
(感觉就是扩展了这个方法,但是又不是直接在方法内增加,并且还能够选择用或者不用)
步骤: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、对于该方法传入的参数。 * */
//创建被代理对象 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