51Testing软件测试论坛

标题: Java中如何实现回调函数让事实告诉你 [打印本页]
作者: lsekfe    时间: 2022-10-21 13:53
标题: Java中如何实现回调函数让事实告诉你
最近工作需要研究了一会别人写的库，其中充满着各种"回调函数"，因此把自己理解给记录下来，存档。
　　首先我们来看看回调函数 这个概念的具体由来，百度百科的示义如下：
　　回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。
　　从上面的这段阐述之中，我们不难发现两点。
　　函数回调就是将函数指针的地址当作参数传递给另一个函数。
　　函数回调的用途简单来说就是进行事件的响应或者事件触发。
　　既然我们知道回调函数的用途是事件的响应，那么我们就从这里入手。
　　假设我们有这样一个场景，一家人坐在一起吃饭，但是我们中国的规矩是，长辈没动筷子，小辈们是不能动的，所以必须等着长辈动筷子这一事件完成之后，小辈们才能开始。
　　接下来我们就用回调函数来解决。由于java中没有指针一说，故而也没了*，但是java提供了 接口帮我们实现 回调函数，俗称 接口回调。
　　首先我们分别创建一个，父亲，儿子，姐姐对象。
  1. <font size="3">package zt;




  6. /**

  8. * 接口回调

  10. */

  12. public final class App {

  14.     public static void main(String[] args) {

  16.         

  18.     }

  20. }

  22. /**

  24. * 父亲类，里面有个start函数，表示开始动筷子

  26. */

  28. class Father{

  30.     private void start(){

  32.         System.out.print("父亲开始动筷子了");

  34.     }

  36. }

  38. /**

  40. * 儿子类，里面有个start函数，表示开始动筷子

  42. */

  44. class Son{

  46.     private void start(){

  48.         System.out.print("儿子可以开始动筷子了");

  50.     }

  52. }

  54. /**

  56. * 姐姐类，里面有个start函数，表示开始动筷子

  58. */

  60. class Sister{

  62.     private void start(){

  64.         System.out.print("姐姐可以开始动筷子了");

  66.     }

  68. }</font>
复制代码
创建好之后，我们要实现，当父亲开始动筷子之后，姐姐和弟弟才能开始动筷子。也就是我们必须将父亲动筷子这个事件传递给姐姐和弟弟对象。
　　所以按照逻辑，这个父亲有一个儿子，一个女孩，并且父亲开始动筷子了，他们两个才可以动。代码如下：

  1. <font size="3">package zt;




  6. /**

  8. * 接口回调

  10. */

  12. public final class App {

  14.     public static void main(String[] args) {

  16.         new Father(new Son(),new Sister()).start();;

  18.     }

  20. }




  25. interface Start{

  27.     void Fstart(Object obj);

  29. }




  34. /**

  36. * 父亲类，里面有个start函数，表示开始动筷子

  38. */

  40. class Father{




  45.     private Sister sister;

  47.     private Son son;




  52.     Father(Son son,Sister sister){

  54.         this.son= son;

  56.         this.sister = sister;

  58.     }




  63.     public void start(){

  65.         System.out.println("父亲开始动筷子了");

  67.         son.Fstart("父亲动了筷子");

  69.         sister.Fstart("父亲动了筷子");

  71.     }

  73. }

  75. /**

  77. * 儿子类，里面有个start函数，表示开始动筷子

  79. */

  81. class Son implements Start{

  83.     private void start(){

  85.         System.out.println("儿子可以开始动筷子了");

  87.     }




  92.     @Override

  94.     public void Fstart(Object obj) {

  96.         if(obj.toString().equals("父亲动了筷子")){

  98.             start();

  100.         }

  102.     }

  104. }

  106. /**

  108. * 姐姐类，里面有个start函数，表示开始动筷子

  110. */

  112. class Sister implements Start{

  114.     private void start(){

  116.         System.out.println("姐姐可以开始动筷子了");

  118.     }




  123.     @Override

  125.     public void Fstart(Object obj) {

  127.         if(obj.toString().equals("父亲动了筷子")){

  129.             start();

  131.         }

  133.     }

  135. }</font>
复制代码
然后运行，结果如下：
[attach]144155[/attach]
这样看起来是不是很灵活，万一生个二胎，再加一个就行了。当然上面的代码并不完美，面向对象的思想告诉我们，我们应该在父亲和儿子，姐姐之间再定义一个Children。代码如下，这样不管生几胎就更省事了：
  1. <font size="3">package zt;




  6. /**

  8. * 接口回调

  10. */

  12. public final class App {

  14.     public static void main(String[] args) {

  16.         new Father(new Children[] { new Son(), new Sister() }).start();

  18.     }

  20. }




  25. interface Start {

  27.     void Fstart(Object obj);

  29. }




  34. /**

  36. * 父亲类，里面有个start函数，表示开始动筷子

  38. */

  40. class Father {




  45.     private Children[] childs;




  50.     Father(Children[] childs) {

  52.         this.childs = childs;

  54.     }




  59.     public void start() {

  61.         System.out.println("父亲开始动筷子了");

  63.         for (Children ch : this.childs) {

  65.             ch.Fstart("父亲动了筷子");

  67.         }

  69.     }

  71. }




  76. class Children implements Start {




  81.     protected void start() {

  83.         System.out.println("孩子们开始动筷子");

  85.     }




  90.     @Override

  92.     public void Fstart(Object obj) {

  94.         if (obj.toString().equals("父亲动了筷子")) {

  96.             this.start();

  98.         }

  100.     }




  105. }




  110. /**

  112. * 儿子类，继承孩子类

  114. */

  116. class Son extends Children {




  121.     @Override

  123.     protected void start() {

  125.         System.out.println("儿子可以开始动筷子了");

  127.     }




  132. }




  137. /**

  139. * 姐姐类，继承孩子类

  141. */

  143. class Sister extends Children {

  145.     @Override

  147.     protected void start() {

  149.         System.out.println("姐姐可以开始动筷子了");

  151.     }

  153. }</font>
复制代码
这就是我最近的一些感受，说实话工作快3年了，我最近第一次感受到了面向对象编程的优美。当然也有不好的地方，面向对象把有些事复杂化了。一句话，实践是检验真理的唯一标准，纸上得来终觉浅，绝知此事要躬行。





欢迎光临 51Testing软件测试论坛 (http://bbs.51testing.com/) Powered by Discuz! X3.2