什么是接口回调（一）

在架构师的进阶道路上，离不开源码的阅读，离不开设计模式的熏陶，更离不开思想的传递，本章带你走进接口回调的设计道路！

1、什么是接口

这里简单复习下接口定义和概念：

• 接口用interface关键字声明
• 接口不是类，是一组对类的需求描述，当中定义了很多统一的规范和协议
• 实现接口的类，必须要按照接口统一制定的标准去编写
• 更确切来说，接口是建立类的协议

2、接口特性

• 接口不能够new对象，他本身不是对象类，所谓对象类是不能直接new出的，所以存在多态
• 接口里面的方法，是没有方法体的{}
• 接口的实现类必须实现接口里的所有方法
• 接口的所有修饰字只能为public，接口不能有实例，但是去可以声明接口变量，只不过变量必须指向实现类
• 接口可以有多个实现类，实现类也可以引用多个接口，但抽象类的子类只能继承一个父类

等等上述的特性

3、接口实现

//接口
public interface Round {
   public static final double PI=3.1415;

   int getId();

   void setId(int id);

}
//实现类
public class RoundImpl implements Round {
    @Override
    public int getId() {
        return 0;
    }
    @Override
    public void  setId(int id) {
    }
}

4、接口回调

• 接口回调：

通俗说法：有个接口A，还有个A的实现类AImpl，而AImpl中有个方法a()和方法c()；

有个B类，B类中有个b()方法；

AImpl通过方法a，调用B类的b方法，然后B类的方法b判断后，是否回调AImpl的c()方法；

• 同步回调：

方法b中的逻辑执行完再去执行方法c();

• 异步回调：

b方法和c方法一起再执行

这个描述比较清晰，我们举个例子看下代码

接口A我们定义成CallBack回调接口

public interface CallBack {

    /**
     * 收到钱后的思考方法
     * @param money
     * @return
     */
    boolean consider(int money);

    /**
     * 思考后要不要付钱
     *
     * @param money
     */
    void payFor(int money);
}

AImpl定义成乘客Passenger

public class PassengerImpl implements CallBack {

    /**
     * 司机告诉乘客多少钱
     * 乘客来考虑是否可以
     * @param money
     * @return
     */
    @Override
    public boolean consider(int money) {
        boolean result = true;
        //如果钱大于80块，嫌贵，表示拒绝思考
        if (money > 80) {
            result = false;
            System.out.println(money + "太贵了，你看80可以去吗？");
        }
        return result;
    }

    /**
     * 乘客考虑是不是需要给钱给司机
        这里理解为c方法
     * @param money
     */
    @Override
    public void payFor(int money) {
        System.out.println("ok, 钱给你" + money);
    }

    /**
     * 另起一个方法做为一开始的调用者
     * 这里就是A类的方法 a()
     */
    public void takeTaxi(Driver driver){
        System.out.println("师傅，去三亚一天多少钱？");
        //A类的a方法调用B类的b方法
        driver.answer(this);
    }
}

B类定义成司机Driver类

/**
 * @Author: chenxin
 * @Date: 2021/2/21 9:06
 * @Description
 * 这是司机类，可以作为B类，里面有个B方法
 */
public class Driver {

    /**
     * 这个作为B类的b方法
     * @param callBack
     */
    public void answer(CallBack callBack){
        System.out.println("去那里要100块的!");
        if(callBack.consider(100)){
            //回调A类的c方法
            callBack.payFor(100);
        }
    }
}

main测试下

public class Main {
    public static void main(String[] args) {

        PassengerImpl passenger = new PassengerImpl();
        Driver driver = new Driver();
        passenger.takeTaxi(driver);
    }
}

我们仔细分析下：

• 乘客先发起了a方法的请求，实际是takeTaxi方法，为了避免我们在A类中耦合B类对象，所以传入方法参数是Driver对象
• a方法调用司机的answer方法（b方法），answer方法传入的刚好是实现类本身
• answer方法作为回答，说要100块，并且调用A的某个函数consider传入司机要求的钱，判断是不是需要回去调用A实现类的c方法（payFor）
• 司机太贪了所以没能调用payFor

师傅，去三亚一天多少钱？
去那里要100块的!
100太贵了，你看80可以去吗？

那什么是同步回调？

方法b中的逻辑执行完再去执行方法c()；也就是等待司机回答answer多少钱，问乘客满不满意consider，再去考虑回调不回调用c方法（payFor）

上述的就是同步执行，总不能钱都没问直接上车吧？

那什么是异步回调？

b方法和c方法一起再执行，c不用等待b结束，就可以直接执行

意思是，payFor付钱这个操作，不需要等待一个司机答复，都去问不同的司机，哪个司机回答可以，哪个司机就去回调c的方法

当然这里代码我就没多写，等第二节我再详细以源码为例子，深入讲解接口回调的操作！！！

本节只是你熟悉下接口回调的思想，下一节走进源码讲解接口回调！！