内部类使用场景：供外部类使用，回调_class内部类返回外部类-优快云博客

我们说这个内部类依附于它的外部类而存在，可能的原因有：
1、不可能为其他的类使用；
2、出于某种原因，不能被其他类引用，可能会引起错误。
3、当前的类过大，比如某个方法，里面写了非常多的代码，需要重构，如果你想抽象到另外一个类里面，那么不妨考虑一下内部类，因为，这些代码是从当前类抽象出来的，只被当前类所使用，那么用内部类实现也是很好的。下面我们以一个大家熟悉的例子来说明。

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

Java代码

public class SendSms implements SpInfo
{
public String sendSms(String userID,String productID,int OPType)
{
String res = null;
。。。
SendSms.AddressBean ab = new SendSms.AddressBean();//获得内部类的实例
//用内部类来加工处理用户号码
org.apache.axis.types.URI[] addressesuri = ab.getDownAddress(userID);
。。。
//下面开始组织soapheader，此处也可以用内部类来实现的。
RequestSOAPHeader soapHeader = DownHeader.downHeader_ismp(productID, addressesuri);
。。。
SMS downsms = new SMS();
res = downsms.sendSMS(addressesuri, senderName, charging, down_message,
receiptRequest, soapHeader);
return res;
}

public class SendSms implements SpInfo
{
          public String sendSms(String userID,String productID,int OPType)
          {
                  String res = null;
                  。。。
                  SendSms.AddressBean ab = new SendSms.AddressBean();//获得内部类的实例
                  //用内部类来加工处理用户号码
                  org.apache.axis.types.URI[] addressesuri = ab.getDownAddress(userID);
                  。。。

                  //下面开始组织soapheader，此处也可以用内部类来实现的。
                  RequestSOAPHeader soapHeader = DownHeader.downHeader_ismp(productID, addressesuri);
                  。。。
                  SMS downsms = new SMS();
                  res = downsms.sendSMS(addressesuri, senderName, charging, down_message,
                  receiptRequest, soapHeader);
              return res;
          }

Java代码

//内部类----此类只被当前的外部类所使用
public class AddressBean
{
public org.apache.axis.types.URI[] getDownAddress(String senderAddress)
{
org.apache.axis.types.URI[] addressesuri = null;
String proaddress = "tel:" + senderAddress;
String[] address = new String[] {proaddress};
addressesuri = new org.apache.axis.types.URI[address.length];
try
{
for (int i = 0; i < address.length; i++)
{
addressesuri[i] = new URI(address[i]);
}
}catch(Exception ex)
{
ex.printStackTrace();
}
return addressesuri;
}
}
}

          //内部类----此类只被当前的外部类所使用
          public class AddressBean
          {
                  public org.apache.axis.types.URI[] getDownAddress(String senderAddress)
                  {
                          org.apache.axis.types.URI[] addressesuri = null;
                          String proaddress = "tel:" + senderAddress;
                          String[] address = new String[] {proaddress};
                          addressesuri = new org.apache.axis.types.URI[address.length];
                          try
                           {
                                   for (int i = 0; i < address.length; i++)
                                   {
                                            addressesuri[i] = new URI(address[i]);
                                   }
                           }catch(Exception ex)
                           {
                                   ex.printStackTrace();
                           }
                          return addressesuri;
                  }
          }
}

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

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

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

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

Java代码

public class TestObject {
/**
* 一个用来被测试的方法，进行了一个比较耗时的循环
*/
public static void testMethod(){
for(int i=0; i<100000000; i++){
}
}
/**
* 一个简单的测试方法执行时间的方法
*/
public void testTime(){
long begin = System.currentTimeMillis();//测试起始时间
testMethod();//测试方法
long end = System.currentTimeMillis();//测试结束时间
System.out.println("[use time]:" + (end - begin));//打印使用时间
}
public static void main(String[] args) {
TestObject test=new TestObject();
test.testTime();
}
}

public class TestObject {  
    /** 
     * 一个用来被测试的方法，进行了一个比较耗时的循环 
     */  
    public static void testMethod(){  
        for(int i=0; i<100000000; i++){  
              
        }  
    }  
    /** 
     * 一个简单的测试方法执行时间的方法 
     */  
    public void testTime(){  
        long begin = System.currentTimeMillis();//测试起始时间  
        testMethod();//测试方法  
        long end = System.currentTimeMillis();//测试结束时间  
        System.out.println("[use time]:" + (end - begin));//打印使用时间  
    }  
      
    public static void main(String[] args) {  
        TestObject test=new TestObject();  
        test.testTime();  
    }  
}

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

Java代码

public class Tools {
/**
* 测试函数使用时间，通过定义CallBack接口的execute方法
* @param callBack
*/
public void testTime(CallBack callBack) {
long begin = System.currentTimeMillis();//测试起始时间
callBack.execute();///进行回调操作
long end = System.currentTimeMillis();//测试结束时间
System.out.println("[use time]:" + (end - begin));//打印使用时间
}
public static void main(String[] args) {
Tools tool = new Tools();
tool.testTime(new CallBack(){
//定义execute方法
public void execute(){
//这里可以加放一个或多个要测试运行时间的方法
TestObject.testMethod();
}
});
}
}

public class Tools {  
      
    /** 
     * 测试函数使用时间，通过定义CallBack接口的execute方法 
     * @param callBack 
     */  
    public void testTime(CallBack callBack) {  
        long begin = System.currentTimeMillis();//测试起始时间  
        callBack.execute();///进行回调操作  
        long end = System.currentTimeMillis();//测试结束时间  
        System.out.println("[use time]:" + (end - begin));//打印使用时间  
    }  
      
    public static void main(String[] args) {  
        Tools tool = new Tools();  
        tool.testTime(new CallBack(){  
            //定义execute方法  
            public void execute(){  
                //这里可以加放一个或多个要测试运行时间的方法  
                TestObject.testMethod();
            }  
        });  
    }  
      
}

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

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

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

Java代码

Button okButton = createButton(buttons, "&Ok", "Process input",
new MySelectionAdapter(){
public void widgetSelected(SelectionEvent e)
{
System.out.println("Name: " + nameField.getText());
System.out.println("Address: " + addrField.getText());
System.out.println("Phone number: " + phoneField.getText());
}
});

                            Button okButton = createButton(buttons, "&Ok", "Process input",
                                       new MySelectionAdapter(){
                                           public void widgetSelected(SelectionEvent e)
                                           {
                                               System.out.println("Name:         " + nameField.getText());
                                               System.out.println("Address:      " + addrField.getText());
                                               System.out.println("Phone number: " + phoneField.getText());
                                           }
                                       });

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