关于java接口回调的一个疑惑！

Question

   RT
     1.我一直以来认为 接口什么都没有实现，而去回调又有什么作用？
  
     2.是不是每个类实现接口的时候都会去调用哪个接口？         忘各位给予详细解析。小弟先谢谢了！！

Answer 1

我博客上有篇文章，楼主去看下。我只把里面的小例子贴出来。CSDN博客格式太恶心。我修改下。
http://blog.csdn.net/youjianbo_han_87/archive/2010/08/03/5784322.aspx
   1. interface  CallBack{   
   2.     public   void  doCRUD();   
   3. }  
   4.   
   5. public   class  HibernateTemplate {   
   6.       
   7.     public   void  execute(CallBack action){  
   8.         getConnection();  
   9.         action.doCRUD();  
  10.         releaseConnection();  
  11.     }  
  12.    
  13.     public   void  add(){  
  14.          execute(new  CallBack(){  
  15.             public   void  doCRUD(){  
  16.                 System.out.println("执行add操作..." );  
  17.             }  
  18.          });  
  19.     }  
  20.       
  21.     public   void  delete(){  
  22.          execute(new  CallBack(){  
  23.             public   void  doCRUD(){  
  24.                 System.out.println("执行delete操作..." );  
  25.             }  
  26.          });  
  27.     }   
  28.   
  29.     public   void  getConnection(){  
  30.         System.out.println("获得连接..." );  
  31.     }  
  32.       
  33.     public   void  releaseConnection(){  
  34.         System.out.println("释放连接..." );  
  35.     }  
  36.       
  37. }  

Answer 2

我们在看spring中有部分说到持久层，其中有个类JdbcTemplate，它是利用Template模式。Template模式就是说：在父类中定义一个操作算法或操作顺序，而将一些步骤的具体实现延迟到子类中。请看列子：// TemplateTest.javapackage com.designpattern.template;   
  
/**  
 * 父类  
 */  
abstract class SuperTemplate {   
    public abstract Object doInTransaction();   
  
    public void execute() {   
        try {   
            System.out.println("事务开始");   
            System.out.println("开始执行业务逻辑代码");   
            doInTransaction();   
            System.out.println("业务逻辑处理完成，提交事务");   
        } catch (Exception e) {   
            System.out.println("出现错误，回滚");   
        }   
    }   
}   
  
/**  
 * 子类  
 */  
class SubTemplate extends SuperTemplate {   
  
    public Object doInTransaction() {   
        System.out.println("正在执行业务逻辑代码");   
        // 事务出错代码   
        // int i = 1/0;   
        return null;   
    }   
}   
  
public class TemplateTest {   
    public static void main(String[] args) {   
        SubTemplate s = new SubTemplate();   
        s.execute();   
    }   
}  首先在父类SuperTemplate中定义两个方法：doInTransaction()和execute()，execute()方法用来执行事务，doInTransaction()是事务的具体操作，但是doInTransaction()是个抽象方法，并没有具体的行为，它把行为交给了它的子类SuperTemplate ，子类中重写这个方法，然后在测试类中调用SubTemplate.execute()方法就行了。
除此之外，还有一种回调形式是利用接口回调函数，例子： 
// TemplateTest2.javapackage com.designpattern.template;/**
 * 回调接口
 */
interface TestTemplateCallBack {
Object doSomething();
}class Template2 { /**
 * 执行业务逻辑的方法，参数类型为接口对象
 * 
 * @param callBack:TestTemplateCallBack接口对象
 */
public void execute(TestTemplateCallBack callBack) {
try {
System.out.println("事务开始");
System.out.println("开始执行业务逻辑");
callBack.doSomething();
System.out.println("业务逻辑执行成功，提交事务");
} catch (Exception e) {
System.out.println("出现错误，回滚");
e.printStackTrace();
}
}
}public class TemplateTest2 {
public void insert(final String msg) {
Template2 t = new Template2();
// 匿名内部类重写方法
t.execute(new TestTemplateCallBack() {
public Object doSomething() {
// 事务出错代码
// int i = 1 / 0;
System.out.println("插入数据:" + msg);
return null;
}
});
} public static void main(String[] args) {
TemplateTest2 t = new TemplateTest2();
t.insert("Hello");
}
}在这里申明一个接口，里面有个方法doSomething()。Template2 这个类中的execute()方法用来执行事务，其中有个参数：execute(TestTemplateCallBack callBack)，参数类型为之前定义的接口对象，然后就可以利用这个对象来调用doSomething()方法。但是doSomething()方法具体的操作内容在哪呢？它在TemplateTest2的insert()方法里面，这里在TemplateTest2类中定义一个insert()方法，接着申明一个Template2对象t，当执行t.execute()方法的时候，这时我们写个匿名类来当传入参数，这匿名类就是之前的接口，在匿名类中重写doSomething()方法就可以实现具体操作了。实际的列子可以参考spring源码中的JdbcTemplate类。

Answer 3

接口则是 以interface 为关键字.相当于一个抽象类.内部只有一些空的方法或空的构造函数继承接口则需要重写这些方法或构造函数.就是那么简单,如果你还不明白可以再上网查查其他的资料~

Answer 4

肯定不会让接口执行回调方法啊，肯定是实现接口的类去执行相应的回调方法。比如：interface CallBack{
    void do();
}class Caller{
    void call(CallBack callBack){
        callBack.do();
    }
}
肯定是实现了CallBack接口的类作为参数传到了CallBack里面去，他会执行那个类do方法的版本。至于为啥要这样做：举个例子来说：
比如有个智能手机类，实现了回调接口，那这个类就要实现自己的回调方法。
他给另一个手机发短信，调用了发短信方法，发短信方法有一个布尔返回值来返回是否发成功了。
问题来了，我发完短信不能一直等着返回值（是否成功）啥都不干呀，那么我就必须要让实现发短信方法的那个类做完了以后再通知智能手机类，这样智能手机类就可以在接到状态之前做自己的事情啦。
这样就实现了异步，大家都是自己干自己的事情，你让我做的事情我做完了再告诉你，我做的这段时间你也可以干自己的事情。另外不同的智能手机回调方法（也就上例中说到发完短信你通知我）都有自己的实现方式，但让发短信那个类来看的话，都是智能手机，都能回调，我就调智能手机的回调方法吧，至于具体回调方法里面做了啥我不关心，由具体的智能手机来确定。第二个问题没看懂，实现接口和调用接口是两回事吧~~

Answer 5

借口说白了就是Java的一个特性， 多肽的发展，动态绑定~~~

Answer 6

1.你说的回调是说动态代理吗？（简单的接口理解你不会真的不会吧O(∩_∩)O~）
2.有标志性接口如Serializable,不需要具体实现某个方法，当然大部分接口你实现了必须得重写它要求的方法，但不一定都会回调，还要看具体的情况，如多线程的Runnable接口...

Answer 7

接口里确实什么都没写，但LZ是纳闷为什么什么都没写，但是能做一些事情呢？
因为接口只是做了个标志，Java动态绑定，真正做的事情是实现了接口的实现类里的
比如Java API里的 List,像下面的方法public void doSomething(List l) {
       l.add("hello");
}但其实真正传入的 l 它是List的一个实现，比如一个ArrayList,LinkedList etc.
这样做，你就不用再写成public void doSomething(ArrayList l) {
       l.add("hello");
}public void doSomething(LinkedList l) {
       l.add("hello");
}