回調模式小結（一）

目的：

在形如

1. func(){
3.     head head head...
5.     act();
7.     tail tail tail...
9. }

的代碼中，常常會出現 act 并不是特定的某個動作，可能需要外界定制，如

1. void main(){
2.     int a = 2, b = 3;
3.     
4.     double r=a + b;
6.     printf("%lf/n", r);
7. }

 

第 4 行的運算式可能是  a-b, a * b, 或者 sqrt(a*a + b*b)，此時便需要將運算式傳進 main 函數。

 

假如運算式有幾種可以確定，可以使用：

1. void main(char op){
2.     int a = 2, b = 3;
3.     
4.     double r= 0;
5.     switch(op){
6.       case '+': r = a + b; break;
7.       case '-' : r = a - b ; break;
8.       case '*' : r = a * b ; break;
9.       case '?' : r = sqrt(a * a + b * b); break;
10.     }
12.     printf("%lf/n", r);
13. }

 

代碼看起來比較臃腫。不幸的是，事先并不知道确定有哪些表達式，所以雖然這么賣力，也沒能解決問題。

 

我們期望的方案應該是這樣的：

1. void main(expr){
2.     int a = 2, b = 3;
3.     double r = expr(a, b);
4.     printf("%lf/n", r);
5. }

這個。。好像泄露謎底了。 這種由另外的開發階段來提供表達式的方式叫回調。

 

在 c 語言里，能做到這樣的方法是函數指針：

1. void fun(double(*expr)(int, int)){
2.     int a = 2, b = 3;
3.     double r = expr(a, b);
4.     printf("%lf/n", r);
5. }
7. double add(int a, int b){return a + b;}
8. double subtract(int a, int b){return a - b;}
9. double multi(int a, int b){return a * b;}
10. double xian(int a, int b){return sqrt(a * a + b * b);}
14. void main(){
15.     fun(&add);
16.     func(&subtract);
17.     func(&multi);
18.     func(&xian);
19. }

此方法順利的實現了回調的目的。所以在以後還可以方便的塞新算法進去。

 

在 java 里沒有函數指針，所以我們不能指望函數指針這種方式，萬一指錯了怎么辦，函數指針好用，也很危險。在 java 里的做法有這么幾種。

 

第一、聲明一個表達式類或接口，每一種運算都這個類派生，如下：

1. public class Test {
3.     interface Expr {
4.         double eval(int a, int b);
5.     }
7.     private static void fun(Expr expr) {
8.         int a = 2, b = 3;
9.         double r = expr.eval(a, b);
10.         System.out.println(r);
11.     }
13.     public static void main(String[] args) {
14.         fun(new Expr() {
15.             @Override
16.             public double eval(int arg0, int arg1) {
17.                 return arg0 + arg1;
18.             }
19.         });
20.         fun(new Expr() {
21.             @Override
22.             public double eval(int arg0, int arg1) {
23.                 return arg0 - arg1;
24.             }
25.         });
26.         fun(new Expr() {
27.             @Override
28.             public double eval(int arg0, int arg1) {
29.                 return arg0 * arg1;
30.             }
31.         });
32.         fun(new Expr() {
33.             @Override
34.             public double eval(int arg0, int arg1) {
35.                 return Math.sqrt(arg0 * arg0 + arg1 * arg1);
36.             }
37.         });
38.     }
39. }

這段代碼看上去比較長。幸運的是在 eclipse 的幫助下，也沒打幾個字。

 

第二種方法、使用 override 特性：

1. public abstract class Test {
3.     public void fun() {
4.         int a = 2, b = 3;
5.         double r = expr(a, b);
6.         System.out.println(r);
7.     }
9.     abstract double expr(int a, int b);
11.     public static void main(String[] args) {
12.         new Test() {
13.             @Override
14.             double expr(int arg0, int arg1) {
15.                 return arg0 + arg1;
16.             }
17.         }.fun();
18.         new Test() {
19.             @Override
20.             double expr(int arg0, int arg1) {
21.                 return arg0 - arg1;
22.             }
23.         }.fun();
24.         new Test() {
25.             @Override
26.             double expr(int arg0, int arg1) {
27.                 return arg0 * arg1;
28.             }
29.         }.fun();
30.         new Test() {
31.             @Override
32.             double expr(int arg0, int arg1) {
33.                 return Math.sqrt(arg0 * arg0 + arg1 * arg1);
34.             }
35.         }.fun();
36.     }
37. }

最後是來自函數式編程家族的 javascript：

1. function fun(expr){
2.     var a=2, b = 3;
3.     var r = expr(a, b);
4.     alert(r);
5. }
7. fun(function(){return a + b;});
9. fun(function(){return a - b;});
11. fun(function(){return a * b;});
13. fun(function(){return Math.sqrt(a  * a + b * b);});

代碼很短很瀟灑。