Java基础12-深入理解Java中回调机制（二 ）

public class XiaoMing { 
   //小明和小李一起吃饭
   public void eatFood() {
      XiaoLi xl = new XiaoLi();
      //A调用B的方法
      xl.washFace();
   }
 
   public void eat() {
      System.out.print("小明和小李一起去吃大龙虾");
   }
}
那么怎么让小李洗漱完后在通知小明一起去吃饭呢

public class XiaoMing { 
   //小明和小李一起吃饭
   public void eatFood() {
      XiaoLi xl = new XiaoLi();
      //A调用B的方法
      xl.washFace();
      eat();
   }
 
   public void eat() {
      System.out.print("小明和小李一起去吃大龙虾");
   }
}复制代码

public class XiaoLi{//小李
   public void washFace() {
    System.out.print("小李要洗漱");
    XiaoMing xm = new XiaoMing();
        //B调用A的方法
    xm.eat();//洗漱完后，一起去吃饭
   }
}复制代码

public interface EatRice {
   public void eat(String food);
}
小明：

public class XiaoMing implements EatRice{//小明
    
   //小明和小李一起吃饭
   public void eatFood() {
    XiaoLi xl = new XiaoLi();
    //A调用B的方法
    xl.washFace("大龙虾", this);//this指的是小明这个类实现的EatRice接口
   }
 
   @Override
   public void eat(String food) {
    // TODO Auto-generated method stub
    System.out.println("小明和小李一起去吃" + food);
   }
}
小李:

public class XiaoLi{//小李
   public void washFace(String food,EatRice er) {
    System.out.println("小李要洗漱");
        //B调用了A的方法
    er.eat(food);
   }
}
测试Demo:

public class demo {
   public static void main(String args[]) {
    XiaoMing xm = new XiaoMing();
    xm.eatFood();
   }
}复制代码

public class XiaoWang implements EatRice{//小王
    
   //小王和小李一起去上网
   public void eatFood() {
    XiaoLi xl = new XiaoLi();
    //A调用B的方法
    xl.washFace("轻舞飞扬上网", this);
   }
 
   @Override
   public void eat(String bar) {
    // TODO Auto-generated method stub
    System.out.println("小王和小李一起去" + bar);
   }
}复制代码

    //回调指的是A调用B来做一件事，B做完以后将结果告诉给A，这期间A可以做别的事情。
    //这个接口中有一个方法，意为B做完题目后告诉A时使用的方法。
    //所以我们必须提供这个接口以便让B来回调。
    //回调接口，
    public interface CallBack {
        void tellAnswer(int res);
    }复制代码

    //老师类实例化回调接口，即学生写完题目之后通过老师的提供的方法进行回调。
    //那么学生如何调用到老师的方法呢，只要在学生类的方法中传入老师的引用即可。
    //而老师需要指定学生答题，所以也要传入学生的实例。
public class Teacher implements CallBack{
    private Student student;

    Teacher(Student student) {
        this.student = student;
    }

    void askProblem (Student student, Teacher teacher) {
        //main方法是主线程运行，为了实现异步回调，这里开启一个线程来操作
        new Thread(new Runnable() {
            @Override
            public void run() {
                student.resolveProblem(teacher);
            }
        }).start();
        //老师让学生做题以后，等待学生回答的这段时间，可以做别的事，比如玩手机.\
        //而不需要同步等待，这就是回调的好处。
        //当然你可以说开启一个线程让学生做题就行了，但是这样无法让学生通知老师。
        //需要另外的机制去实现通知过程。
        // 当然，多线程中的future和callable也可以实现数据获取的功能。
        for (int i = 1;i < 4;i ++) {
            System.out.println("等学生回答问题的时候老师玩了 " + i + "秒的手机");
        }
    }

    @Override
    public void tellAnswer(int res) {
        System.out.println("the answer is " + res);
    }
}复制代码

    //学生的接口，解决问题的方法中要传入老师的引用，否则无法完成对具体实例的回调。
    //写为接口的好处就是，很多个学生都可以实现这个接口，并且老师在提问题时可以通过
    //传入List<Student>来聚合学生，十分方便。
public interface Student {
    void resolveProblem (Teacher teacher);
}复制代码

public class Tom implements Student{

    @Override
    public void resolveProblem(Teacher teacher) {
        try {
            //学生思考了3秒后得到了答案，通过老师提供的回调方法告诉老师。
            Thread.sleep(3000);
            System.out.println("work out");
            teacher.tellAnswer(111);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }复制代码

public class Test {
    public static void main(String[] args) {
        //测试
        Student tom = new Tom();
        Teacher lee = new Teacher(tom);
        lee.askProblem(tom, lee);
        //结果
//        等学生回答问题的时候老师玩了 1秒的手机
//        等学生回答问题的时候老师玩了 2秒的手机
//        等学生回答问题的时候老师玩了 3秒的手机
//        work out
//        the answer is 111
    }
}