java回调函数

程序A在程序中预留一个接口，程序B可以通过实现该接口，写入自己的逻辑，程序A在执行过程中会调用其接口的实现B的逻辑。

通俗例子：

小明做作业，其中有道题目不会做，打电话告诉小红，让小红做好后主动发给自己。

其中有道不会做的题目可以理解为一个回调函数，小红通过实现该函数可以去完成这道题目，小明只需要获取该回调函数的结果即可获得该题的答案。

public class A {
    IcallBack icallBack;
    public void setCallBack(IcallBack icallBack) {
        this.icallBack = icallBack;
    }
    public String call(String hello) {
        return icallBack.test(hello);
    }
}

interface IcallBack {
    public String test(String hello);
}

public class B implements IcallBack{

    @Override
    public String test(String hello) {
        System.out.println(hello);
        return hello;
    }
}

public class Main {
    public static void main(String[] args) {
        A a = new A();
        a.setCallBack(new B());
        a.call("hello");
    }

}

概念：

小明在完成作业过程中，不必等待小红某道题的结果，只需通过多线程调用回调函数的结果，等小红做好会自动返回该题结果，小明可以并行去做其他题。

public class XiaoMing {
    Work work;
    public void doWork() {
        
        new Thread(() -> {
            System.out.println("小红开始做...");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            work.doSomething("1+1");
            System.out.println("小红做完了");
        }).start();
        System.out.println("小明  do work...");
    }
    
    public void setWork(Work work) {
        this.work = work;
    }
}

interface Work {
    public String doSomething(String problem);
}

public class XiaoHong implements Work{
    @Override
    public String doSomething(String problem) {
        if (problem.equals("1+1")) {
            System.out.println("结果是2");
            return "2";
        } else {
            //其他情况都返回0
            return "0";
        }
    }
}

public class Main {
    public static void main(String[] args) throws Exception {
        XiaoHong xiaoHong = new XiaoHong();
        XiaoMing xiaoMing = new XiaoMing();
        xiaoMing.setWork(xiaoHong);
        xiaoMing.doWork();
    }
}