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()方法，这也是一种双重调用。

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

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。

 

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

 1 public class A implements CallBackInterface{
 2 
 3     public void a() {
 4         new B().b(this);
 5     }
 6     
 7     public void a2(int parm1) {
 8         System.out.println("A类方法中 b() 的返回结果是  :" + parm1); 
 9     }
10 
11     @Override
12     public void callBack(int reInt) {
13 
14         a2(reInt);
15     }
16 }

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

 1 public class C implements CallBackInterface{
 2 
 3     public void c() {
 4         new B().b(this);
 5     }
 6     
 7     public void c2(int parm1) {
 8         System.out.println("C类方法中 b() 的返回结果是  :" + parm1);
 9     }
10     
11     @Override
12     public void callBack(int reInt) {
13         c2(reInt);
14     }
15 
16 }

 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来实现的多线程。

 未完待续...  ...

转载于:https://www.cnblogs.com/leafIcesun/p/11449558.html