Interpreter似乎使用面不是很广,它描述了一个语言解释器是如何构成的,在实际应用中,我们可能很少去构造一个语言的文法.我们还是来简单的了解一下:

首先要建立一个接口,用来描述共同的操作.

public interface AbstractExpression {
　　 void interpret( Context context );
}

再看看包含解释器之外的一些全局信息

public interface Context { }

AbstractExpression的具体实现分两种:终结符表达式和非终结符表达式:

public class TerminalExpression implements AbstractExpression {
　　 public void interpret( Context context ) { }
}

对于文法中每一条规则,非终结符表达式都必须的:
public class NonterminalExpression implements AbstractExpression {
　　 private AbstractExpression successor;
　　
　　 public void setSuccessor( AbstractExpression successor ) {
　　　　 this.successor = successor;
　　 }

　　 public AbstractExpression getSuccessor() {
　　　　 return successor;
　　 }

　　 public void interpret( Context context ) { }
}

Memento模式相对也比较好理解,我们看下列代码:

我们再看看Memento类:

可见 Memento中保存了Originator中的number和file的值. 通过调用Originator中number和file值改变的话,通过调用setMemento()方法可以恢复.

Memento模式的缺点是耗费大,如果内部状态很多,再保存一份,无意要浪费大量内存.

Memento模式在Jsp+Javabean中的应用
在Jsp应用中,我们通常有很多表单要求用户输入,比如用户注册,需要输入姓名和Email等, 如果一些表项用户没有填写或者填写错误,我们希望在用户按"提交Submit"后,通过Jsp程序检查,发现确实有未填写项目,则在该项目下红字显示警告或错误,同时,还要显示用户刚才已经输入的表项.

如下图中 First Name是用户已经输入,Last Name没有输入,我们则提示红字警告.:

这种技术的实现,就是利用了Javabean的scope="request"或scope="session"特性,也就是Memento模式.
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
实例：
经常使用计算机的人恐怕对系统备份（Memento）不会陌生，当你的Windows系统运行正常时，对它进行备份，当系统运行有问题时，就可以调用备份快速的将系统恢复，这样就可以大量节省重新装系统的痛苦，特别是当你缺少某一驱动，或在装系统是出现一些怪问题时，犹为痛苦。我想有过这种经历的人应该很了解吧，呵呵！
好了，下面让我们看看这个过程该如何实现吧：
 
1、我们先定义Windows系统（WindowsSystem）类：
 
public class WindowsSystem {
  private String state;
  public Memento createMemento() {  //创建备份，保存当前状态
    return new Memento(state);
  }
  public void restoreMemento(Memento memento){ //从备份中恢复系统
    this.state=memento.getState();
  }
  public String getState(){  //获得状态
    return this.state;
  }
  public void setState(String state){  //设置状态
    this.state=state;
    System.out.println("当前系统处于"+this.state);
  }
}
2、再定义备份（Memento）类：
public class Memento {
  private String state;
  public Memento(String state) {  //备份
    this.state=state;
  }
  public String getState(){ //获得状态
    return this.state;
  }
  public void setState(String state){  //设置状态
    this.state=state;
  }
}
3、定义用户（User）类：
public class User {
  private Memento memento;
  public Memento retrieveMemento() {  //恢复系统
    return this.memento;
  }
  public void saveMemento(Memento memento){  //保存系统
    this.memento=memento;
  }
}
4、编写测试类：
public class Test {
  public static void main(String args[]) {   
    WindowsSystem Winxp = new WindowsSystem(); //Winxp系统
    User user = new User();   //某一用户
    Winxp.setState("好的状态");   //Winxp处于好的运行状态
    user.saveMemento(Winxp.createMemento()); //用户对系统进行备份，Winxp系统要产生备份文件
    Winxp.setState("坏的状态");   //Winxp处于不好的运行状态
    Winxp.restoreMemento(user.retrieveMemento());   //用户发恢复命令，系统进行恢复
    System.out.println("当前系统处于"+Winxp.getState());
  }
}
5、说明：
A：定义：Memento对象是一个保存另外一个对象内部状态拷贝的对象，这样以后就可以将该对象恢复到原先保存的状态。
B：Memento模式的用意是在不破坏封装的条件下，将一个对象的状态捕捉住，并外部化，存储起来，从而可以在将来合适的时候把这个对象还原到存储起来的状态。
C：Memento模式所涉及的角色有三个，备忘录角色、发起人角色和负责人角色。
备忘录角色的作用：
（1）       将发起人对象的内部状态存储起来，备忘录可以根据发起人对象的判断来决定存储多少发起人对象的内部状态。
（2）       备忘录可以保护其内容不被发起人对象之外的任何对象所读取。
发起人角色的作用：
（1）       创建一个含有当前内部状态的备忘录对象。
（2）       使用备忘录对象存储其内部状态。
负责人角色的作用：
（1）       负责保存备忘录对象。
（2）       不检查备忘录对象的内容。
D：在本例中，备份（Memento）类是备忘录角色、Windows系统（WindowsSystem）类是发起人角色、用户（User）类是负责人角色。 

public abstract class Component {
 private String name;

 public abstract Component addChild(Component leftChild, Component rightChild);

 public String getName() {
  return name;
 }

 public void getTreeInfo() {
 }

 public abstract int getLength();
}


/** Leaf.java **************/
package binarytree;

public class Leaf extends Component {
 private String name;

 private Component leaf = null;

 public Leaf(String name) {
  this.name = name;
 }

 public Component addChild(Component leftChild, Component rightChild) {
  return this;
 }

 public String getName() {
  return name;
 }

 public int getLength() {
  return 1;
 }

 public static void main(String[] args) {
 }
}

/** Tree.java **************/
package binarytree;

public class Tree extends Component {
 private String name;

 private Component leftChild;

 private Component rightChild;

 public Tree(String name, Component leftChild, Component rightChild) {
  this.name = name;
  this.leftChild = leftChild;
  this.rightChild = rightChild;
 }

 public Tree(String name) {
  this.name = name;
  this.leftChild = null;
  this.rightChild = null;
 }

 public Component addChild(Component leftChild, Component rightChild) {
  this.leftChild = leftChild;
  this.rightChild = rightChild;
  return this;
 }

 public String getName() {
  return name;
 }

 public void getTreeInfo()
 // 得到树或叶子的详细信息
 // 先打印自己的名字，再遍例左孩子，再遍例右孩子
 // 如果左孩子或右孩子是树，递归调用
 {
  System.out.println(" this trees name is " + getName());
  if (this.leftChild instanceof Leaf) {
   System.out.println(getName() + "s left child is "
     + this.leftChild.getName() + ",it is a Leaf");
  }
  if (this.leftChild instanceof Tree) {
   System.out.println(getName() + "s left child is "
     + this.leftChild.getName() + ",it is a Tree");
   this.leftChild.getTreeInfo();
  }
  if (this.leftChild == null) {
   System.out.println(getName() + "s left child is a null");
  }
  if (this.rightChild instanceof Leaf) {
   System.out.println(getName() + "s right child is "
     + this.rightChild.getName() + ",it is a Leaf");
  }
  if (this.rightChild instanceof Tree) {
   System.out.println(getName() + "s right child is "
     + this.rightChild.getName() + ",it is a Tree");
   this.rightChild.getTreeInfo();
  }
  if (this.rightChild == null) {
   System.out.println(getName() + "s right child is a null");
  }
  // System.out.println(getName()+"s 高度 是 "+getLength());
 }

 public int getLength() {
  // 比较左孩子或右孩子的高度，谁大，+1 返回
  // 空孩子的处理
  if (this.leftChild == null) {
   if (this.rightChild == null)
    return 1;
   else
    return this.rightChild.getLength() + 1;
  } else {
   if (this.rightChild == null) {
    return this.leftChild.getLength() + 1;
   } else {
    if ((this.leftChild.getLength()) >= (this.rightChild
      .getLength()))
     return this.leftChild.getLength() + 1;
    else
     return this.rightChild.getLength() + 1;
   }
  }
 }

 public static void main(String[] args) {
 }
}

/** Test.java 测试类 **************/
package binarytree;

public class Test {

 public Test() {
 }

 public static void main(String[] args) {
  Component tree = new Tree("luopeng");
  Component left_child = new Leaf("luopeng1");
  Component right_child = new Leaf("luopeng2");
  tree = tree.addChild(left_child, right_child);
  // tree=tree.addRightChild(right_child);
  tree.getTreeInfo();
  Component tree1 = new Tree("luopeng2");
  tree1.addChild(tree, left_child);
  tree1.getTreeInfo();
  Component tree2 = new Tree("luopeng3");
  tree2.addChild(tree, null);
  tree2.getTreeInfo();
  Component tree4 = new Tree("luopeng4");
  tree4.addChild(null, tree);
  tree4.getTreeInfo();
  System.out.println(tree4.getName() + "的高度是 " + tree4.getLength());
 }
}

Composite比较容易理解，想到Composite就应该想到树形结构图。组合体内这些对象都有共同接口,当组合体一个对象的方法被调用执行时，Composite将遍历(Iterator)整个树形结构,寻找同样包含这个方法的对象并实现调用执行。可以用牵一动百来形容。

所以Composite模式使用到Iterator模式，和Chain of Responsibility模式类似。

Composite好处:
1.使客户端调用简单，客户端可以一致的使用组合结构或其中单个对象，用户就不必关系自己处理的是单个对象还是整个组合结构，这就简化了客户端代码。
2.更容易在组合体内加入对象部件. 客户端不必因为加入了新的对象部件而更改代码。

如何使用Composite?
首先定义一个接口或抽象类，这是设计模式通用方式了，其他设计模式对接口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和管理Composite组合体的对象们（或称部件Component）.

下面的代码是以抽象类定义，一般尽量用接口interface,

抽象类Equipment就是Component定义，代表着组合体类的对象们,Equipment中定义几个共同的方法。

Disk是组合体内的一个对象，或称一个部件，这个部件是个单独元素( Primitive)。
还有一种可能是，一个部件也是一个组合体，就是说这个部件下面还有'儿子'，这是树形结构中通常的情况，应该比较容易理解。现在我们先要定义这个组合体：

上面CompositeEquipment继承了Equipment,同时为自己里面的对象们提供了外部访问的方法,重载了Iterator,Iterator是Java的Collection的一个接口，是Iterator模式的实现.一般没必要重载Iterator。

我们再看看CompositeEquipment的两个具体类:盘盒Chassis和箱子Cabinet，箱子里面可以放很多东西，如底板，电源盒，硬盘盒等；盘盒里面可以放一些小设备，如硬盘 软驱等。无疑这两个都是属于组合体性质的。

至此我们完成了整个Composite模式的架构。

我们可以看看客户端调用Composote代码:

Cabinet cabinet=new Cabinet("Tower");

Chassis chassis=new Chassis("PC Chassis");
//将PC Chassis装到Tower中 (将盘盒装到箱子里)
cabinet.add(chassis);
//将一个10GB的硬盘装到 PC Chassis (将硬盘装到盘盒里)
chassis.add(new Disk("10 GB"));

//调用 netPrice()方法;
System.out.println("netPrice="+cabinet.netPrice());
System.out.println("discountPrice="+cabinet.discountPrice());

上面调用的方法netPrice()或discountPrice()，实际上Composite使用Iterator遍历了整个树形结构,寻找同样包含这个方法的对象并实现调用执行.

Composite是个很巧妙体现智慧的模式，在实际应用中，如果碰到树形结构，我们就可以尝试是否可以使用这个模式。

以论坛为例，一个版(forum)中有很多帖子(message),这些帖子有原始贴，有对原始贴的回应贴，是个典型的树形结构，那么当然可以使用Composite模式，那么我们进入Jive中看看，是如何实现的.

Jive解剖
在Jive中 ForumThread是ForumMessages的容器container(组合体).也就是说，ForumThread类似我们上例中的 CompositeEquipment.它和messages的关系如图：
[thread]
　　 |- [message]
　　 |- [message]
　　 　　 |- [message]
　　 　　 |- [message]
　　 　　 　　 |- [message]

我们在ForumThread看到如下代码：

类似CompositeEquipment, 提供用于访问自己组合体内的部件方法: 增加 删除 遍历.
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

    Composite模式的意图是“将对象组合成树形结构表示‘整体-部分’的层次结构。Composite使得用户对单个对象和组合对象的使用更具有一致性”。

    在Word中我们经常会将一些图元进行“组合”，组合以后的图形还可以向简单图元那样进行移动、变形等等操作；除此以外，在Word中，我们对于一个字符、一个词组、一句话、一个段落，甚至是整篇文章的操作是相同的，我们都可以进行剪切、复制，进行字体与大小的调整，进行颜色的变换。这些例子都是Composite模式的实例，我们将简单的元素组合成复杂的元素，然后还可以像操作简单元素那样操作组合元素。

    Composite模式将子元素组织成树型，实际上，组织成图型也没有问题。用户总是喜欢组合简单元素，一方面，用户可以通过这样的组合来进行抽象，另一方面，用户可以通过组合化简繁琐的操作。Composite模式在各种可视化编辑软件中应用得最为广泛。

    另一使用Composite的经典例子是Java的Swing系统。所有的Swing组件都是继承自一个叫做JComponent的接口，因此，我们对一个JFrame的操作和对一个JButton的操作是一样的。这同时也使得，JFrame在管理自己的子元素时，它不需要知道他们是一个JButton还是一个JPanel，对它来说，这只是一个JComponent。

    实现Composite模式的关键是良好设计的接口，人们应该对可能的元素（简单的、组合的）进行分析，并设计出通用的操作。尽可能的保证接口操作对所有元素都是有意义的，否则就应该将那些只对部分元素有意义的操作下放到子类中。

为什么要使用Proxy?
1.授权机制

我们开发一个应用系统时，用户请求任何页面都要经过权限控制，最早开发的时候我们常常封装一个权限验证方法,然后在每个jsp或者对应的servlet中增加相关代码，但是用户对权限的需求往往是多变的，这样一旦权限验证方法变化（参数变化，增加方法），如果开发的系统很庞大的话，有可能你就需要修改几百个jsp页面或者servlet代码。
还有我们常需要判断session是否过期，如果过期就要重新登陆系统，如果每个页面或者servlet都要加判断代码，那也是件比较痛苦的事情。
如果我们采用代理模式，增加Proxy对象，每次用户请求必须通过proxy对象处理，由它专门处理相关权限控制，一旦权限需求变化了，只需要修改Proxy对象相关的实现方法。

2.某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
举例4个具体情况:
u 一个对象，比如一幅很大的图像，需要载入的时间很长。

u 一个需要很长时间才可以完成的计算结果，并且需要在它计算过程中显示中间结果

u 一个存在于远程计算机上的对象，需要通过网络载入这个远程对象则需要很长时间，特别是在网络传输高峰期。

u 一个对象只有有限的访问权限，代理模式(Proxy)可以验证用户的权限

总之原则是,对于开销很大的对象,只有在使用它时才创建,这个原则可以为我们节省很多宝贵的Java内存. 所以,有些人认为Java耗费资源内存,我以为这和程序编制思路也有一定的关系.


简单实例：
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface AnInterface {
 public void doSomething();
}

class AClass implements AnInterface {
 public void doSomething() {
  System.out.println("Inside Method AClass.doSomething()");
 }
}

class SimpleInvocationHandler implements InvocationHandler {
 public SimpleInvocationHandler(Object realSubject) {
  this.realSubject = realSubject;
 }

 public Object invoke(Object proxy, Method m, Object[] args) {
  Object result = null;
  System.out.println("Before Calling " + m.getName());
  try {
   result = m.invoke(realSubject, args);
  } catch (Exception ex) {
   System.exit(1);
  }
  System.out.println("After Calling " + m.getName());
  return result;
 }

 private Object realSubject = null;
}

public class Test {
 public static void main(String args[]) {
  AnInterface realSubject = new AClass();
  AnInterface proxy = (AnInterface) Proxy.newProxyInstance(realSubject
    .getClass().getClassLoader(), realSubject.getClass()
    .getInterfaces(), new SimpleInvocationHandler(realSubject));
  passMeAProxy(proxy);
 }

 private static void passMeAProxy(AnInterface anInterface) {
  anInterface.doSomething();
 }
}

4。Proxy模式和Strategy模式

Adapter模式和代理模式(Proxy)都是在对象间构造一个简单的层。然而，Adapter模式向对象提供一个不同的接口，代理模式(Proxy)为对象提供相同的接口。

Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

如何使用?
因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现一下子变得很简单.

以勺子为例：

有个具体实现(ConcretePrototype):

调用Prototype模式很简单:

AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon2 = spoon.clone();

当然也可以结合工厂模式来创建AbstractSpoon实例。

在Java中Prototype模式变成clone()方法的使用，由于Java的纯洁的面向对象特性，使得在Java中使用设计模式变得很自然，两者已经几乎是浑然一体了。这反映在很多模式上，如Interator遍历模式。

Builder模式是一步一步创建一个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容就可以构建它们.用户不知道内部的具体构建细节.Builder模式是非常类似抽象工厂模式,细微的区别大概只有在反复使用中才能体会到.

为何使用?
是为了将构建复杂对象的过程和它的部件解耦.注意: 是解耦过程和部件.

因为一个复杂的对象,不但有很多大量组成部分,如汽车,有很多部件:车轮 方向盘 发动机还有各种小零件等等,部件很多,但远不止这些,如何将这些部件装配成一辆汽车,这个装配过程也很复杂(需要很好的组装技术),Builder模式就是为了将部件和组装过程分开.

如何使用?
首先假设一个复杂对象是由多个部件组成的,Builder模式是把复杂对象的创建和部件的创建分别开来,分别用Builder类和Director类来表示.

首先,需要一个接口,它定义如何创建复杂对象的各个部件:

用Director构建最后的复杂对象,而在上面Builder接口中封装的是如何创建一个个部件(复杂对象是由这些部件组成的),也就是说Director的内容是如何将部件最后组装成成品:

Builder的具体实现ConcreteBuilder:
通过具体完成接口Builder来构建或装配产品的部件;
定义并明确它所要创建的是什么具体东西;
提供一个可以重新获取产品的接口:

复杂对象:产品Product:

复杂对象的部件:

我们看看如何调用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
Director director = new Director( builder );

director.construct();
Product product = builder.getResult();
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
通俗讲解：Builder模式的理解


简单地说，就好象我要一座房子住，可是我不知道怎么盖（简单的砌墙，层次较低），也不知道怎么样设计（建几个房间，几个门好看，层次较高）， 于是我需要找一帮民工，他们会砌墙，还得找个设计师，他知道怎么设计，我还要确保民工听设计师的领导，而设计师本身也不干活，光是下命令，这里砌一堵墙，这里砌一扇门，这样民工开始建设，最后，我可以向民工要房子了。在这个过程中，设计师是什么也没有，除了他在脑子里的设计和命令，所以要房子也是跟民工要，记住了！

就象国内好多企业上erp一样，上erp，首先得找软件公司呀，找到软件公司后，软件公司说，我只知道怎么写软件，就知道怎么实现，不清楚整个erp的流程。好，那我们还得找一个咨询公司，好，找到德勤了，德勤说好，我要软件怎么做，软件公司怎么做，我就能保证软件能为你们提供erp系统了。

此模式是为了让设计和施工解耦，互不干扰。


package builder;

public interface Builder
{
public  void makeWindow();
public  void makeFloor();
public  Room  getRoom();

}


/*************************************************************/
package builder;

public class Designer {

  public Designer() {
  }
  public void order(Builder  builder) 
{
  builder.makeWindow();
  builder.makeFloor();

}
}

/*************************************************************/
package builder;
public class Mingong  implements Builder{
  private  String window="";
  private  String floor="";
  public Mingong() {
  }
  public  void makeWindow(){
  window=new String("window");
  }
  public  void makeFloor(){
  floor=new String("floor");
  }
  public  Room  getRoom()
  {
  if((!window.equals(""))&&(!floor.equals("")))
    {
    Room r = new Room();
    r.setFloor(floor);
    r.setWindow(window);
    return r;
    }
  else return null;
  }
}

/*************************************************************/
package builder;
public class Room {
  private  String window="";
  private  String floor="";
  public Room() {
  }
 public String getFloor() {
  return floor;
 }

 public void setFloor(String floor) {
  this.floor = floor;
 }

 public String getWindow() {
  return window;
 }

 public void setWindow(String window) {
  this.window = window;
 }
}
/*************************************************************/

package builder;

public class Client {

  public Client() {
  }
  public static void main(String[] args) {
     Builder mingong=new Mingong();
     Designer  designer=new      Designer();
     designer.order(mingong);
     Room r = mingong.getRoom();
     System.out.println(r.getWindow);//会输出window，表示构建成功。
  }
}

public class IntegerAdder implements Observer {

private IntegerDataBag bag;

public IntegerAdder( IntegerDataBag bag ) {
this.bag = bag;
bag.addObserver( this );
}

public void update( Subject o ) {
if( o == bag ) {
System.out.println( "The contents of the IntegerDataBag have changed." );
int counter = 0;
Iterator i = bag.iterator();
while( i.hasNext() ) {
Integer integer = ( Integer ) i.next();
counter+=integer.intValue();
}
System.out.println( "The new sum of the integers is: " + counter );
}
}

}

import java.util.Iterator;

public class IntegerPrinter implements Observer {

private IntegerDataBag bag;

public IntegerPrinter( IntegerDataBag bag ) {
this.bag = bag;
bag.addObserver( this );
}

public void update( Subject o ) {
if( o == bag ) {
System.out.println( "The contents of the IntegerDataBag have changed." );
System.out.println( "The new contents of the IntegerDataBag contains:" );
Iterator i = bag.iterator();
while( i.hasNext() ) {
System.out.println( i.next() );
}
}
}

}

IntegerAdder和IntegerPrinter将自己作为观察者增加到IntegerDataBag。当IntegerAdder接收到一条更新消息时，它先统计bag中的总数，然后显示结果。同样，当IntegerPrinter接收到一条更新消息时，它打印出bag中的Interger。

下面是一个简单的main()，它使用了上面的几个类：

public class Driver {
public static void main( String [] args ) {
Integer i1 = new Integer( 1 ); Integer i2 = new Integer( 2 );
Integer i3 = new Integer( 3 ); Integer i4 = new Integer( 4 );
Integer i5 = new Integer( 5 ); Integer i6 = new Integer( 6 );
Integer i7 = new Integer( 7 ); Integer i8 = new Integer( 8 );
Integer i9 = new Integer( 9 );

IntegerDataBag bag = new IntegerDataBag();
bag.add( i1 ); bag.add( i2 ); bag.add( i3 ); bag.add( i4 );
bag.add( i5 ); bag.add( i6 ); bag.add( i7 ); bag.add( i8 );

IntegerAdder adder = new IntegerAdder( bag );
IntegerPrinter printer = new IntegerPrinter( bag );

// adder and printer add themselves to the bag

System.out.println( "About to add another integer to the bag:" );
bag.add( i9 );
System.out.println("");
System.out.println("About to remove an integer from the bag:");
bag.remove( 0 );
}
}

运行main，你将看到：

c:\javaworld\java Driver
About to add another integer to the bag:
The contents of the IntegerDataBag have changed.
The new sum of the intergers is: 45
The contents of the IntegerDataBag have changed.
The new contents of the IntegerDataBag contains:
1
2
3
4
5
6
7
8
9

About to remove an integer from the bag:
The contents of the IntegerDataBag have changed.
The new sum of the intergers is: 44
The contents of the IntegerDataBag have changed.
The new contents of the IntegerDataBag contains:
2
3
4
5
6
7
8
9

IntegerDataBag/IntegerAdder/IntegerPrinter是应用Observer模式的一个很简单的例子。Java本身有大量使用Observer模式的例子：AWT/Swing事件模型，还有java.util.Observer和java.util.Observable接口等，都是很好的例子

Stratrgy应用比较广泛,比如, 公司经营业务变化图, 可能有两种实现方式,一个是线条曲线,一个是框图(bar),这是两种算法,可以使用Strategy实现.

这里以字符串替代为例, 有一个文件,我们需要读取后,希望替代其中相应的变量,然后输出.关于替代其中变量的方法可能有多种方法,这取决于用户的要求,所以我们要准备几套变量字符替代方案.

首先,我们建立一个抽象类RepTempRule 定义一些公用变量和方法:

在RepTempRule中 有一个抽象方法abstract需要继承明确,这个replace里其实是替代的具体方法.
我们现在有两个字符替代方案,
1.将文本中aaa替代成bbb;
2.将文本中aaa替代成ccc;

对应的类分别是RepTempRuleOne RepTempRuleTwo

第二步：我们要建立一个算法解决类，用来提供客户端可以自由选择算法。

调用如下:

我们达到了在运行期间，可以自由切换算法的目的。

实际整个Strategy的核心部分就是抽象类的使用,使用Strategy模式可以在用户需要变化时,修改量很少,而且快速.

Strategy和Factory有一定的类似,Strategy相对简单容易理解,并且可以在运行时刻自由切换。Factory重点是用来创建对象。

Strategy适合下列场合:

1.以不同的格式保存文件;

2.以不同的算法压缩文件;

3.以不同的算法截获图象;

4.以不同的格式输出同样数据的图形,比如曲线 或框图bar等

    有时，为复用而设计的工具箱类不能够被复用的原因仅仅是因为它的接口与专业应用领域所需要的接口不匹配。
    适配器模式有类的适配器模式和对象的适配器模式两种不同的形式。

一、类的适配器模式
    类的适配器模式把适配的类的API转换成目标类的API。

• 目标(Target)角色：这就是所期待得到的接口。
  
• 源(Adaptee)角色：现有需要适配的接口。
  
• 适配器(Adapter)角色：适配器类是本模式的核心。适配器把源接口转换成目标接口。显然这一角色不可以是接口，而必须是具体类。

    有一个很典型的例子就是编译系统。通常我们将编译系统分解为：Compile和Link两个步骤。一个Compile又可以分解为词法分析、语法分析、语义分析、中间代码生成等等步骤。对于用户来讲，我们不可能将这些模块分别提供给他们，让他们依次调用。相反的，我们应该提供一个统一的接口，使得用户可以方便的使用各个功能，例如IDE 。

Facade一个典型应用就是数据库JDBC的应用,如下例对数据库的操作:

上例是Jsp中最通常的对数据库操作办法.

在应用中,经常需要对数据库操作,每次都写上述一段代码肯定比较麻烦,需要将其中不变的部分提炼出来,做成一个接口,这就引入了facade外观对象.如果以后我们更换Class.forName中的<driver>也非常方便,比如从Mysql数据库换到Oracle数据库,只要更换facade接口中的driver就可以.

我们做成了一个Facade接口,使用该接口,上例中的程序就可以更改如下:

可见非常简单,所有程序对数据库访问都是使用改接口,降低系统的复杂性,增加了灵活性.

如果我们要使用连接池,也只要针对facade接口修改就可以.

由上图可以看出, facade实际上是个理顺系统间关系,降低系统间耦合度的一个常用的办法,也许你已经不知不觉在使用,尽管不知道它就是facade.

任何事物对象都有抽象和行为之分，例如人，人是一种抽象，人分男人和女人等；人有行为，行为也有各种具体表现，所以，“人”与“人的行为”两个概念也反映了抽象和行为之分。

在面向对象设计的基本概念中，对象这个概念实际是由属性和行为两个部分组成的，属性我们可以认为是一种静止的，是一种抽象，一般情况下，行为是包含在一个对象中，但是，在有的情况下，我们需要将这些行为也进行归类，形成一个总的行为接口，这就是桥模式的用处。

总之，Bridge模式就是使抽象和行为分离，做到各自的独立发展，就是说抽象和行为各抽象出一个接口。当需要扩展行为或者抽象部分时，
只需扩展相应部分，而不用修改原来的结构。

例子一：
假如有个类DrawGraph有个画圆的接口，当然这个圆形可以用铅笔画，也可以用钢笔画。其中画圆是抽象部分，
用铅笔画和用钢笔画是行为部分。往往这个时候我们分别会定义铅笔类PencilDraw，钢笔类PenDraw来实现Draw，
这样就使得抽象部分和行为部分固定的捆绑在一起，扩展性不强。假如要动态增加一个用粉笔画的行为和一个画方形的抽象部分，
就必然要新定义一个ChalkDraw类，DrawGraph类里增加drawRectangle接口。显然这是很麻烦的。

Bridge模式是这样实现的：
//抽象部分
public abstract class DrawGraph {

 private ToolDraw toolDraw;
 public void setToolDraw(){
  this.toolDraw = ToolDrawSingleton.getToolDraw();//用Singleton模式来选工具。
 }
 
 public ToolDraw getToolDraw(){
  return toolDraw;
 }
 
 public abstract void draw();
}

//画圆
public class DrawCircle implements DrawGraph{
 public DrawCircle(){
  setToolDraw();
 }
 public void draw(){
  System.out.pritnln(toolDraw.getName() + " draw circle");
 }
}

//画矩形
public class DrawRectangle implements DrawGraph{
 public DrawRectangle(){
  setToolDraw();
 }
 public void draw(){
  System.out.pritnln(toolDraw.getName() + " draw rectangle");
 }
}

//行为部分
public abstract class ToolDraw{
 public abstract String getName();
 public abstract void drawWithTool();
}

//铅笔
public class PencilDraw implements ToolDraw{
 private final static String name = "Pencil";
 
 public static String getName(){
  return name;
 }
 
 public void drawWithTool(){
  System.out.println("Draw with Pencil.");
 }
}

//钢笔
public class PenDraw implements ToolDraw{
 private final static String name = "Pen";
 
 public String getName(){
  return name;
 }
 
 public void drawWithTool(){
  System.out.println("Draw with Pen.");
 }
}

//粉笔
public class ChalkDraw implements ToolDraw{
 private final static String name = "Chalk";
 
 public String getName(){
  return name;
 }
 
 public void drawWithTool(){
  System.out.println("Draw with Chalk.");
 }
}

做一个Singleton类来联系抽象和行为。通过此类来选工具
public class ToolDrawSingleton{
 private static ToolDraw toolDraw;
 
 public ToolDrawSingleton(ToolDraw toolDraw){
  this.toolDraw = toolDraw
 }
 public static ToolDraw getToolDraw(){
  return toolDraw;
 }
}

假如我们现在要用粉笔来画一个方形,一个圆形：
//取得工具
ToolDrawSingleton tool = new ToolDrawSingleton(new ChalkDraw());
//画方形
DrawGraph drawRectangle = new DrawRectangle();
drawRectangle.draw();
//画圆形
drawRectangle = new DrawCircle();
drawRectangle.draw();

例子二：
例如,一杯咖啡为例,子类实现类为四个：中杯加奶、大杯加奶、 中杯不加奶、大杯不加奶。

但是，我们注意到：上面四个子类中有概念重叠，可从另外一个角度进行考虑，这四个类实际是两个角色的组合：抽象 和行为，其中抽象为：中杯和大杯；行为为：加奶 不加奶（如加橙汁 加苹果汁）.

实现四个子类在抽象和行为之间发生了固定的绑定关系，如果以后动态增加加葡萄汁的行为，就必须再增加两个类：中杯加葡萄汁和大杯加葡萄汁。显然混乱,扩展性极差。

那我们从分离抽象和行为的角度，使用Bridge模式来实现。

如何实现?
以上面提到的咖啡 为例. 我们原来打算只设计一个接口(抽象类),使用Bridge模式后,我们需要将抽象和行为分开,加奶和不加奶属于行为,我们将它们抽象成一个专门的行为接口.

先看看抽象部分的接口代码:

其中CoffeeImp 是加不加奶的行为接口,看其代码如下:

现在我们有了两个抽象类,下面我们分别对其进行继承,实现concrete class:

上面分别是中杯和大杯的具体实现.下面再对行为CoffeeImp进行继承:

Bridge模式的基本框架我们已经搭好了,别忘记定义中还有一句:动态结合,我们现在可以喝到至少四种咖啡:
1.中杯加奶
2.中杯不加奶
3.大杯加奶
4.大杯不加奶

看看是如何动态结合的,在使用之前,我们做个准备工作,设计一个单态类(Singleton)用来hold当前的CoffeeImp:

看看中杯加奶 和大杯加奶 是怎么出来的:

//拿出牛奶
CoffeeImpSingleton coffeeImpSingleton = new CoffeeImpSingleton(new MilkCoffeeImp());

//中杯加奶
MediumCoffee mediumCoffee = new MediumCoffee();
mediumCoffee.pourCoffee();

//大杯加奶
SuperSizeCoffee superSizeCoffee = new SuperSizeCoffee();
superSizeCoffee.pourCoffee();

注意: Bridge模式的执行类如CoffeeImp和Coffee是一对一的关系, 正确创建CoffeeImp是该模式的关键。