内部类使用场景:供外部类使用,回调

来源:互联网 发布:如何查看本机端口号 编辑:程序博客网 时间:2024/06/16 13:47
 
我们说这个内部类依附于它的外部类而存在,可能的原因有:
1、不可能为其他的类使用;
2、出于某种原因,不能被其他类引用,可能会引起错误。
3、当前的类过大,比如某个方法,里面写了非常多的代码,需要重构,如果你想抽象到另外一个类里面,那么不妨考虑一下内部类,因为,这些代码是从当前类抽象出来的,只被当前类所使用,那么用内部类实现也是很好的。下面我们以一个大家熟悉的例子来说明。

这段时间做电信的短信下发的项目,需要对上行用户的手机号做特殊处理,然后下发短信,那么主要功能是下短信,但是在下发之前,需要对用户号码做出处理,满足下面下短信的时候使用。

Java代码 复制代码 收藏代码
  1. public class SendSms implements SpInfo   
  2. {   
  3.           public String sendSms(String userID,String productID,int OPType)   
  4.           {   
  5.                   String res = null;   
  6.                   。。。   
  7.                   SendSms.AddressBean ab = new SendSms.AddressBean();//获得内部类的实例  
  8.                   //用内部类来加工处理用户号码   
  9.                   org.apache.axis.types.URI[] addressesuri = ab.getDownAddress(userID);   
  10.                   。。。   
  11.   
  12.                   //下面开始组织soapheader,此处也可以用内部类来实现的。  
  13.                   RequestSOAPHeader soapHeader = DownHeader.downHeader_ismp(productID, addressesuri);   
  14.                   。。。   
  15.                   SMS downsms = new SMS();   
  16.                   res = downsms.sendSMS(addressesuri, senderName, charging, down_message,   
  17.                   receiptRequest, soapHeader);   
  18.               return res;   
  19.           }   
  20.             


Java代码 复制代码 收藏代码
  1.           //内部类----此类只被当前的外部类所使用   
  2.           public class AddressBean   
  3.           {   
  4.                   public org.apache.axis.types.URI[] getDownAddress(String senderAddress)   
  5.                   {   
  6.                           org.apache.axis.types.URI[] addressesuri = null;   
  7.                           String proaddress = "tel:" + senderAddress;   
  8.                           String[] address = new String[] {proaddress};   
  9.                           addressesuri = new org.apache.axis.types.URI[address.length];   
  10.                           try  
  11.                            {   
  12.                                    for (int i = 0; i < address.length; i++)   
  13.                                    {   
  14.                                             addressesuri[i] = new URI(address[i]);   
  15.                                    }   
  16.                            }catch(Exception ex)   
  17.                            {   
  18.                                    ex.printStackTrace();   
  19.                            }   
  20.                           return addressesuri;   
  21.                   }   
  22.           }   
  23. }  


首先我们得了解一下什么叫做回调函数:

精妙比喻:回调函数还真有点像您随身带的BP机:告诉别人号码,在它有事情时Call您
回调用于层间协作,上层将本层函数安装在下层,这个函数就是回调,而下层在一定条件下触发回调,例如作为一个驱动,是一个底层,他在收到一个数据时,除了完成本层的处理工作外,还将进行回调,将这个数据交给上层应用层来做进一步处理,这在分层的数据通信中很普遍。
其实回调和API非常接近,他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用,一般这个函数对高层都是已知的;而回调正好相反,他是高层提供给底层的调用,对于低层他是未知的,必须由高层进行安装,这个安装函数其实就是一个低层提供的API,安装后低层不知道这个回调的名字,但它通过一个函数指针来保存这个回调,在需要调用时,只需引用这个函数指针和相关的参数指针。
其实:回调就是该函数写在高层,低层通过一个函数指针保存这个函数,在某个事件的触发下,低层通过该函数指针调用高层那个函数。

关于回调的总结:
在Java中,通常就是编写另外一个类或类库的人规定一个接口,然后你来实现这个接口,然后把这个接口的一个对象作为参数传给别人的程序,别人的程序必要时就会通过那个接口来调用你编写的函数。



下面使用java回调函数来实现一个测试函数运行时间的工具类:
如果我们要测试一个类的方法的执行时间,通常我们会这样做:
java 代码

Java代码 复制代码 收藏代码
  1. public class TestObject {     
  2.     /**   
  3.      * 一个用来被测试的方法,进行了一个比较耗时的循环   
  4.      */     
  5.     public static void testMethod(){     
  6.         for(int i=0; i<100000000; i++){     
  7.                  
  8.         }     
  9.     }     
  10.     /**   
  11.      * 一个简单的测试方法执行时间的方法   
  12.      */     
  13.     public void testTime(){     
  14.         long begin = System.currentTimeMillis();//测试起始时间    
  15.         testMethod();//测试方法     
  16.         long end = System.currentTimeMillis();//测试结束时间    
  17.         System.out.println("[use time]:" + (end - begin));//打印使用时间    
  18.     }     
  19.          
  20.     public static void main(String[] args) {     
  21.         TestObject test=new TestObject();     
  22.         test.testTime();     
  23.     }     
  24. }    


大家看到了testTime()方法,就只有"//测试方法"是需要改变的,下面我们来做一个函数实现相同功能但更灵活:
首先定一个回调接口:
java 代码

Java代码 复制代码 收藏代码
  1. public class Tools {     
  2.          
  3.     /**   
  4.      * 测试函数使用时间,通过定义CallBack接口的execute方法   
  5.      * @param callBack   
  6.      */     
  7.     public void testTime(CallBack callBack) {     
  8.         long begin = System.currentTimeMillis();//测试起始时间    
  9.         callBack.execute();///进行回调操作     
  10.         long end = System.currentTimeMillis();//测试结束时间    
  11.         System.out.println("[use time]:" + (end - begin));//打印使用时间    
  12.     }     
  13.          
  14.     public static void main(String[] args) {     
  15.         Tools tool = new Tools();     
  16.         tool.testTime(new CallBack(){     
  17.             //定义execute方法     
  18.             public void execute(){     
  19.                 //这里可以加放一个或多个要测试运行时间的方法     
  20.                 TestObject.testMethod();   
  21.             }     
  22.         });     
  23.     }     
  24.          
  25. }  


通过上面的文字和代码我们可以理解了什么叫做java的回调。那么我们具体在什么时候使用回调函数呢?

在进行JDBC编程的时候,我们经常要写到try catch语句块,而如果采用回调技术,那么完全可以避免重复的去写,将自己的方法体使用一个回调接口的方法来实现,每次都传到同一个try catch当总,但是每一个方法的内容是不相同的。

再比如算法比较多的情况下,也可以采用这种实现模式来实现。最近看了SWT,发现里面好多的事件驱动都是采用回调来实现的。比如给按钮添加事件:

Java代码 复制代码 收藏代码
  1. Button okButton = createButton(buttons, "&Ok""Process input",   
  2.            new MySelectionAdapter(){   
  3.                public void widgetSelected(SelectionEvent e)   
  4.                {   
  5.                    System.out.println("Name:         " + nameField.getText());   
  6.                    System.out.println("Address:      " + addrField.getText());   
  7.                    System.out.println("Phone number: " + phoneField.getText());   
  8.                }   
  9.            });  

匿名内部类最常用的情况就是在回调当中的精彩表现。回调是一种双向调用模式,也就是说,被调用方在接口被调用时也会调用对方的接口。