原创作者: dcaoyuan   阅读:3977次   评论:0条   更新时间:2011-06-01    

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

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

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

3、保存在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.         /** following will affect other objects */
  11.         if (willAnchorHandle) {  
  12.             final boolean accomplishedNow = anchorHandle(p(e));  
  13.             if (accomplishedNow) {  
  14.                 drawingPane.accomplishedHandledChartChanged(AbstractHandledChart.this);  
  15.             }  
  16.         }  
  17.         if (willBeginEdit) {  
  18.             final EditAction action = chart.lookupActionAt(EditAction.class, e.getPoint());  
  19.             if (action != null) {  
  20.                 /** as the glassPane is always in the front, so add it there */  
  21.                 action.anchorEditor(drawingPane.getView().getGlassPane());  
  22.                 action.execute();  
  23.             }  
  24.         }  
  25.     } else {  
  26.         /** double clicked, process chart whose nHandles is variable */  
  27.         if (!isAccomplished() && nHandles == VARIABLE_NUMBER_OF_HANDLES) {  
  28.             anchored = false;  
  29.             accomplished = true;  
  30.             selectedHandleIdx = -1;  
  31.               
  32.             drawingPane.accomplishedHandledChartChanged(AbstractHandledChart.this);  
  33.         }  
  34.     }  
  35. }  

 

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. }  

 

评论 共 0 条 请登录后发表评论

发表评论

您还没有登录,请您登录后再发表评论

文章信息

Global site tag (gtag.js) - Google Analytics