OO四剑客
现在面向对象的开发已经基本成为程序员认定的真理，围绕这个思想很多人做了将原来不是面向对象的东西转换
为面向对象的工作，比如面向对象数据库
（参考 『http://linugb118.blog.ccidnet.com/blog-htm-do-showone-uid-39808-type-blog-itemid-102097.html』db4o 参考我以前写的）
，还比如or-mapping的出现，等等。
本人以前也对面向对象的工具以及一些面向对象的产品进行过源码的研究，后来在看了《Jakarta Commons Cookbook》
后，我觉得具体可以这么归纳面向对象开发的四个要素：Predicate(断言)，Closure(终结者),Comparator(比较器)，Transformer(转换)，
我们先不解释这四个要素的含义和用意，我们先来看看非面向对象语言的描述，如果在学校学习过面向过程的
编程语言如PASCAL的话，大家其实知道，如果需要实现某个功能，那么在一个函数中从头写到尾，其实对于计算机
本身而言，他也是从头到尾执行的，他本身不会跳转，只有你给if或者else 这样的词语告诉它，那么机器才会根据你的
意思知道是跳转到别的地方还是继续执行。目前跳转的常用模式就是if(A){do}else{} 以及循环while(A) do{},
这里开始引入第一个要素Predicate(断言)，什么是Predicate，其实上面的A就是Predicate。在面向过程语言中。
往往是等于，AND，OR，不等于等一些判断，而等式链接的直接是变量，链接符号那么是预先定义的符号，比如==,&&,||, ! 等等
那么面向对象的话，一切都是对象，首先等式链接的两边是对象，虽然对象语言中仍然有预先定义的符号，但是我们
觉得这个不符合面向对象的原则【一切皆是对象】，于是我们要把等式符号也要转换为对象，我们就引入接口Predicate
在接口Predicate中
public interface Predicate
{
public boolean evaluate(Object object);
}
只有一个方法evaluate，他返回true或者false；
在common collections中 与等式符号对于的有
EqualPredicate ==
NotPredicate !=
TruePredicate true
FalsePredicate false
OrPredicate ||
AndPredicate &&
等等
而本身因为链接的是对象，因此和对象相关的特定Predicate有
IdentityPredicate
InstanceOfPredicate
NullPredicateNullIsTruePredicate
NotNullPredicateNullIsFalsePredicate
UniquePredicate
除了上面已经实现的Predicate，而Predicate本身因为是接口，所有用户也可以自己去实现自己的Predicate
比如
public class LaunchPredicate implements Predicate {
public LaunchPredicate( ) {}
public boolean evaluate(Object object) {
if(...)
{return true}
return false;
}}
另外我们说过Predicate本身是对象，而等式链接的对象当然也可以是Predicate对象本身，因此就有了无穷无尽的
组合，也就是Composite Predicates
上面的AndPredicate和OrPredicate就是能链接Predicate对象的Predicate，除此之外还有
AllPredicate, OnePredicate, AnyPredicate, NonePredicate 当然从原则上说其他Predicate的实现也能
链接Predicate对象，但是含义不够通用。
前面对照面向过程语言我讲的是if/while后面的断言部分，那么我们现在看看if/while后面do的部分
在面向过程语言中，do就是一段代码。那么如果利用面向对象的思想来思考，那么do应该是一个对象，那这个对象
就是Closure(终结者)
public interface Closure
{
public void execute(java.lang.Object input);
}
在接口中，我们可以看出里面只有一个execute接口，用户可以实现自己的Closure来实现代码片段想做的事情。
接下来，有个问题，多个代码片段可能合成一个片段，那么怎么处理，Closure 同样可以，只要引入ChainedClosure
就可以了，ChainedClosure的用法
Closure[] cArray = new Closure[] { repairShielding, fuel };
Closure preLaunch = new ChainedClosure( cArray );
我们刚才看的只是片段里面没有if/while 断言，如果片段里面有if/while 断言怎么办，那么这个时候我们
根据上面讲的断言引入三个特殊的Closure：IfClosure 和WhileClosure/ForClosure
他们的用法如下
Predicate isWinning = new Predicate( ){...}
Closure sell = new Closure( ){...}
Closure buy = new Closure( ){...}
Closure stockAction = new IfClosure( isWinning, buy, sell );
这是一个买卖股票的例子，如果isWinning为true 那么执行买入buy，否则执行卖出；
Closure drive = new Closure( ) {...}
Predicate hasFuel = new Predicate( ) {...}
Closure useAllFuel = new WhileFuel( hasFuel, drive );
执行循环数字那么就用ForClosure
Closure driveSome = new ForClosure( 5, drive );
到这里，我们需要回过来看看对象的断言，对象怎么能够相互比较的，其实很简单，有两种方法，一种
方法：继承Comparable，实现CompareTo方法 另外一种是：用外部的Comparator来比较。
参考【我写过一篇文件
http://linugb118.blog.ccidnet.com/blog-htm-do-showone-uid-39808-type-blog-itemid-102094.html】
我们这里讲的是Comparator，Comparator比较灵活，独立于对象。
public interface Comparator
{
public int compare(Object o1, Object o2);
public boolean equals(Object obj);
}
Comparator接口中主要需要实现的是compare方法。你可以自己写自己的Comparator，当然collections中
已经有了些常用的Comparator
如ReverseComparator 反向比较
如果要给book反向排序，那么就这样使用Collections.sort( books, reverseComparator );
多个比较器同时使用就用ComparatorChain;
如下面例子：
ComparatorChain comparatorChain = new ComparatorChain( );
comparatorChain.addComparator( new BeanComparator( "lastName" ) );
comparatorChain.addComparator( new BeanComparator( "firstName" ) );
comparatorChain.addComparator( new BeanComparator( "age" ), true );
除此之外 还有特定的比较器NullComparator和FixedOrderComparator
他们的用法：
Comparator nullComparator = new NullComparator( BookComparator );
和
String[] medalOrder = {"tin", "bronze", "silver", "gold", "platinum"};
Comparator medalComparator = new FixedOrderComparator( medalOrder );----按medalOrder指定的顺序排
到现在为止，面向对象的四剑客我们已经讲过三个，剩下最后一个是Transformer(转换)
public interface Transformer
{
public java.lang.Object transform(java.lang.Object input)
}
其实从程序的角度，我觉得Transformer和Closure都是将input 的东西进行处理然后输出，好像一样的，
没错，从程序角度是一样的，但是如果从对象角度来看，他们还是有一些区别，Transformer是将一个对象
转换为其他对象或者一个新的对象，一般不太会改变对象只是做一些转换，而Closure就是处理对象，会在
上面做很多改变。
Transformer同样可以用ChainedTransformer来将多个Transformer链起来使用
Transformer[] chainElements = new Transformer[] { multiply, increment };
Transformer chain = new ChainedTransformer( chainElements );
另外Transformer可以和Predicate一起形成条件开关转换器SwitchTransform
Predicate[] pArray = new Predicate[] { isOdd, isEven };
Transformer[] tArray = new Transformer[] { oddTransform, evenTransform };
Transform predicateTransform =
new SwitchTransform( pArray, tArray, new NOPTransformer( ) );
这里如果isOdd就执行oddTransform，如果isEven就执行evenTransform，默认执行new NOPTransformer()
读完上面的四剑客，估计你应该对面向对象一切皆为对象的理念有了更深刻的理解的。^_^