Erlang里的OO和Java里的OO

[Updated: Feb 18, 2007, 增加了关于Java中静态方法的内容]
首先，这里的OO中的Object仅指包含可变状态的Object，暂不涉及有关OO的多态、继承等概念。

一、Erlang的OO
１、保存在函数调用栈中的状态
Erlang是函数式语言，一般而言，对于事物可变的状态（参数和中间状态）尽可能局限在函数调用中处理完，在调用过程中这些状态全部保存在函数的调用堆栈中，也就是说，函数处理的是事物瞬间的状态。这时，可以说，Erlang不太关心包含可变状态的Object。

２、保存在共享内存或硬盘上的状态
当然，Erlang肯定要处理现实世界的可变状态，这些可变状态，如果是临时的，通常可以以ets形式保存在内存中，如果变化的周期较长，也可以以dts 的形式保存硬盘上。ets和dts是erlang自带的数据库机制。这时，可以说，Erlang以一种基本数据结构的角度来看待包含可变状态的 Object。

３、保存在Process中的状态
世界上的事物总是意想不到地复杂的，有时，甚至很多时候，上述两种方式都不太好处理事物的状态。典型的情况是UI，UI的组件需要长时间显示在屏幕上，而 这些组件的状态通常是非常复杂的，比如，一个按钮，需要保存它的大小、位置、外观、文字、提示、在点击时可能需要做出的动作，等等等等。由于这类状态的持 续性、易变性和异步的特点，以Object的方式来处理似乎是最合适的。目前函数式语言普遍对UI的处理比较弱。

对于这种情况，Erlang的方式是：Process就是Object。

Erlang可以把状态保存在一个Process的Loop循环中，Process之间通过Message来交互。以按钮为例：

xml 代码

 

1. loop(B, Display, Wargs, Fun) - >   
2.     receive  
3.     {event,_,buttonPress,X} ->   
4.         flash(Display, Wargs),  
5.         Fun(X),  
6.         loop(B, Display, Wargs, Fun);  
7.     {event,_,expose,_} ->   
8.         xDo(Display, B),  
9.         xFlush(Display),  
10.         loop(B, Display, Wargs, Fun);  
11.     {onClick, Fun1} ->   
12.         loop(B, Display, Wargs, Fun1);  
13.     {set, Str} ->   
14.         Win  =  Wargs #win.win,  
15.         xDo(Display, xClearArea(Win)),  
16.         Bin  =   draw_cmd (Display, Wargs, Str),  
17.         loop(Bin, Display, Wargs, Fun);  
18.     {'EXIT', Pid, Why} ->   
19.         io:format("Here:~p~n",[{self(),Pid,Why}]),  
20.         true;  
21.     Any ->   
22.         Wargs1  =  sw :generic(Any, Display, Wargs),  
23.         loop(B, Display, Wargs1, Fun)  
24.     end.  

这段代码中可以看到，按钮的状态Wargs（Windows参数）和Fun（登记的动作）通过递归不断地传递（也是保存在调用栈中），并在接受到 message时可以做出相应的改变。这时，Erlang的Object不仅具有了状态，而且还能对message做出反应，并且，它在Process中 能长时间地维持。

二、Java的OO
这里想谈的是能从Erlang的OO角度来看Java的OO吗？
我的理解是：尽可能。

抛开在Java中的具体实现，假定我们能把Java的Object实例与Erlang的Process类比，那么我们可以：
1、把Object实例的Public方法调用看作是对外部message的反应（恰恰方法调用在OO的本意中原本就是message）；
2、把实例方法的调用看作是把函数绑定到（外加到）一堆状态上，相当于Scope在Erlang中的message loop中的函数；
3、把实例的状态看作是在一个Loop中不断被传递的参数。想象有个隐藏在背后的Loop持有这些状态（作为参数），new操作类比为new一个Loop。
4、Class的静态方法是Erlang中的Module方法，相当于Erlang的message loop外的函数。

当然：
1、JVM中的对象实例并不对应着一个share nothing的Process；
2、想象的Loop也不真实存在。

但是，这种转换至少在想象中是可以成立的。而且，它还隐含着一种可能，就是Java的语法可能不需要太多的改变就可以让这种想象变为现实。就是说，如果将 来的某一天，JVM的实现真的把每个实例都实现为一个share nothing的process，而且在背后自动地维持着这么一个Loop，再把方法调用实现为message的传递，那么你现在写的Java程序又何尝 不能获得Erlang一样的并发优势呢？

有趣的是，SUN确实这么想过，但是由于对性能的忧虑而至少现在没有去做。而且，虽然有人抱怨Java里的基本类型不是对象，但在我看来，这是对的，因为 即使在将来，也不可能为每个int i = 1去new 一个进程。何况，通过box，在必要的情况下还是可以把它看作对象的。

这个，也许只是将来。那么，我们现在能做什么呢？

多了解一些函数式编程的知识，并尽量将其用到日常编程中。

对于Java，至少以下几点是现在就可以开始做的：

• 尽量将会调用其它实例的语句与只涉及自身状态的语句分开。我现在通常将所有涉及自身状态的语句放在每个方法的前面，将调用其它实例的语句放在方法的最后面。（本文的最后给出了一个例子）
• 如果一个方法处理的主要是基本数据类型及其容器（list, map等等），那么将它们拿到单独的类中，并设计为static方法。
• 尽量少些setter/getter，可能的话，用一个完整的例程一次性处理完相关的事务。
• 如果其它实例中get出来一个对象，尽量只对它进行只读操作。如果要改变其状态，想想又没有其它更好的方法。
• 如果一个方法可以写成static方法，不妨就写成static方法（可惜java的语法会让static方法签名变得很长）。

最后是一个从我的程序中直接摘出来的一段程序，包括在接触FP之前写的，和最近改的。因为刚学函数编程不久，所以改得不一定合适。

之前：

java 代码

 

1. public   void  mouseClicked(MouseEvent e) {  
2.     /** sinlge-clicked ? go on drawing, or, check my selection status */   
3.     if  (e.getClickCount() ==  1 ) {  
4.         /** go on drawing ? */   
5.         if  (isActivated() && !isAccomplished()) {  
6.             boolean  accomplishedNow = anchorHandle(p(e));  
7.             if  (accomplishedNow) {  
8.                 drawingPane.accomplishedHandledChartChanged(AbstractHandledChart.this );  
9.             }  
10.             /** always set this is selected in this case: */   
11.             getChart().setSelected(true );  
12.         }  
13.         /** else, check my selection status */   
14.         else  {  
15.             if  (chart.hits(e.getPoint())) {  
16.                 if  (getChart().isSelected()) {  
17.                     final  EditAction action = getChart().lookupActionAt(EditAction. class , e.getPoint());  
18.                     if  (action !=  null ) {  
19.                         /** as the glassPane is always in the front, so add it there */   
20.                         action.anchorEditor(drawingPane.getView().getGlassPane());  
21.                         action.execute();  
22.                     }  
23.                 }  
24.                   
25.                 getChart().setSelected(true );  
26.                 /**  
27.                  * I was just selected only, don't call activate() here, let drawingPane  
28.                  * to decide if also activate me.  
29.                  */   
30.             } else  {  
31.                 getChart().setSelected(false );  
32.                 /**  
33.                  * I was just deselected only, don't call passivate() here, let drawingPane  
34.                  * to decide if also passivate me.  
35.                  */   
36.             }  
37.         }  
38.           
39.     }  
40.     /** double clicked, process chart whose nHandles is variable */   
41.     else  {  
42.           
43.         if  (!isAccomplished()) {  
44.             if  (nHandles == VARIABLE_NUMBER_OF_HANDLES) {  
45.                 anchored = false ;  
46.                 accomplished = true ;  
47.                 selectedHandleIdx = -1 ;  
48.                   
49.                 drawingPane.accomplishedHandledChartChanged(AbstractHandledChart.this );  
50.             }  
51.         }  
52.     }  
53. }  

java 代码

 

1. public   void  mouseMoved(MouseEvent e) {  
2.     if  (isActivated()) {  
3.         if  (!isAccomplished()) {  
4.             if  (anchored) {  
5.                 stretchHandle(p(e));  
6.             }  
7.         }  
8.         /** else, decide what kind of cursor will be used and if it's ready to be moved */   
9.         else  {  
10.             Handle theHandle = getHandleAt(e.getX(), e.getY());  
11.             /** mouse points to theHandle ? */   
12.             if  (theHandle !=  null ) {  
13.                 int  idx = currentHandles.indexOf(theHandle);  
14.                 if  (idx >=  0 ) {  
15.                     selectedHandleIdx = idx;  
16.                 }  
17.                   
18.                 cursor = HANDLE_CURSOR;  
19.             }  
20.             /** else, mouse does not point to any handle */   
21.             else  {  
22.   
23.                 selectedHandleIdx = -1 ;  
24.                 /** mouse points to this chart ? */   
25.                 if  (chart.hits(e.getX(), e.getY())) {  
26.                     setReadyToDrag(true );  
27.                     cursor = MOVE_CURSOR;  
28.                 }  
29.                 /** else, mouse does not point to this chart */   
30.                 else  {  
31.                     setReadyToDrag(false );  
32.                     cursor = DEFAULT_CURSOR;  
33.                 }  
34.             }  
35.         }  
36.     }  
37. }  

之后：

java 代码

 

1. public   void  mouseClicked(MouseEvent e) {  
2.     if  (e.getClickCount() ==  1 ) {  
3.         /** sinlge-clicked ? go on drawing, or, check my selection status */   
4.         final   boolean  willAnchorHandle = isActivated() && !isAccomplished();  
5.         final   boolean  chartSelected    = willAnchorHandle ||  
6.                 !willAnchorHandle && chart.hits(e.getPoint());  
7.         final   boolean  willBeginEdit    = !willAnchorHandle && chartSelected;  
8.           
9.         chart.setSelected(chartSelected);
10. 
    
11.         /** following will affect other objects */
    
12.         if  (willAnchorHandle) {  
13.             final   boolean  accomplishedNow = anchorHandle(p(e));  
14.             if  (accomplishedNow) {  
15.                 drawingPane.accomplishedHandledChartChanged(AbstractHandledChart.this );  
16.             }  
17.         }  
18.         if  (willBeginEdit) {  
19.             final  EditAction action = chart.lookupActionAt(EditAction. class , e.getPoint());  
20.             if  (action !=  null ) {  
21.                 /** as the glassPane is always in the front, so add it there */   
22.                 action.anchorEditor(drawingPane.getView().getGlassPane());  
23.                 action.execute();  
24.             }  
25.         }  
26.     } else  {  
27.         /** double clicked, process chart whose nHandles is variable */   
28.         if  (!isAccomplished() && nHandles == VARIABLE_NUMBER_OF_HANDLES) {  
29.             anchored = false ;  
30.             accomplished = true ;  
31.             selectedHandleIdx = -1 ;  
32.               
33.             drawingPane.accomplishedHandledChartChanged(AbstractHandledChart.this );  
34.         }  
35.     }  
36. }  

 

java 代码

 

1. public   void  mouseMoved(MouseEvent e) {  
2.     if  (isActivated()) {  
3.         if  (isAccomplished()) {  
4.             /** decide what kind of cursor will be used and if it's ready to be moved */   
5.             final  Handle theHandle = getHandleAt(e.getX(), e.getY());  
6.             if  (theHandle !=  null ) {  
7.                 /** mouse points to theHandle */   
8.                 final   int  idx = currentHandles.indexOf(theHandle);  
9.                 selectedHandleIdx = idx >= 0  ? idx : selectedHandleIdx;  
10.                 cursor = HANDLE_CURSOR;  
11.             } else  {  
12.                 /** mouse does not point to any handle */   
13.                 final   boolean  mousePointToThisChart = chart.hits(e.getX(), e.getY());  
14.                 readyToDrag = mousePointToThisChart;  
15.                 selectedHandleIdx = -1 ;  
16.                 cursor = mousePointToThisChart ? MOVE_CURSOR : DEFAULT_CURSOR;  
17.             }  
18.         } else  {  
19.             if  (anchored) {  
20.                 stretchHandle(p(e));  
21.             }  
22.         }  
23.     }  
24. }