个人中心
gpt4 book ai didi

Java中的回调

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 24 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java中的回调由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

　　又忙了一周，事情差不多解决了，终于有可以继续写我的博客了（各位看官久等了）.

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

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

　　别急别急，且听我慢慢道来.

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

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

　　好像还是有些不明白？来上代码吧.

　　先定义一个接口：. 。

?
1
2
3
4
5
6
7
8
public interface ReceiveReport {
   /**
    * 接收报告
    * @param name 员工名称
    * @param report 报告内容
    */
   public void receiveReport(String name,String report);
}

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

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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接口:

?
1
2
3
public interface Worker {
   public void work(ReceiveReport boss);
}

　　定义一个员工类.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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);
   }
}

　　然后来测试一下:

?
1
2
3
4
5
6
7
8
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的时候使用线程即可，我们来修改一下代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  * @author Frank
  * @create 2017/12/3
  * @description 接收报告接口
  */
public interface ReceiveReport {
   /**
    * 接收报告
    * @param worker 员工
    * @param report 报告内容
    */
   public void receiveReport(Worker worker,String report);
}
?
1
2
3
4
5
6
7
8
9
10
11
/**
  * @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();
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
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);
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
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));
     }
   }
}
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
  * @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中独有的内容，思想这种东西，是为了解决特定场景下的特定问题而出现的，只有被正确应用了才有它的价值，而不要为了使用它而使用它.

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

以上就是Java中的回调的详细内容，更多关于Java 回调的资料请关注我其它相关文章！ 。

原文链接：https://cloud.tencent.com/developer/article/1016595 。

最后此篇关于Java中的回调的文章就讲到这里了,如果你想了解更多关于Java中的回调的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

24 4 0
文章推荐： java实现相同属性名称及相似类型的pojo、dto、vo等互转操作
文章推荐： iOS通过摄像头图像识别技术分享
文章推荐： 仿IOS的越界回弹效果和左右滑动功能
文章推荐： 详细分析Java内部类——局部内部类
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com