Java回调函数与反射机制

文章1(侧重反射机制):

原文地址:http://blog.csdn.net/zhandoushi1982/article/details/8567709

Java中没有指针,不能传递方法函数的地址,一般采用接口回调实现。
(1)可以举个现实生活中的例子:一读者想借《软件技术学习与实践》这本书,但这本书已被其他读者借走了。于是,读者与图书馆管理员间发生了以下对话:

读者:“我把我的电话号码告诉你,等书一到就马上通知我。”
管理员:“好的。另一读者把书还回来后,马上给您打电话,书我先帮您留着。”
在上述这个场景中,读者就是“回调对象”,管理员就是“控制器对象”,读者的电话号码就是“回调对象的方法”。

(2)代码示例。

        回调在JAVA中是通过接口和匿名内部类来实现的。匿名内部类的例子可参见onClickListener的用法,在形参中完成响应函数的过程。接口的用法可参见Camera.java (frameworks\base\core\java\Android\hardware)中的setPreviewCallback和takePicture函数,基本上是类似的。

======================================================================================================

       反射机制的作用:
 1,反编译:.class-->.java
 2,通过反射机制访问java对象的属性,方法,构造方法等;下边我们具体看怎么实现这些功能

(1)反射机制获取类有三种方法,我们来获取Employee类型

  1. //第一种方式:  
  2. Class c1 = Class.forName("Employee");  
  3. //第二种方式:  
  4. //java中每个类型都有class 属性.  
  5. Class c2 = Employee.class;  
  6. //第三种方式:  
  7. //java语言中任何一个java对象都有getClass 方法  
  8. Employee e = new Employee();  
  9. Class c3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)  
(2)创建对象:获取类以后我们来创建它的对象,利用newInstance:
  1. Class c =Class.forName("Employee");  
  2.   
  3. //创建此Class 对象所表示的类的一个新实例  
  4. Object o = c.newInstance(); //调用了Employee的无参数构造方法.  
(3)获取属性:分为所有的属性和指定的属性,先看获取所有的属性的写法:
  1. public class main {   
  2.     public static void main(String[] args) throws  ClassNotFoundException, NoSuchFieldException, Exception{  
  3.   
  4.         //获取整个类  
  5.         Class c = Class.forName("java.lang.Integer");  
  6.           //获取所有的属性?  
  7.         Field[] fs = c.getDeclaredFields();  
  8.    
  9.                //定义可变长的字符串,用来存储属性  
  10.         StringBuffer sb = new StringBuffer();  
  11.         //通过追加的方法,将每个属性拼接到此字符串中  
  12.         //最外边的public定义  
  13.         sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
  14.         //里边的每一个属性  
  15.         for(int j = 0;j < fs.length;j++){  
  16.             sb.append("\t");//空格  
  17.             sb.append(Modifier.toString(fs[j].getModifiers())+" ");//获得属性的修饰符,例如public,static等等  
  18.             sb.append(fs[j].getType().getSimpleName() + " ");//属性的类型的名字  
  19.             sb.append(fs[j].getName()+";\n");//属性的名字+回车  
  20.         }  
  21.         sb.append("}");  
  22.         System.out.println(sb);  
  23.     }  
  24. }  
执行结果:

public final class Integer{
public static final int MIN_VALUE;
public static final int MAX_VALUE;
public static final Class TYPE;
static final char[] digits;
static final char[] DigitTens;
static final char[] DigitOnes;
static final int[] sizeTable;
private static String integerCacheHighPropValue;
private final int value;
public static final int SIZE;
private static final long serialVersionUID;
}
(4)再看获取特定的属性的写法:

  1. public class main {   
  2.       
  3.     public void test(int x){  
  4.         System.out.println(x);  
  5.     }  
  6.       
  7.     public static void main(String[] args) throws  ClassNotFoundException, NoSuchFieldException, Exception{  
  8. /* 
  9.         Class<?> forName = Class.forName("main"); 
  10.         Method method = forName.getDeclaredMethod("test", Integer.class); 
  11.         method.invoke(forName.newInstance(), 10); 
  12. */  
  13.   
  14.         Class<?> forName1 = Class.forName("main");  
  15.         Method method1 = forName1.getDeclaredMethod("test"int.class);  
  16.         method1.invoke(forName1.newInstance(), 10);   
  17.   
  18.     }  
  19. }  
执行结果10

(5)获取方法,和构造方法,不再详细描述,只来看一下关键字:


这样我们就可以获得类的各种内容,进行了反编译。


文章2(侧重回调函数):

原文地址:http://blog.csdn.net/yehuang_0801/article/details/5648914

反射机制

  1. public class main {   
  2.       
  3.     public void test(int x){  
  4.         System.out.println(x);  
  5.     }  
  6.       
  7.     public static void main(String[] args) throws  ClassNotFoundException, NoSuchFieldException, Exception{  
  8. /* 
  9.         Class<?> forName = Class.forName("main"); 
  10.         Method method = forName.getDeclaredMethod("test", Integer.class); 
  11.         method.invoke(forName.newInstance(), 10); 
  12. */  
  13.   
  14.         Class<?> forName1 = Class.forName("main");  
  15.         Method method1 = forName1.getDeclaredMethod("test"int.class);  
  16.         method1.invoke(forName1.newInstance(), 10);   
  17.   
  18.     }  
  19. }  

回调函数&函数回调&回调机制

所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法

  1. /**  
  2.  * 这是一个回调接口  
  3.  * @author xiaanming  
  4.  *  
  5.  */    
  6. public interface CallBack {    
  7.     /**  
  8.      * 这个是小李知道答案时要调用的函数告诉小王,也就是回调函数  
  9.      * @param result 是答案  
  10.      */    
  11.     public void solve(String result);    
  12. }    

  1. /**  
  2.  * 这个是小王  
  3.  * @author xiaanming  
  4.  * 实现了一个回调接口CallBack,相当于----->背景一  
  5.  */    
  6. public class Wang implements CallBack {    
  7.     /**  
  8.      * 小李对象的引用  
  9.      * 相当于----->背景二  
  10.      */    
  11.     private Li li;     
  12.     
  13.     /**  
  14.      * 小王的构造方法,持有小李的引用  
  15.      * @param li  
  16.      */    
  17.     public Wang(Li li){    
  18.         this.li = li;    
  19.     }    
  20.         
  21.     /**  
  22.      * 小王通过这个方法去问小李的问题  
  23.      * @param question  就是小王要问的问题,1 + 1 = ?  
  24.      */    
  25.     public void askQuestion(final String question){    
  26.         //这里用一个线程就是异步,    
  27.         new Thread(new Runnable() {    
  28.             @Override    
  29.             public void run() {    
  30.                 /**  
  31.                  * 小王调用小李中的方法,在这里注册回调接口  
  32.                  * 这就相当于A类调用B的方法C  
  33.                  */    
  34.                 li.executeMessage(Wang.this, question);     
  35.             }    
  36.         }).start();    
  37.             
  38.         //小网问完问题挂掉电话就去干其他的事情了,诳街去了    
  39.         play();    
  40.     }    
  41.     
  42.     public void play(){    
  43.         System.out.println("我要逛街去了");    
  44.     }    
  45.     
  46.     /**  
  47.      * 小李知道答案后调用此方法告诉小王,就是所谓的小王的回调方法  
  48.      */    
  49.     @Override    
  50.     public void solve(String result) {    
  51.         System.out.println("小李告诉小王的答案是--->" + result);    
  52.     }    
  53.         
  54. }    

  1. /**  
  2.  * 测试类  
  3.  * @author xiaanming  
  4.  *  
  5.  */    
  6. public class Test {    
  7.     public static void main(String[]args){    
  8.         /**  
  9.          * new 一个小李  
  10.          */    
  11.         Li li = new Li();    
  12.     
  13.         /**  
  14.          * new 一个小王  
  15.          */    
  16.         Wang wang = new Wang(li);    
  17.             
  18.         /**  
  19.          * 小王问小李问题  
  20.          */    
  21.         wang.askQuestion("1 + 1 = ?");    
  22.     }    
  23. }   

这个例子采用异步加回调


Java动态代理与反射详解


转载http://www.cnblogs.com/haodawang/p/5967185.html

动态代理,静态代理看上面链接
  1. import java.lang.reflect.*;  
  2.   
  3. public class Main {  
  4.     static void customer(ProxyInterface pi){  
  5.         pi.say();  
  6.     }  
  7.     public static void main(String[] args){  
  8.         RealObject real = new RealObject();  
  9.         ProxyInterface proxy = (ProxyInterface)Proxy.newProxyInstance(ProxyInterface.class.getClassLoader(),new Class[]{ProxyInterface.class}, new ProxyObject(real));  
  10.         customer(proxy);  
  11.     }  
  12. }  
  13.   
  14.   
  15. interface ProxyInterface{  
  16.     void say();  
  17. }  
  18.   
  19. //被代理类  
  20. class RealObject implements ProxyInterface{  
  21.     public void say(){  
  22.         System.out.println("i'm talking");  
  23.     }  
  24. }  
  25.   
  26. //代理类,实现InvocationHandler 接口  
  27. class ProxyObject implements InvocationHandler{  
  28.     private Object proxied = null;  
  29.     public ProxyObject(){  
  30.           
  31.     }  
  32.     public ProxyObject(Object proxied){  
  33.         this.proxied  = proxied;  
  34.     }  
  35.     public Object invoke(Object arg0, Method arg1, Object[] arg2) throws Throwable {  
  36.         System.out.println("hello");  
  37.         return arg1.invoke(proxied, arg2);  
  38.     };  
  39. }  
以下摘抄:

可以看到动态代理的代理类是实现了一个InvocationHandler的接口,我们通过reflect.Proxy的类的newProxyInstance方法就可以得到这个接口的实例,然后再来作为参数传递进去,这里每一个在代理类上处理的东西也会被重定向到调用处理器上。

至于动态代理和静态代理的区别,即动态代理是动态的创建代理和动态的处理方法的,这也是反射的一个重要体现之处。

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值