java之回调函数

左手的ㄟ右手 2022-05-17 06:37 230阅读 0赞

今天面试碰到了让我写一个回调函数，由于之前听过，但是一直没写过，也没用过所以是一脸懵逼的，今天就来记录下java的回调函数吧，由易到难。

案例一：老板与员工

背景：老板把手中的工作交给了员工去做，自己出去玩了，员工干完之后，通知老板。说也说不清楚，先来看代码。

步骤1：先定义一个包含了回调函数的回调接口，方法就是回调函数。

public interface CallBack {
        //这就是回调函数，回调函数也就是别人干完帮你做的事后，调用你（通知你）。
        public void call(String info);
    }

步骤2：定义一个老板类，该类实现了回调接口的回调函数。

//老板
    public class Boss  implements CallBack{
        //老板持有员工对象
        private Emp emp = new Emp();
    
        public void play() {
    
            System.out.println("我是老板，我去玩了，事情交给你们干了！");
        }
        //本来是老板的一部分工作，老板不想做了，交给员工来干。
        public void doSomething() {
            //因为老板把工作交给你了，自己当然要出去干其他事，所以开启异步。
                new Thread(new Runnable(){
                    public void run() {
                        //传入当前老板的引用，这样才能帮老板做他的事。
                        emp.work(Boss.this);
                    }
                }).start();
                //老板出去玩了，事情已经交代员工了
                this.play();
        }
        //回调函数，做完老板吩咐的事情后，通知老板。（也就是响应）
        public  void call(String info) {
            System.out.println(info);
        }
    }

步骤3：定义一个员工类，该类的一个方法就是自己的工作，也就是帮老板做的事，需要传入一个老板的引用。

//员工
    public class Emp {
        //老板雇我，就是为了让我替他工作，所以work方法中的形参为老板的引用。
        public void  work(CallBack callBack) {
            System.out.println("我接手了老板的这个工作！");
            System.out.println("正在工作中！");
            System.out.println("工作做完了！");
            //工作做完之后呢，需要通知老板，也就是回调
            callBack.call("老板，您吩咐的工作我完成了！");
        }
    }

步骤4：写一个主方法来测试一下。

public class Test {
        public static void main(String[] args) {
            Boss boss = new Boss();
            //把工作交给员工
            boss.doSomething();
        }
    }
    
    
    
    我是老板，我去玩了，事情交给你们干了！
    我接手了老板的这个工作！
    正在工作中！
    工作做完了！
    老板，您吩咐的工作我完成了！

总结：回调对象是work中传入的参数，回调函数是call方法，本来是老板的事情，老板让员工去做了，自己去玩了，员工接手老板的工作，完成后执行了回调函数（通知老板），该回调函数是通过老板的引用去执行的。

是不是看完这个案例后，似乎有点似懂非懂的，那么在来一个案例，请看案例二。

案例二：小白和小黑是舍友，今天小白的快递到了，但是呢，小白在外边兼职，需要小黑去帮忙取快递，取完快递后，小黑发了个QQ告诉小白说，我快递已经帮你取到了。看代码

步骤一：先定义一个回调接口，里面包含回调函数。

public interface CallBack {
        //这就是回调函数，回调函数也就是别人干完帮你做的事后，调用你（通知你）。
        public void call(String info);
    }

步骤二：新建一个小白类，实现回调接口，并且含有小黑的引用。

//我是小白，同样也需要实现回调接口
    public class SmallWhite implements CallBack{
        //我持有小黑的引用，因为我需要他的帮助
        private SmallBlack smallBlack = new SmallBlack();
        //求助小黑
        public void help() {
            System.out.println("我是小白，我的快递到了，我在外边兼职，取不了，你帮我取吧！");
            //开启多线程，因为小白还要继续做他的兼职
            new Thread(new Runnable() {
                public void run() {
                    //传入小白的引用
                    smallBlack.getExpress(SmallWhite.this);
                }
            }).start();
            //事情吩咐完毕，小白继续干活
            work();
        }
    
        public void work() {
            System.out.println("继续兼职！");
        }
    
        public void call(String info) {
            System.out.println("我知道了，谢谢你！");
        }
    }

步骤三：新建小黑类，包含一个含有小白引用作为形参的方法，因为要回调它，所以必须含有。

//我是小黑
    public class SmallBlack {
    
        //取快递，同样需要小白的引用.
        public void getExpress(CallBack callBack) {
            System.out.println("我是小黑，我去取快递了！");
            System.out.println("取到快递，通知小白！");
            //回调函数，调用小白的call方法。
            callBack.call("快递已经帮你取到了！");
        }
    }

步骤四：测试

public class Test {
        public static void main(String[] args) {
            SmallWhite smallWhite = new SmallWhite();
            //叫小黑帮忙去快递
            smallWhite.help();
        }
    }
    
    
    
    
    
    
    
    
    我是小白，我的快递到了，我在外边兼职，取不了，你帮我取吧！
    继续兼职！
    我是小黑，我去取快递了！
    取到快递，通知小白！
    我知道了，谢谢你！

总结：置于有些人会问，貌似这好像不用实现接口吧，那是因为我们只在两个类之间讨论，如果此时小黑的另外一个舍友，小明也需要小黑帮忙取快递，那么这个接口就是必须的了，因为java只支持单继承，能实现接口的情况下，优先考虑接口。

回调其实就是，一些类（类A）实现了回调接口之后，它包含着另外一个类（类B）的引用，类B中含有一个类A作为形参的方法，调用该方法后就能获得到类A的引用，也就才能调用类A的回调方法。如果不理解的话，直接这么记即可。