【Java入门提高篇】Day4 Java中的回调

  又忙了一周,事情差不多解决了,终于有可以继续写我的博客了(各位看官久等了)。

  这次我们来谈一谈Java里的一个很有意思的东西——回调。

  什么叫回调,一本正经的来讲,在计算机程序设计中,回调函数是指通过函数参数传递到其它代码的,某一块可执行代码的引用。这一设计允许了底层代码调用在高层定义的子程序。

  别急别急,且听我慢慢道来。

  举个栗子,设置这样一个情景,老板安排员工做事,然后让他做完后跟他电话说一声。老板当然不会在那里一直等员工做完事情才去做其他事,而是只交代完任务就去忙自己的事情了。

  这个例子包含了异步+回调的思想,员工做完任务后向老板报告这个过程,就叫回调,当然,报告的话,老板肯定先跟员工说好了报告方式,比如说邮件,电话等,而交代报告方式,就是注册回调函数,这里的回调函数必须符合接口的规范。

  好像还是有些不明白?来上代码吧。

  先定义一个接口:.

public interface ReceiveReport {
    /**
     * 接收报告
     * @param name 员工名称
     * @param report 报告内容
     */
    public void receiveReport(String name,String report);
}

  定义一个Boss类实现这个接收报告的接口:

public class Boss implements ReceiveReport{
    private Worker worker;

    public Boss(Worker worker){
        this.worker = worker;
    }

    /**
     * 下达任务
     */
    public void sendTask(){
        worker.work(this);
    }

    /**
     * 接收报告
     * @param name 员工名称
     * @param report 报告内容
     */
    public void receiveReport(String name,String report){
        System.out.println("收到:"+name+" 的报告:"+report);
    }
}

  定义一个Worker接口:

public interface Worker {
    public void work(ReceiveReport boss);
}

  定义一个员工类。

public class Employee implements Worker{
    private String name;//员工姓名

    //构造器
    public Employee(String name) {
        this.name = name;
    }

    /**
     * 工作
     * @param boss 任务名称
     */
    public void work(ReceiveReport boss){
        System.out.println(name + " is doing works.");
        String report = "我已经完成了任务!";
        boss.receiveReport(name,report);
    }
}

  然后来测试一下:

public class Test {
    public static void main(String[] args) {
        Worker employee = new Employee("Frank");//定义一个员工
        Boss boss = new Boss(employee);//定义一个Boss
        //boss开始下达任务
        boss.sendTask();
    }
}

  测试结果:

Frank is doing works.收到:Frank 的报告:我已经完成了任务!

  至此,员工与老板的交互就完成了,这就是一个简单的同步回调了。Boss通过Worker接口可以给员工安排工作,而不用去关心是哪个员工在工作,Worker通过ReceiveReport来向Boss报告工作情况,两个类通过接口进行回调交互,可以很好的解耦合,因为Boss可以安排不同的员工,只要他们实现了Worker接口就行,而员工也可以向不同的boss汇报情况,只要实现了ReceiveReport接口即可。

其实回调的核心思想就是把自身的this指针传给调用方,就像这里把employee传入Boss类中,在work方法中又注册了回调,于是两者的交互性就很强了。

  那么为什么要用回调呢?如果Boss要在员工完成工作之前登记员工的一些信息,如姓名等,那么有了回调机制,通过把this指针传入,就能在Boss内部为所欲为了,而不需要通过设计新的方法来获取,而且需要获得的数据越多,回调的优势越明显。

  其实这里只是简单的一对一关系,如果是一个Boss,多个员工,那就是简单的观察者模式,如果是多个Boss多个员工,那就是简单生产者-消费者模式了。

  当然,这里仅仅是简单的同步回调。员工只能一个接一个的去完成任务,也就是说前一个员工必须等待后一个员工完成任务后才能开始任务,事实上,员工一般是同时进行工作的。

  如果换一个场景,现在有十个员工,老板发布任务,前三名完成的人有奖金奖励,那么就需要用到异步回调了,sendTask的时候使用线程即可,我们来修改一下代码:

/**
 * @author Frank
 * @create 2017/12/3
 * @description 接收报告接口
 */
public interface ReceiveReport {
    /**
     * 接收报告
     * @param worker 员工
     * @param report 报告内容
     */
    public void receiveReport(Worker worker,String report);
}
/**
 * @author Frank
 * @create 2017/12/3
 * @description 工人接口
 */
public interface Worker {
    public void work(String taskName);
    public void setReceiveReport(ReceiveReport boss);
    public void getReward(Double money);
    public String getName();
}
import java.util.Random;

/**
 * @author Frank
 * @create 2017/12/3
 * @description 员工类
 */
public class Employee implements Worker{
    private ReceiveReport boss;
    private String name;//员工姓名

    @Override
    public String getName() {
        return name;
    }

    //构造器
    public Employee(String name) {
        this.name = name;
    }

    public void setReceiveReport(ReceiveReport boss) {
        this.boss = boss;
    }

    @Override
    public void getReward(Double money) {
        System.out.println(name+"由于表现突出,获得$"+money+"现金奖励!");
    }

    /**
     * 工作
     * @param taskName 任务名称
     */
    public void work(String taskName){
        System.out.println(name + " is doing works:"+taskName);
        Random random = new Random();
        Integer time = random.nextInt(10000);
        try {
            Thread.sleep(time);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        String report = "顺利完成任务!";
        //通知老板
        boss.receiveReport(this,report);
    }
}
import java.util.ArrayList;
import java.util.List;

/**
 * @author Frank
 * @create 2017/12/3
 * @description Boss类
 */
public class Boss implements ReceiveReport{
    private List<Worker> workers = new ArrayList<>();//老板管理的员工
    private volatile int index;//顺序

    /**
     * 添加员工
     * @param worker 员工
     */
    public void addWorker(Worker worker){
        workers.add(worker);
        worker.setReceiveReport(this);
    }

    /**
     * 下达任务
     */
    public void sendTask(String task){
        //给各个员工依次下达任务
        for (Worker w:workers){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    w.work(task);
                }
            }).start();
        }
    }

    /**
     * 接收报告
     * @param worker 员工
     * @param report 报告内容
     */
    public void receiveReport(Worker worker,String report){
        int index = ++this.index;
        System.out.println(worker.getName()+"获得第"+index+"名");
        if (index <= 3){
            //给前三名发奖金
            worker.getReward(1000.0*(4-index));
        }
    }
}
/**
 * @author Frank
 * @create 2017/12/3
 * @description
 */
public class Test {
    public static void main(String[] args) {
        Boss boss = new Boss();//定义一个Boss
        //定义十个员工
        for (int i=0;i<10;i++){
            Worker worker = new Employee("Employee["+i+"]");
            boss.addWorker(worker);
        }
        //boss开始下达任务
        boss.sendTask("Say Hello");

    }
}

  这里没有使用锁,因为设置的时间间隔区间为0-10s,发生并发冲突的概率很低,而且由于现在还没有说多线程的内容,所以暂时先不使用。只需要知道在sendTask方法中,依次启动了线程来调用每个Worker的work方法,线程启动后会同时执行,执行完毕后,又会调用Boss的receiveReport方法来向Boss反馈结果,接收结果后,根据完成顺序,再调用Worker的getReward方法来给前三名发奖金。其实这里是双向回调了,Boss把this指针传给了Worker,Worker又把自己的this指针传给了Worker。

  程序执行结果如下:

Employee[0] is doing works:Say Hello
Employee[4] is doing works:Say Hello
Employee[3] is doing works:Say Hello
Employee[2] is doing works:Say Hello
Employee[1] is doing works:Say Hello
Employee[5] is doing works:Say Hello
Employee[7] is doing works:Say Hello
Employee[6] is doing works:Say Hello
Employee[9] is doing works:Say Hello
Employee[8] is doing works:Say Hello
Employee[9]获得第1名
Employee[9]由于表现突出,获得$3000.0现金奖励!
Employee[7]获得第2名
Employee[7]由于表现突出,获得$2000.0现金奖励!
Employee[3]获得第3名
Employee[3]由于表现突出,获得$1000.0现金奖励!
Employee[1]获得第4名
Employee[0]获得第5名
Employee[5]获得第6名
Employee[4]获得第7名
Employee[8]获得第8名
Employee[6]获得第9名
Employee[2]获得第10名

  因为使用了多线程,所以每次运行的结果可能都会不一样,如果得到了不一样的结果,那是很正常的现象。

  举了这两个栗子,对回调应该也有了一定的了解了吧。

  其实回调只是一种思想,并不是java中独有的内容,思想这种东西,是为了解决特定场景下的特定问题而出现的,只有被正确应用了才有它的价值,而不要为了使用它而使用它。

  至此,回调讲解完毕,如有说明有误的地方,欢迎各位批评指正。也欢迎大家继续关注。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏Java学习网

想成为优秀程序员必知的要点

想成为优秀程序员必知的要点 1.永远不要重复代码 不惜一切代价也要避免重复代码。如果你有几个不同的地方经常性地要使用某个代码片段,那么可以将它重构成函数。代码...

2277
来自专栏从流域到海域

Python 条件判断

Python if语句 格式:注意不要漏写:这是容易犯错的地方。 if语句包含两部分,判断部分和执行部分,只有在判断部分得到的布尔值为True时,才会执行执...

25110
来自专栏偏前端工程师的驿站

JS魔法堂:不完全国际化&本地化手册 之 理論篇

前言  最近加入到新项目组负责前端技术预研和选型,其中涉及到一个熟悉又陌生的需求——国际化&本地化。熟悉的是之前的项目也玩过,陌生的是之前的实现仅仅停留在"有"...

2328
来自专栏Janti

项目心得:广度遍历搜索部门处理业务

部门树节点 平常在做后台管理系统的时候,多多少少都会涉及部门管理,部门有上下级,所以架构会呈现出树形,下图是一个简单的部门节点图: ? 这个和平时的二叉树很像,...

3178
来自专栏瓜大三哥

UVM(十)之config机制续1

UVM(十)之config机制续1 1. 省略get的config config总是set和get成对出现的。在build_phase中,要写上如下的两句话才...

2769
来自专栏编程一生

架构师之路--从原理角度来分析性能

  埃及艳后Cleopatra,很小的时候看过妈妈买的一本书里把她的名字翻译成克娄巴特拉,里面有很多描写她美貌的场景描写。然而这个以美貌著称的奇女子,我看到书里...

942
来自专栏从流域到海域

在美国国会图书馆标题表的SKOS上运行Apache Spark GraphX算法

这是Bob DuCharme的一篇客串文章。

4557
来自专栏小樱的经验随笔

Vijos P1113 不高兴的津津【模拟】

不高兴的津津 描述 津津上初中了。妈妈认为津津应该更加用功学习,所以津津除了上学之外,还要参加妈妈为她报名的各科复习班。另外每周妈妈还会送她去学习朗诵、舞蹈和钢...

2658
来自专栏web前端教室

先行者成员提问--JavaScript的缩进

今天在群里有个同学问,说他给github上的一个项目写了个插件,然后对方说他的插件的空格缩进不对,他就想问问几个空格缩进才对? 先说下我的观点,我是4个空格,并...

2036
来自专栏司想君

前端也要学系列:设计模式之装饰者模式

今天我们来讲另外一个非常实用的设计模式:装饰者模式。这个名字听上去有些莫名其妙,不着急,我们先来记住它的一个别名:包装器模式。

922

扫码关注云+社区

领取腾讯云代金券