Java回调与接口

有类A和类B，分别有a();和b();方法。其中a()中会调用b()方法

 1 public class A {
 2 
 3     public void a() {
 4         new B().b();
　　　　　　 a2();
 5     }
 6     
 7     public void a2() {
 8         System.out.println("a2 is running");
 9     }
10 }

public class B {

    public void b() {
        System.out.println("b is running");
    }
}

如果b()方法的执行时间较短的话，可以不用管其他，这样调用就好。但是，如果执行时间较长的话，a()方法里往下的代码无法继续执行，会一直等待b()方法执行完事。这就是方法的同步调用。
缺点是，一个方法执行时间长或阻塞，会造成整个a()方法的流程阻塞。那么，为解决这个问题，就出现了方法的异步调。

异步调用

 类A的a()方法可以采用另起线程的方式来调用b()方法。

这中方式也会有种问题，如果b()的执行结果不影响a()方法中下面的执行，就这样调用就好，但是，如过下面的代码需要b()返回的结果，则必须通过什么途径对b()方法执行结果进行监听，java中可以通过Future+Callable的方式可以

实现这一点（实现方式稍后解释）。

这里呢，我们可以简单的给A类放一个callBack()函数，来当作回调函数。每次b()方法执行完就会主动调用A类的callBack()方法，这也是一种双重调用。

public class A {

    public void a() {
        new B().b(this);
    }
    
    public void a2() {
        System.out.println("a2 is running");
    }
    
    public void callBack() {
        System.out.println("callback is running");
    }
}

1 public class B {
2 
3     public void b(A a) {
4         System.out.println("b is running");
5         //通知A我执行完了
6         a.callBack();
7     }
8 }

     但是以上场景适合于只有A来调用B的b()方法，而也是只通知了A。如果有跟A类一样，都需要调用b()方法，且要实时等待b()的执行结果，怎么办？

不可能也N个b(A a); b(C c);等等诸如此类的方法吧，

OK，针对这种需要多态的应用场景，我们的接口自然而然地就要上了，我们可以把回调这一行为抽象出来，让所有要调用b()方法的类都去实现这个抽象。

场景：A，C，D都有一个方法需要B的b()方法，而且都需要的b()的返回结果干一些事情。

  那么我们就可以来抽象一下前面三个类的行为了。

 首先，我们把A，C, D中需要b的返回结果做其他事的方法都抽象到一个接口中，就叫它callBack。

 

public interface CallBackInterface {
    public void callBack(int reInt);
}

public class A implements CallBackInterface{

    public void a() {
        new B().b(this);
    }
    
    public void a2(int parm1) {
        System.out.println("A类方法中 b() 的返回结果是  :" + parm1); 
 9     }

    @Override
    public void callBack(int reInt) {

        a2(reInt);
    }
}

public class B {

    public void b(CallBackInterface tmp) {
        System.out.println("b is running");
        int result = 10;
        //通知A我执行完了
        tmp.callBack(result);
    }
}

public class C implements CallBackInterface{

    public void c() {
        new B().b(this);
    }
    
    public void c2(int parm1) {
        System.out.println("C类方法中 b() 的返回结果是  :" + parm1);
    }
    
    @Override
    public void callBack(int reInt) {
        c2(reInt);
    }

}

 1 public class Main {
 2 
 3     public static void main(String[] args) {
 4         
 5         A tmA = new A();
 6         
 7         tmA.a();
 8         
 9         C tmC = new C();
10         
11         tmC.c();
12     }
13 
14 }

运行结果：

接下来再说明一下，java中用Future模式和Callable来实现的多线程。

 未完待续...  ...