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

最新推荐文章于 2024-10-30 18:07:32 发布

qq_38432159

最新推荐文章于 2024-10-30 18:07:32 发布

阅读量97

点赞数

文章标签： 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名