亚洲国产精品无码久久一区二区,久久精品国产精品亚洲艾,亚洲av片在线观看

Tue, 01 Aug 2006 03:45:00 GMT

Interpreter解释器模式定�?
定义语言的文�?,�q�且建立一个解释器来解释该语言中的句子.�Q�后面不用看了）

Interpreter��g��使用面不是很�q?它描�q�C��一个语�a�解释器是如何构成�?在实际应用中,我们可能很少��L��造一个语�a�的文�?我们�q�是来简单的了解一�?

首先要徏立一个接�?用来描述共同的操�?

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

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

public interface Context { }

AbstractExpression的具体实现分两种:�l�结�W�表辑ּ�和非�l�结�W�表辑ּ�:

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

对于文法中每一条规�?非终�l�符表达式都必须�?
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 ) { }
}

保尔�?/a> 2006-08-01 11:45 发表评论

Tue, 01 Aug 2006 02:28:00 GMT

Memento备望录模式定�?
memento是一个保存另外一个对象内部状态拷贝的对象.�q�样以后��可以将该对象恢复到原先保存的状�?

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

public class Originator {

　　 private int number;

　　private File file = null;

　　public Originator(){}

　　// 创徏一个Memento
　　public Memento getMemento(){
　　　　return new Memento(this);
　　}

　　// 恢复到原始�?br />　　public void setMemento(Memento m){
　　　　 number = m.number;
　　　　 file = m.file;
　　}

}

我们再看看Memento�c?

private class Memento implements java.io.Serializable{

　　private int number;

　　private File file = null;

　　public Memento( Originator o){

　　　　number = o.number;
　　　　file = o.file;

　　}

可见 Memento中保存了Originator中的number和file的�? 通过调用Originator中number和file值改变的�?通过调用setMemento()�Ҏ(gu��)��可以恢复.

Memento模式的缺�Ҏ(gu��)��耗费�?如果内部状态很�?再保存一�?无意要浪费大量内�?

Memento模式在Jsp+Javabean中的应用
在Jsp应用�?我们通常有很多表单要求用戯��?比如用户注册,需要输入姓名和Email�{? 如果一些表��用��h��有填写或者填写错�?我们希望在用��h��"提交Submit"�?通过Jsp�E�序��?发现��实有未填写��目,则在该项目下�U�字昄��警告或错�?同时,�q�要昄��用户刚才已经输入的表��?

如下图中 First Name是用户已�l�输�?Last Name没有输入,我们则提�C�红字警�?:

�q�种技术的实现,��是利用了Javabean的scope="request"或scope="session"�Ҏ(gu��)�?也就是Memento模式.
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－
实例�Q?br />�l�常使用计算机的人恐怕对�pȝ��备䆾�Q�Memento�Q�不�?x��)陌生，当你的Windows�pȝ��q�行正常�Ӟ��对它�q�行备䆾�Q�当�pȝ��q�行有问题时�Q�就可以调用备䆾快速的��系�l�恢复，�q�样��可以大量节省重新装�pȝ��的痛苦，特别是当你缺��某一驱动�Q�或在装�pȝ��是出��C��些怪问题时�Q�犹为痛苦。我��x��q�这�U�经历的人应该很了解吧，呵呵�Q?br />好了�Q�下面让我们看看�q�个�q�程该如何实现吧�Q?

1、我们先定义Windows�pȝ��Q�WindowsSystem�Q�类�Q?br />
public class WindowsSystem {
private String state;
public Memento createMemento() { //创徏备䆾�Q�保存当前状�?br />    return new Memento(state);
}
public void restoreMemento(Memento memento){ //从备份中恢复�pȝ��
    this.state=memento.getState();
}
public String getState(){ //获得状�?br />    return this.state;
}
public void setState(String state){ //讄��状�?br />    this.state=state;
    System.out.println("当前�pȝ��处于"+this.state);
}
}
2、再定义备䆾�Q�Memento�Q�类�Q?br />public class Memento {
private String state;
public Memento(String state) { //备䆾
    this.state=state;
}
public String getState(){ //获得状�?br />    return this.state;
}
public void setState(String state){ //讄��状�?br />    this.state=state;
}
}
3、定义用��P��User�Q�类�Q?br />public class User {
private Memento memento;
public Memento retrieveMemento() { //恢复�pȝ��
    return this.memento;
}
public void saveMemento(Memento memento){ //保存�pȝ��
    this.memento=memento;
}
}
4、编写测试类�Q?br />public class Test {
public static void main(String args[]) {
    WindowsSystem Winxp = new WindowsSystem(); //Winxp�pȝ��
    User user = new User();   //某一用户
    Winxp.setState("好的状�?);   //Winxp处于好的�q�行状�?br />    user.saveMemento(Winxp.createMemento()); //用户对系�l�进行备份，W(xu��)inxp�pȝ��要��生备份文�?br />    Winxp.setState("坏的状�?);   //Winxp处于不好的运行状�?br />    Winxp.restoreMemento(user.retrieveMemento());   //用户发恢复命令，�pȝ��q�行恢复
    System.out.println("当前�pȝ��处于"+Winxp.getState());
}
}
5、说明：(x��)
A�Q�定义：(x��)Memento对象是一个保存另外一个对象内部状态拷贝的对象�Q�这样以后就可以��该对象恢复到原先保存的状态�?br />B�Q�Memento模式的用意是在不破坏��装的条件下�Q�将一个对象的状态捕捉住�Q��ƈ外部化，存储��h��Q�从而可以在��来合适的时候把�q�个对象�q�原到存储�v来的状态�?br />C�Q�Memento模式所涉及(qi��ng)的角色有三个�Q�备忘录角色、发起�h角色和负责�h角色�?br />备忘录角色的作用�Q?br />�Q?�Q�     �?��发起�h对象的内部状态存储�v来，备忘录可以根据发起�h对象的判断来军_��存储多少发�v人对象的内部状态�?br />�Q?�Q�     �?备忘录可以保护其内容不被发�v人对象之外的��M��对象所��d��?br />发�v��色的作用�Q?br />�Q?�Q�     �?创徏一个含有当前内部状态的备忘录对象�?br />�Q?�Q�     �?使用备忘录对象存储其内部状态�?br />负责��色的作用�Q?br />�Q?�Q�     �?负责保存备忘录对象�?br />�Q?�Q�     �?不检查备忘录对象的内宏V�?br />D�Q�在本例中，备䆾�Q�Memento�Q�类是备忘录角色、Windows�pȝ��Q�WindowsSystem�Q�类是发起�h角色、用��P��User�Q�类是负责�h角色。�?!--/lxfcn-->

保尔�?/a> 2006-08-01 10:28 发表评论

Mon, 31 Jul 2006 09:33:00 GMT

我用composite模式写的一个二叉树(w��i)的例�?br />1�Q�Component 是抽象组�?br />Tree 和Leaf �l�承Component

private String name; //�?w��i)或叶子的名�U?br />addChild(Component leftChild,Component rightChild);
//�l�一个树(w��i)上加上一个左孩子�Q�一个右孩子
getName(){return name;}
getTreeInfo(){} //得到�?w��i)或叶子的详�l�信�?br />getLength(); //得到�?w��i)的高�?

2�Q�Tree 二叉�?w��i)，一个左孩子�Q�一个右孩子

3�Q�Leaf 是叶子节�?br />4�Q�Test 是测试节�?

/** Component.java **************/
package binarytree;

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()
// 得到�?w��i)或叶子的详�l�信�?br /> // 先打印自��q��名字�Q�再遍例左孩子，再遍例右孩子
// 如果左孩子或叛_��子是�?w��i)，递归调用
{
  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() {
  // 比较左孩子或叛_��子的高度�Q�谁大，+1 �q�回
  // �I�孩子的处理
  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 ��试�c?**************/
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());
}
}

保尔�?/a> 2006-07-31 17:33 发表评论

Composite�Q�组合）模式

Mon, 31 Jul 2006 09:16:00 GMT

Composite模式定义:
��对象以�?w��i)�Ş�l�构�l�织��h��,以达成“部分－整体�?的层�ơ结构，使得客户端对单个对象和组合对象的使用��h��一致�?

Composite比较�Ҏ(gu��)��理解�Q�想到Composite��应该想到树(w��i)形结构图。组合体内这些对象都有共同接�?当组合体一个对象的�Ҏ(gu��)��被调用执行时�Q�Composite��遍�?Iterator)整个�?w��i)�Ş�l�构,��L��同样包含�q�个�Ҏ(gu��)��的对象�ƈ实现调用执行。可以用牵一动百来�Ş宏V�?/p>

所以Composite模式使用到Iterator模式�Q�和Chain of Responsibility模式�c�M��?/p>

Composite好处:
1.使客��L(f��ng)��调用��单，客户端可以一致的使用�l�合�l�构或其中单个对象，用户��׃��必关�p�自己处理的是单个对象还是整个组合结构，�q�就��化了客户端代码�?br />2.更容易在�l�合体内加入对象部�g. 客户端不必因为加入了新的对象部�g而更改代码�?/p>

如何使用Composite?
首先定义一个接口或抽象�c�，�q�是设计模式通用方式了，其他设计模式�Ҏ(gu��)��口内部定义限制不多，Composite却有个规定，那就是要在接口内部定义一个用于访问和��理Composite�l�合体的对象们（或称部�gComponent�Q?

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

public abstract class Equipment
{
　　private String name;
　　//实�h(hu��n)
　　public abstract double netPrice();
　　//折扣��h��
　　public abstract double discountPrice();
　　//增加部�g�Ҏ(gu��)��　　
　　public boolean add(Equipment equipment) { return false; }
　　//删除部�g�Ҏ(gu��)��
　　public boolean remove(Equipment equipment) { return false; }
　　//注意�q�里�Q�这里就提供一�U�用于访问组合体�cȝ��部�g�Ҏ(gu��)��?br />　　public Iterator iter() { return null; }
　　
　　public Equipment(final String name) { this.name=name; }
}

抽象�c�Equipment��是Component定义�Q�代表着�l�合体类的对象们,Equipment中定义几个共同的�Ҏ(gu��)��?/p>

public class Disk extends Equipment
{
　　public Disk(String name) { super(name); }
　　//定义Disk实�h(hu��n)�?
　　public double netPrice() { return 1.; }
　　//定义了disk折扣��h��?.5 �Ҏ(gu��)��?br />　　public double discountPrice() { return .5; }
}

Disk是组合体内的一个对象，或称一个部�Ӟ��q�个部�g是个单独元素( Primitive)�?br />�q�有一�U�可能是�Q�一个部件也是一个组合体�Q�就是说�q�个部�g下面�q�有'儿子'�Q�这是树(w��i)形结构中通常的情况，应该比较�Ҏ(gu��)��理解。现在我们先要定义这个组合体�Q?/p>

abstract class CompositeEquipment extends Equipment
{
　　private int i=0;
　　//定义一个Vector 用来存放'儿子'
　　private Lsit equipment=new ArrayList();

　　public CompositeEquipment(String name) { super(name); }

　　public boolean add(Equipment equipment) {
　　　　 this.equipment.add(equipment);
　　　　 return true;
　　 }

　　public double netPrice()
　　{
　　　　double netPrice=0.;
　　　　Iterator iter=equipment.iterator();
　　　　for(iter.hasNext())
　　　　　　netPrice+=((Equipment)iter.next()).netPrice();
　　　　return netPrice;
　　}

　　public double discountPrice()
　　{
　　　　double discountPrice=0.;
　　　　Iterator iter=equipment.iterator();
　　　　for(iter.hasNext())
　　　　　　discountPrice+=((Equipment)iter.next()).discountPrice();
　　　　return discountPrice;
　　}
　　

　　//注意�q�里�Q�这里就提供用于讉K��自己�l�合体内的部件方法�?br />　　//上面disk 之所以没有，是因为Disk是个单独(Primitive)的元�?
　　public Iterator iter()
　　{
　　　　return equipment.iterator() ;
　　{
　　//重蝲Iterator�Ҏ(gu��)��
　　 public boolean hasNext() { return i　　//重蝲Iterator�Ҏ(gu��)��
　　 public Object next()
　　 {
　　　　if(hasNext())
　　　　　　 return equipment.elementAt(i++);
　　　　else
　　　　　 throw new NoSuchElementException();
　　 }
　　

}

上面CompositeEquipment�l�承了Equipment,同时��己里面的对象们提供了外部讉K��的方�?重蝲了Iterator,Iterator是Java的Collection的一个接口，是Iterator模式的实�?一般没必要重蝲Iterator�?/font>

我们再看看CompositeEquipment的两个具体类:盘盒Chassis和箱子Cabinet�Q�箱子里面可以放很多东西�Q�如底板�Q�电(sh��)源盒�Q�硬盘盒�{�；盘盒里面可以放一些小讑֤��Q�如��盘软驱�{�。无疑这两个都是属于�l�合体性质的�?/p>

public class Chassis extends CompositeEquipment
{
　　 public Chassis(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

public class Cabinet extends CompositeEquipment
{
　　 public Cabinet(String name) { super(name); }
　　 public double netPrice() { return 1.+super.netPrice(); }
　　 public double discountPrice() { return .5+super.discountPrice(); }
}

��x��我们完成了整个Composite模式的架构�?/p>

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

Cabinet cabinet=new Cabinet("Tower");

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

//调用 netPrice()�Ҏ(gu��)��;
System.out.println("netPrice="+cabinet.netPrice());
System.out.println("discountPrice="+cabinet.discountPrice());

上面调用的方法netPrice()或discountPrice()�Q�实际上Composite使用Iterator遍历了整个树(w��i)形结�?��L��同样包含�q�个�Ҏ(gu��)��的对象�ƈ实现调用执行.

Composite是个很��y妙体现智慧的模式�Q�在实际应用中，如果��到�?w��i)�Ş�l�构�Q�我们就可以��试是否可以使用�q�个模式�?/p>

以论坛�ؓ(f��)例，一个版(forum)中有很多帖子(message),�q�些帖子有原始脓(chu��ng)�Q�有对原始脓(chu��ng)的回应脓(chu��ng)�Q�是个典型的�?w��i)�Ş�l�构�Q�那么当然可以��用Composite模式�Q�那么我们进入Jive中看看，是如何实现的.

我们在ForumThread看到如下代码�Q?br />

public interface ForumThread {
　　 ....
　　 public void addMessage(ForumMessage parentMessage, ForumMessage newMessage)
　　　　　　 throws UnauthorizedException;

　　 public void deleteMessage(ForumMessage message)
　　　　　　 throws UnauthorizedException;

　　
　　 public Iterator messages();
　　　　 ....

}

�c�M��CompositeEquipment, 提供用于讉K��自己�l�合体内的部件方�? 增加删除遍历.
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－

Composite模式的意图是“将对象�l�合成树(w��i)形结构表�C�‘整�?部分’的层次�l�构。Composite使得用户对单个对象和�l�合对象的��用更��h��一致性”�?/p>

在Word中我们经�怼�(x��)��一些图元进行“组合”，�l�合以后的图形还可以向简单图元那栯��行移动、变形等�{�操作；除此以外�Q�在Word中，我们对于一个字�W�、一个词�l�、一句话、一个段落，甚至是整��文章的操作是相同的�Q�我们都可以�q�行剪切、复�Ӟ��q�行字体与大��的调整�Q�进行颜色的变换。这些例子都是Composite模式的实例，我们��简单的元素�l�合成复杂的元素�Q�然后还可以像操作简单元素那��h��作组合元素�?/p>

Composite模式��子元素�l�织成树(w��i)型，实际上，�l�织成图型也没有问题。用��h��L��喜欢�l�合��单元素，一斚w��Q�用户可以通过�q�样的组合来�q�行抽象�Q�另一斚w��Q�用户可以通过�l�合化简�J�琐的操作。Composite模式在各�U�可视化�~�辑软�g中应用得最为广泛�?/p>

另一使用Composite的经�怾�子是Java的Swing�pȝ��。所有的Swing�l��g都是�l�承自一个叫做JComponent的接口，因此�Q�我们对一个JFrame的操作和对一个JButton的操作是一��L(f��ng)��。这同时也��得，JFrame在管理自��q��子元素时�Q�它不需要知道他们是一个JButton�q�是一个JPanel�Q�对它来��_(d��)��q�只是一个JComponent�?/p>

实现Composite模式的关键是良好设计的接口，��Z��应该对可能的元素�Q�简单的、组合的�Q�进行分析，�q�设计出通用的操作。尽可能的保证接口操作对所有元素都是有意义的，否则��应该将那些只对部分元素有意义的操作下放到子�c�M��?br />

保尔�?/a> 2006-07-31 17:16 发表评论

Proxy�Q�代理）模式

Tue, 25 Jul 2006 06:28:00 GMT

设计模式中定�?/b>: 为其他对象提供一�U�代理以控制对这个对象的讉K��.

��Z��么要使用Proxy?
1.授权机制

我们开发一个应用系�l�时�Q�用戯��求�Q何页面都要经�q�权限控�Ӟ��最早开发的时候我们常常封装一个权限验证方�?/span>,然后在每�?/span>jsp或者对应的servlet中增加相关代码，但是用户�Ҏ(gu��)��限的需求往往是多变的�Q�这样一旦权限验证方法变化（参数变化�Q�增加方法）�Q�如果开发的�pȝ��很庞大的话，有可能你��需要修改几百个jsp��面或�?/span>servlet代码�?br />�q�有我们帔R��要判�?/span>session是否�q�期�Q�如果过期就要重新登陆系�l�，如果每个��面或�?/span>servlet都要加判断代码，那也是�g比较痛苦的事情�?br />如果我们采用代理模式�Q�增�?/span>Proxy对象�Q�每�ơ用戯��求必��通过proxy对象处理�Q�由它专门处理相��x��限控�Ӟ��一旦权限需求变化了�Q�只需要修�?/span>Proxy对象相关的实现方法�?/span>

2.某个客户端不能直接操作到某个对象,但又必须和那个对象有所互动.
举例4个具体情�?
u 一个对象，比如一�q�很大的囑փ��Q�需要蝲入的旉��很长�?

u 一个需要很长时间才可以完成的计��结果，�q�且需要在它计��过�E�中昄��中间�l�果

u 一个存在于�q�程计算��Z��的对象，需要通过�|�络载入�q�个�q�程对象则需要很长时��_(d��)��特别是在�|�络传输高峰期�?

u 一个对象只有有限的讉K��权限�Q�代理模�?Proxy)可以验证用户的权�?

��M��原则�?对于开销很大的对�?只有在��用它时才创徏,�q�个原则可以为我们节省很多宝�늚�Java内存. 所�?有些��为Java耗费资源内存,我以��和程序编制思�\也有一定的关系.

��单实例：(x��)
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();
}
}

保尔�?/a> 2006-07-25 14:28 发表评论

Tue, 25 Jul 2006 03:09:00 GMT
1。采用Factory method、Builder和Abstract Factory模式可以分离接口和具体实玎ͼ�本文通过�c�L��讨论三者间的差异�?
下面举例说明三者间的差异，其中客户相当于模式��用者，商家相当于模式本�w�：(x��) 1. Factory method�c�M��购买品牌机，客户可以选择联想或DELL�Q�商家的模式是提供各�c�d��牌整机； 2. Builder�c�M��购买�l�装机，商家的模式是商家提供配�g�Q��ƈ按客��h��要求装机�Q�最后商家提供机器（得到一台整机）�Q� �?3. Abstract Factory�c�M��DIY�Q�用��h��据�h(hu��n)��|��比如分高中低三个价位�Q�每个�h(hu��n)位一套最优配�|�）选择一套配�Ӟ��Q�得��C��套配�Ӟ��?br />
2。Factory method和Abstract Factory模式区别�Q?br />虽然两种模式表面看来都是用来创徏对象的，Abstract Factory创徏一�l�products�Q?Factory Method只创��Z��个product�Q�但�q��ƈ不意味着Factory Method只是Abstract Factory在只有一个product时的特例�?br />�Q�以下把Abstract Factory模式��U�Cؓ(f��)AF�Q�把Factory Method��U�Cؓ(f��)FM�Q?br />
AF的适用性在设计模式一书中解释如下�Q?br />一个系�l�要独立于它的��品的创徏、组合和表示�Ӟ��
一个系�l�要由多个��品系列中的一个来配置的时候；
当你要强调一�p�d��相关的��品对象的设计以便�q�行联合使用�Ӟ��
当你提供一个��品类库，而只��x��C�它们的接口而不是实现时�?br />
FM的适用性在设计模式一书中解释如下�Q?br />当一个类不知道它所创徏的对象的�cȝ��时候；
当一个类希望由它的子�c�L��指定它所创徏的对象的时候；
当类创徏对象的职责委托给多个帮助子类中的某一�? �q�且你希望将"哪一个帮助子�c�L��代理�?�q�一信息局部化的时候�?br />
因此�Q�不同主要在于：(x��)
�Q?�Q�应用环境不同：(x��)FM中创��的职责�q�不仅限于创建对象，而AF通常只有创徏对象�q�一职责�?br />�Q?�Q�实现方式不同：(x��)FM是实现��承，抽象�c�d��现大部分操作�Q�通常仅将对象的创建工作�g�q�到子类来完成；AF是接口��承，抽象�c�通常不实��C�Q何功能，仅仅定义一�p�d��接口�Q�子�c�d��现抽象类定义的接口�?br />�Q?�Q�工厂方法可以说成template method在创建对象上面的应用�Q�目的是��装具体创徏哪个对象�Q�而抽象工厂是��Z��创徏一“系列”的产品�Q�抽象工厂通常用工厂方法来实现从而封装了具体创徏哪个产品�p�d��。抽象工厂可以通过一�p�d��工厂�Ҏ(gu��)��实现�?br />
3。template mothod vs strategy
�q�两个模式的相同之处在于它们可以使算法和上下文解耦，不同之处在于一个是使用�l�承来解决问题，另一个是��Z��委托�?而且strategy是对于整个算法的�Q�template是针对算法的具体步骤的�?/p>
4。Proxy模式和Strategy模式

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

保尔�?/a> 2006-07-25 11:09 发表评论

Prototype�Q�原型）模式

Mon, 24 Jul 2006 08:07:00 GMT

原型模式定义:
用原型实例指定创建对象的�U�类,�q�且通过拯��q�些原型创徏新的对象.

Prototype模式允许一个对象再创徏另外一个可定制的对象，�Ҏ(gu��)��无需知道��M��如何创徏的细�?工作原理�?通过��一个原型对象传�l�那个要发动创徏的对象，�q�个要发动创建的对象通过��h��原型对象拯��它们自己来实施创建�?/p>
如何使用?
因�ؓ(f��)Java中的提供clone()�Ҏ(gu��)��来实现对象的克隆,所以Prototype模式实现一下子变得很简�?

以勺子�ؓ(f��)例：(x��)

public abstract class AbstractSpoon implements Cloneable
{
　　String spoonName;

　　public void setSpoonName(String spoonName) {this.spoonName = spoonName;}
　　public String getSpoonName() {return this.spoonName;}

　　public Object clone()
　　{
　　　　Object object = null;
　　　　try {
　　　　　　object = super.clone();
　　　　} catch (CloneNotSupportedException exception) {
　　　　　　System.err.println("AbstractSpoon is not Cloneable");
　　　　}
　　　　return object;
　　}
}

有个具体实现(ConcretePrototype):

public class SoupSpoon extends AbstractSpoon
{
　　public SoupSpoon()
　　{
　　　　setSpoonName("Soup Spoon");
　　}
}

调用Prototype模式很简�?

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

当然也可以结合工厂模式来创徏AbstractSpoon实例�?/p>
在Java中Prototype模式变成clone()�Ҏ(gu��)��的��用，�׃��Java的纯�z�的面向对象�Ҏ(gu��)��，使得在Java中��用设计模式变得很自然�Q�两者已�l�几乎是��然一体了。这反映在很多模式上�Q�如Interator遍历模式�?/p>

保尔�?/a> 2006-07-24 16:07 发表评论

Mon, 24 Jul 2006 07:19:00 GMT
Builder模式定义:
��一个复杂对象的构徏与它�?strong>表示分离,使得同样的构��E�可以创��Z��同的表示.
Builder模式是一步一步创��Z��个复杂的对象,它允许用户可以只通过指定复杂对象的类型和内容��可以构建它�?用户不知道内部的具体构徏�l�节.Builder模式是非常类似抽象工厂模�?�l�微的区别大概只有在反复使用中才能体�?x��)�?

��Z��使用?
是�ؓ(f��)了将构徏复杂对象�?b>�q�程和它�?i>部�g解�?注意: 是解�?b>�q�程�?i>部�g.

因�ؓ(f��)一个复杂的对象,不但有很多大量组成部�?如汽�?有很多部�?车轮方向�?发动��有各�U�小零�g�{�等,部�g很多,但远不止�q�些,如何��这些部件装配成一辆汽�?�q�个装配�q�程也很复杂(需要很好的�l�装技�?,Builder模式��是��Z��部件和�l�装�q�程分开.

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

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

public interface Builder {

　　//创徏部�gA　　比如创徏汽�R车轮
　　void buildPartA();
　　//创徏部�gB 比如创徏汽�R方向�?br />　　void buildPartB();
　　//创徏部�gC 比如创徏汽�R发动�?br />　　void buildPartC();

　　//�q�回最后组装成品结�?(�q�回最后装配好的汽�?
　　//成品的组装过�E�不在这里进�?而是转移��C��面的Director�c�M��q�行.
　　//从而实��C��解�?b>�q�程�?i>部�g
　　Product getResult();

}

用Director构徏最后的复杂对象,而在上面Builder接口中封装的是如何创��Z��个个部�g(复杂对象是由�q�些部�g�l�成�?,也就是说Director的内�Ҏ(gu��)��如何��部件最后组装成成品:

public class Director {

　　private Builder builder;

　　public Director( Builder builder ) {
　　　　this.builder = builder;
　　}
　　// ��部件partA partB partC最后组成复杂对�?br />　　//�q�里是将车轮方向盘和发动机组装成汽�R的过�E?br />　　public void construct() {
　　　　builder.buildPartA();
　　　　builder.buildPartB();
　　　　builder.buildPartC();

　　}

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

public class ConcreteBuilder implements Builder {

　　Part partA, partB, partC;
　　public void buildPartA() {
　　　　//�q�里是具体如何构建partA的代�?br />
　　};
　　public void buildPartB() {
　　　　//�q�里是具体如何构建partB的代�?br />　　};
　　 public void buildPartC() {
　　　　//�q�里是具体如何构建partB的代�?br />　　};
　　 public Product getResult() {
　　　　//�q�回最后组装成品结�?br />　　};

}

复杂对象:产品Product:

public interface Product { }

复杂对象的部�?

public interface Part { }

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

director.construct();
Product product = builder.getResult();
�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q?br />通俗讲解�Q�Builder模式的理�?/strong>

��单地��_(d��)��好象我要一座房子住�Q�可是我不知道怎么盖（��单的砌墙�Q�层�ơ较低）�Q�也不知道怎么栯��计（建几个房��_(d��)��几个门好看，层次较高�Q�，于是我需要找一帮民工，他们�?x��)砌墙，�q�得找个设计师，他知道怎么设计�Q�我�q�要��保民工听设计师的领��|��而设计师本��n也不�q�活�Q�光是下命��o(h��)�Q�这里砌一堵墙�Q�这里砌一扇门�Q�这��h��工开始徏设，最后，我可以向民工要房子了。在�q�个�q�程中，设计师是什么也没有�Q�除了他在脑子里的设计和命��o(h��)�Q�所以要房子也是跟民工要�Q�记住了�Q?br />
��p��国内好多企业上erp一��P��上erp�Q�首先得找��Y件公司呀�Q�找到��Y件公司后�Q��Y件公司说�Q�我只知道怎么写��Y�Ӟ��q��道怎么实现�Q�不清楚整个erp的流�E�。好�Q�那我们�q�得找一个咨询公司，好，扑ֈ�德勤了，德勤说好�Q�我要��Y件怎么做，软�g公司怎么做，我就能保证��Y件能��Z��们提供erp�pȝ��了�?br />
此模式是��Z��让设计和施工解耦，互不�q�扰�?br />

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);//�?x��)输出window�Q�表�C�构建成功�?br /> }
}

保尔�?/a> 2006-07-24 15:19 发表评论

Template Method�Q�模板方法）模式

Fri, 21 Jul 2006 02:29:00 GMT
意图�Q�定义一个操作中的算法的骨架�Q�而将一些步骤�g�q�到子类中。template method使得子类可以不改变一个算法的�l�构卛_��重定义该��法得某些特定步骤�?br />需要遵循一个过�E�或一�p�d��步骤�Q�它们在某个具体层次上保持一��_(d��)��但单个步骤在更详�l�的层次上可能有不同的实现时�Q�用此模式。有人问�Q��ؓ(f��)什么不用多个strategy模式啊？我的理解�Q�strategy模式是每一步都可以选多个实玎ͼ�比如帽子可以选a,b,c�Q�鞋子可以选a,b,c�Q�但teamplate method是指只能选一套a�Q�或一套b�Q�一套c�Q�不能分开选，此时a�Q�b�Q�c直接有固定的联系�?br />

保尔�?/a> 2006-07-21 10:29 发表评论

Observer�Q�观察者）模式

Thu, 20 Jul 2006 02:15:00 GMT

按照“四人团”的说法�Q�Observer模式的意图是“定义对象间的一�U�一对多的依赖关�p�，当一个对象的状态发生改变时�Q�所有依赖于它的对象都得到通知�q�被自动更新”�?br />问题�Q�当某个事�g发生�Ӟ��你需要向一�p�d��对象发出通知�Q?strong>而这个对象的列表是不断变化的。（而当依赖关系固定或几乎固定时�Q�加入Observer模式只会(x��)增加复杂性）

��单来��_(d��)��Observer模式让一个对象（观察者，Observer�Q�去监视另一个对象（目标�Q�Subject�Q�；它��得目标和观察者之间徏立一�U?"发布--订阅"�Q�publish-subscribe �Q�的关系。通过Observer模式�Q�观察者可以向目标登记�Q�表明自��p��从目标接收事件。目标需要向观察者通知事�g�Ӟ��只是��单地��事件发�l�每一个观察者�?

例如�Q�有一个基于某�U�数据模型的�?sh��)子表格。只要数据模型发生变化，�?sh��)子表格��需要更新表格单元以�?qi��ng)内嵌的图表。这个例子中�Q�目标是数据模型�Q�观察者是表格单元和图表。当观察者接收到数据模型已经变化的通知�Ӟ��它们��更新自己�?

Observer模式的好处是�Q�它解除了观察者和目标之间的耦合关系。目标不需要知道它的观察者的��M��信息。相反，目标只是允许观察者订阅事件。当目标产生一个事件时�Q�它��单地��事件传�l�每一个观察者�?

看看下面的Java�C�Z��Q?

public interface Subject {
public void addObserver( Observer o );
public void removeObserver( Observer o );
}

上面的代码中�Q�Subject接口定义了两个方法（method�Q�，每个Subject都必��d��现它们，以��Observer可以在Subject中增加或删除自��n�?

public interface Observer {
public void update( Subject o );
}

Observer接口�Q�如上）列出了一个方法（method�Q�，每个Observer都必��d��现它�Q�以使Subject可以发送更新消息给Observer�?

下面看看Subject的一个简单的实现--IntegerDataBag�Q?

import java.util.ArrayList;
import java.util.Iterator;

public class IntegerDataBag implements Subject {

private ArrayList list = new ArrayList();
private ArrayList observers = new ArrayList();

public void add( Integer i ) {
list.add( i );
notifyObservers();
}

public Iterator iterator() {
return list.iterator();
}

public Integer remove( int index ) {
if( index < list.size() ) {
Integer i = (Integer) list.remove( index );
notifyObservers();
return i;
}
return null;
}

public void addObserver( Observer o ) {
observers.add( o );
}

public void removeObserver( Observer o ) {
observers.remove( o );
}

private void notifyObservers() {
// loop through and notify each observer
Iterator i = observers.iterator();
while( i.hasNext() ) {
Observer o = ( Observer ) i.next();
o.update( this );
}
}
}

IntegerDataBag适用于��用Integer的场合。IntegerDataBag也允许Observer增加和删除它们自�w��?

再看看两个Observer的实�?-IntegerAdder和IntegerPrinter�Q?

import java.util.Iterator;

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接收��C��条更新消息时�Q�它先统计bag中的��L��Q�然后显�C�结果。同��P��当IntegerPrinter接收��C��条更新消息时�Q�它打印出bag中的Interger�?

下面是一个简单的main()�Q�它使用了上面的几个�c�：(x��)

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 );
}
}

�q�行main�Q�你��看刎ͼ�(x��)

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本��n有大量��用Observer模式的例子：(x��)AWT/Swing事�g模型�Q�还有java.util.Observer和java.util.Observable接口�{�，都是很好的例�?br />

保尔�?/a> 2006-07-20 10:15 发表评论

Decorator�Q�装饎ͼ�模式

Wed, 19 Jul 2006 08:02:00 GMT

JDK为程序员提供了大量的�c�d��Q�而�ؓ(f��)了保持类库的可重用性，可扩展性和灉|��性，其中使用��C��大量的设计模式，本文��介�l�JDK的I/O包中使用到的Decorator模式�Q��ƈ�q�用此模式，实现一个新的输出流�c�R��?br />
　　 Decorator模式��介�?br />
　　 Decorator模式又名包装�?Wrapper)�Q�它的主要用途在�?strong>�l�一个对象动态的��d��一些额外的职责。与生成子类相比�Q�它更具有灵�z�L�?/strong>�?br />有时候，我们需要�ؓ(f��)一个对象而不是整个类��d��一些新的功能，比如�Q�给一个文本区��d��一个滚动条的功能。我们可以��用��承机制来实现�q�一功能�Q�但是这�U�方法不够灵�z�，我们无法控制文本区加滚动条的方式和时机。而且当文本区需要添加更多的功能�Ӟ��比如�Ҏ(gu��)��{�，需要创建新的类�Q�而当需要组合��用这些功能时无疑��会(x��)引�v�cȝ��爆炸�?

　　我们可以使用一�U�更为灵�zȝ��Ҏ(gu��)��Q�就是把文本区嵌入到滚动条中。而这个滚动条的类��q��当于�Ҏ(gu��)��本区的一�?strong>装饰�?�q�个装饰(滚动�?必须与被装饰的组�?文本�?�l�承自同一个接口，�q�样�Q�用户就不必兛_��装饰的实玎ͼ�因�ؓ(f��)�q�对他们来说是透明的。装��C��(x��)��用��L(f��ng)��h��转发 �l�相应的�l��g(卌��用相关的�Ҏ(gu��)��)�Q��ƈ可能在�{发的前后做一些额外的动作(如添加滚动条)。通过�q�种�Ҏ(gu��)��Q�我们可以根据组合对文本区嵌套不同的装饰�Q�从�?��d��L��多的功能。这�U�动态的对对象添加功能的�Ҏ(gu��)��不会(x��)引�v�cȝ��爆炸�Q�也��h��了更多的灉|��性�?br />
　　以上的方法就�?strong>Decorator模式�Q�它通过�l�对象添加装饰来动态的��d��新的功能。如下是Decorator模式的UML图：(x��)

　　 Component为组件和装饰的公��q��c�，它定义了子类必须实现的方法�?br />
　　 ConcreteComponent是一个具体的�l��g�c�，可以通过�l�它��d��装饰来增加新的功能�?br />
　　 Decorator是所有装饰的公共父类�Q�它定义了所有装饰必��d��现的�Ҏ(gu��)��Q�同�Ӟ��它还保存了一个对于Component的引用，以便��用��L(f��ng)��h��转发�l�C(j��)omponent�Q��ƈ可能在�{发请求前后执行一些附加的动作�?br />
　　 ConcreteDecoratorA和ConcreteDecoratorB是具体的装饰�Q�可以��用它们来装饰具体的Component�?br />
　　Java IO包中的Decorator模式

　　 JDK提供的java.io包中使用了Decorator模式来实现对各种输入输出��的��装。以下将以java.io.OutputStream�?qi��ng)其子类��Z��Q�讨��Z��下Decorator模式在IO中的使用�?br />
　　首先来看一�D는�来创建IO��的代码�Q?br />

以下是代码片�D�：(x��)
try {
　 OutputStream out = new DataOutputStream(new FileOutputStream("test.txt"));
} catch (FileNotFoundException e) {
　 e.printStackTrace();
}

　　�q�段代码对于使用�q�JAVA输入输出��的人来说再熟�?zh��n)�不过了，我们使用DataOutputStream��装了一个FileOutputStream�?�q�是一个典型的Decorator模式的��用，FileOutputStream相当于Component�Q�DataOutputStream��是一�?Decorator。将代码�Ҏ(gu��)��如下�Q�将�?x��)更��?gu��)��理解�Q?br />

以下是代码片�D�：(x��)
try {
　 OutputStream out = new FileOutputStream("test.txt");
　 out = new DataOutputStream(out);
} catch(FileNotFoundException e) {
　 e.printStatckTrace();
}

　　 �׃��FileOutputStream和DataOutputStream有公��q��父类OutputStream�Q�因此对对象的装饰对于用��h��说几乎是透明的。下面就来看看OutputStream�?qi��ng)其子类是如何构成Decorator模式的：(x��)

　　 OutputStream是一个抽象类�Q�它是所有输出流的公��q��c�，其源代码如下�Q?br />

以下是代码片�D�：(x��)
public abstract class OutputStream implements Closeable, Flushable {
　 public abstract void write(int b) throws IOException;
　 ...
}

　　它定义了write(int b)的抽象方法。这相当于Decorator模式中的Component�c�R�?br />
　　 ByteArrayOutputStream�Q�FileOutputStream �?PipedOutputStream 三个�c�都直接从OutputStream�l�承�Q�以ByteArrayOutputStream��Z��Q?br />

以下是代码片�D�：(x��)
public class ByteArrayOutputStream extends OutputStream {
　 protected byte buf[];
　 protected int count;
　 public ByteArrayOutputStream() {
　　 this(32);
　 }
　 public ByteArrayOutputStream(int size) {
　　 if (size �?0) {
　　　 throw new IllegalArgumentException("Negative initial size: " + size);
　　 }
　　 buf = new byte[size];
　 }
　 public synchronized void write(int b) {
　　 int newcount = count + 1;
　　 if (newcount �?buf.length) {
　　　 byte newbuf[] = new byte[Math.max(buf.length 〈�?1, newcount)];
　　　 System.arraycopy(buf, 0, newbuf, 0, count);
　　　 buf = newbuf;
　　 }
　　 buf[count] = (byte)b;
　　 count = newcount;
　 }
　 ...
}

　　它实��C��OutputStream中的write(int b)�Ҏ(gu��)��Q�因此我们可以用来创��出流的对象，�q�完成特定格式的输出。它相当于Decorator模式中的ConcreteComponent�c�R�?br />
　　接着来看一下FilterOutputStream�Q�代码如下：(x��)

以下是代码片�D�：(x��)
public class FilterOutputStream extends OutputStream {
　 protected OutputStream out;
　 public FilterOutputStream(OutputStream out) {
　　 this.out = out;
　 }
　public void write(int b) throws IOException {
　　 out.write(b);
　 }
　...
}

　　同样�Q�它也是从OutputStream�l�承。但是，它的构造函数很特别�Q�需要传递一个OutputStream的引用给它，�q�且它将保存�Ҏ(gu��)��对象的引用。而如果没有具体的OutputStream对象存在�Q�我们将无法创徏FilterOutputStream。由于out既可以是指向 FilterOutputStream�c�d��的引用，也可以是指向B(t��i)yteArrayOutputStream�{�具体输出流�cȝ��引用�Q�因此��用多层嵌套的�?式，我们可以为ByteArrayOutputStream��d��多种装饰。这个FilterOutputStream�cȝ��当于Decorator模式中的 Decorator�c�，它的write(int b)�Ҏ(gu��)��只是��单的调用了传入的��的write(int b)�Ҏ(gu��)��Q�而没有做更多的处理，因此它本质上没有�Ҏ(gu��)��q�行装饰�Q�所以��承它的子�c�d��覆盖此�Ҏ(gu��)��Q�以辑ֈ�装饰的目的�?br />
　　 BufferedOutputStream �?DataOutputStream是FilterOutputStream的两个子�c�，它们相当于Decorator模式中的 ConcreteDecorator�Q��ƈ对传入的输出��做了不同的装饰。以BufferedOutputStream�c�Mؓ(f��)例：(x��)

以下是代码片�D�：(x��)
public class BufferedOutputStream extends FilterOutputStream {
　 ...
　 private void flushBuffer() throws IOException {
　　 if (count �?0) {
　　　 out.write(buf, 0, count);
　　　 count = 0;
　　 }
　 }
　 public synchronized void write(int b) throws IOException {
　　 if (count �? buf.length) {
　　　 flushBuffer();
　　 }
　　 buf[count++] = (byte)b;
　 }
　 ...
}

　　�q�个�c�L��供了一个缓存机�Ӟ��{�到�~�存的容量达��C��定的字节数时才写入输出流。首先它�l�承了FilterOutputStream�Q��ƈ且覆盖了父类�?write(int b)�Ҏ(gu��)��Q�在调用输出��写出数据前都会(x��)��查缓存是否已满，如果未满�Q�则不写。这样就实现了对输出��对象动态的��d��新功能的目的�?br />
　　下面�Q�将使用Decorator模式�Q��ؓ(f��)IO写一个新的输出流�?br />
　　自己写一个新的输出流

　　了解了OutputStream�?qi��ng)其子类的结构原理后�Q�我们可以写一个新的输出流�Q�来��d��新的功能。这部分中将�l�出一个新的输出流的例子，它将�q��o(h��)待输��句中的空格符受��比如需要输�?java io OutputStream"�Q�则�q��o(h��)后的输出�?javaioOutputStream"。以下�ؓ(f��)SkipSpaceOutputStream�cȝ��代码�Q?br />

以下是代码片�D�：(x��)
import java.io.FilterOutputStream;
import java.io.IOException;
import java.io.OutputStream;
/**
* A new output stream, which will check the space character
* and won't write it to the output stream.
* @author Magic
*
*/
public class SkipSpaceOutputStream extends FilterOutputStream {
　 public SkipSpaceOutputStream(OutputStream out) {
　　 super(out);
　 }
　 /**
　 * Rewrite the method in the parent class, and
　 * skip the space character.
　 */
　 public void write(int b) throws IOException{
　　 if(b!=' '){
　　　 super.write(b);
　　 }
　 }
}

　　它从FilterOutputStream�l�承�Q��ƈ且重写了它的write(int b)�Ҏ(gu��)��。在write(int b)�Ҏ(gu��)��中首先对输入字符�q�行了检查，如果不是�I�格�Q�则输出�?br />
　　以下是一个测试程序：(x��)

以下是代码片�D�：(x��)
import java.io.BufferedInputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Test the SkipSpaceOutputStream.
* @author Magic
*
*/
public class Test {
　 public static void main(String[] args){
　　 byte[] buffer = new byte[1024];

　　 /**
　　 * Create input stream from the standard input.
　　 */
　　 InputStream in = new BufferedInputStream(new DataInputStream(System.in));

　　 /**
　　 * write to the standard output.
　　 */
　　 OutputStream out = new SkipSpaceOutputStream(new DataOutputStream(System.out));

　　 try {
　　　 System.out.println("Please input your words: ");
　　　 int n = in.read(buffer,0,buffer.length);
　　　 for(int i=0;i< n;i++){
　　　　 out.write(buffer[i]);
　　　 }
　　 } catch (IOException e) {
　　　 e.printStackTrace();
　　 }
　 }
}

　　执行以上��试�E�序�Q�将要求用户在console�H�口中输入信息，�E�序��过滤掉信息中的�I�格�Q��ƈ��最后的�l�果输出到console�H�口。比如：(x��)

以下是引用片�D�：(x��)
Please input your words:
a b c d e f
abcdef

　　总结

　　在java.io包中�Q�不仅OutputStream用到了Decorator设计模式�Q�InputStream�Q�Reader�Q�W(xu��)riter�{�都用到了此模式。而作��Z��个灵�zȝ��Q�可扩展的类库，JDK中��用了大量的设计模式，比如在Swing包中的MVC模式�Q�RMI中的Proxy模式�{�等。对于JDK中模式的研究不仅能加深对于模式的理解�Q�而且�q�有利于更透彻的了解类库的�l�构和组成。�?/span>

�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－�Q�－

600) this.width=screen.width-600" />

decorator for non-visualable class e.g. java.io.*

The class FilterInputStream itself simply overrides all methods of InputStream with versions that pass all requests to the underlying input stream. Subclasses of FilterInputStream may further override some of these methods as well as provide additional methods and fields.

The FilterInputStream class is thus a Decorator that can be wrapped around any input stream class. It is essentially an abstract class that doesn’t do any processing, but provides a layer where the relevant methods have been duplicated. It normally forwards these method calls to the enclosed parent stream class. The interesting classes derived from FilterInputStream include:

BufferedInputStream Adds buffering to stream so that every call does

not cause I/O to occur.

CheckedInputStream  Maintains a checksum of bytes as they are read

DataInputStream     Reads primitive types (Long, Boolean, Float, etc.)

from the input stream.

DigestInputStream   Computes a MessageDigest of any input stream.

InflaterInputStream Implements methods for uncompressing data.

PushbackInputStream Provides a buffer where data can be “unread,” if

during parsing you discover you need to back up.

保尔�?/a> 2006-07-19 16:02 发表评论

Strategy�Q�策略）模式

Wed, 19 Jul 2006 06:00:00 GMT

Strategy�{�略模式是属于设计模式中对象行�ؓ(f��)型模�?主要是定义一�p�d��的算�?把这些算法一个个��装成单独的�c?

Stratrgy应用比较�q�泛,比如, 公司�l�营业务变化�? 可能有两�U�实现方�?一个是�U�条曲线,一个是框图(bar),�q�是两种��法,可以使用Strategy实现.

�q�里以字�W�串替代��Z��, 有一个文�?我们需要读取后,希望替代其中相应的变�?然后输出.关于替代其中变量的方法可能有多种�Ҏ(gu��)��,�q�取决于用户的要�?所以我们要准备几套变量字符替代�Ҏ(gu��)��.

首先,我们建立一个抽象类RepTempRule 定义一些公用变量和�Ҏ(gu��)��:

public abstract class RepTempRule{

protected String oldString="";
public void setOldString(String oldString){
　　this.oldString=oldString;
}

protected String newString="";
public String getNewString(){
　　return newString;
}

public abstract void replace() throws Exception;

}

在RepTempRule�?有一个抽象方法abstract需要��承明��?�q�个replace里其实是替代的具体方�?
我们现在有两个字�W�替代方�?
1.��文本中aaa替代成bbb;
2.��文本中aaa替代成ccc;

对应的类分别是RepTempRuleOne RepTempRuleTwo

public class RepTempRuleOne extends RepTempRule{

public void replace() throws Exception{

　　//replaceFirst是jdk1.4新特�?
　　newString=oldString.replaceFirst("aaa", "bbbb")
　　System.out.println("this is replace one");
　　
}

}

public class RepTempRuleTwo extends RepTempRule{

public void replace() throws Exception{

　　newString=oldString.replaceFirst("aaa", "ccc")
　　System.out.println("this is replace Two");
　　
}

}

�W�二步：(x��)我们要徏立一个算法解决类�Q�用来提供客��L(f��ng)��可以自由选择��法�?/p>

public class RepTempRuleSolve {

　　private RepTempRule strategy;

　　public RepTempRuleSolve(RepTempRule rule){
　　　　this.strategy=rule;
　　}

　　public String getNewContext(Site site,String oldString) {
　　　　return strategy.replace(site,oldString);
　　}

　　public void changeAlgorithm(RepTempRule newAlgorithm) {
　　　　strategy = newAlgorithm;
　　}

}

调用如下:

public class test{

......

　　public void testReplace(){

　　//使用�W�一套替代方�?br />　　RepTempRuleSolve solver=new RepTempRuleSolve(new RepTempRuleSimple());
　　solver.getNewContext(site,context);

　　//使用�W�二�?/p>

　　solver=new RepTempRuleSolve(new RepTempRuleTwo());
　　solver.getNewContext(site,context);

　　}

.....

}

我们辑ֈ�了在�q�行期间�Q�可以自由切换算法的目的�?/p>

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

Strategy和Factory有一定的�c�M��,Strategy相对��单容易理�?�q�且可以在运行时刻自由切换。Factory重点是用来创建对象�?/p>

Strategy适合下列场合:

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

2.以不同的��法压羃文�g;

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

4.以不同的格式输出同样数据的图�?比如曲线或框图bar�{?/p>

保尔�?/a> 2006-07-19 14:00 发表评论

��单工厂，Factory Method�Q�工厂方法）和Abstract Factory�Q�抽象工厂）模式

Tue, 18 Jul 2006 03:20:00 GMT

对于��单工厂来�?/strong>�Q�它的工厂只能是�q�个样子�?br /> public class SimplyFactory {
/**
* 静态工厂方�?br /> */
public static Prouct factory(String which) throw NoSuchProductExcption
{

   if(which.equalIgnoreCase("product1"))
   {
   return new Product1();
    }
   else if(which.equalsIgnoreCase("product2"))
      {
        return new Product2();
       }
  else if(which.equalsIgnoreCase("product3"))
      {
        return new Product3();
       }
  else throw  NoSuchProductExcption("NoSuchProduct");
   }
}
}

而对产品Product1,Product2,Product3,可以执行接口Product,也可以不执行接口Product�Q�当然这样不好）�Q�这个Product接口只是用来抽象具体product用的

public interface Product
{
  void productMethod1();     //�q�些只是
  void productMethod2();
  void productMethod3();
}
对工厂来��_(d��)��只要有这么一�U��品，一般来说就要在工厂里有它的生��的方法，否则抛出异常�Q�而要工厂生��的话�Q�也必须下达生��什么��品的命��o(h��)�Q�至��要向工厂发��Z��P��让工厂��以区分是要生产什么��品，否则工厂是不知道生��哪一�U��品，
对于��单工厂来��_(d��)��是需要在工厂中枚举所有的产品�Q�所以说��单工厂还是非常笨的�?nbsp;

if(which.equalIgnoreCase("product1"))     只是用来区分生��什么��品的标记��|��Q�也可以�Ҏ(gu��)��产品其它属性来判断�Q�比如��品类型，产品大小�Q��M��能够区分是什么��品的属性，或者是与��品属性相关的变量�Q?nbsp;   或者说标记值是A,生��A产品�Q�或者工厂里定义不是�q�样的，我偏偏要生��B产品�Q�或者再�Ҏ(gu��)��一些，我偏偏要生��A产品+B产品�Q�那么就要return new ProductA()+new ProductB()了�?br />
�q�样�Q�我们就可以看出一个问题来�Q�如果要能够被简单工厂生产出来，��必��d��单工厂中有能够生产出的它的方法定义，当然�q�需要有�q�个具体产品�cȝ��定义�Q�就是有class对应�Q�这��L(f��ng)��保在��单工厂中new 它的时候不�?x��)抛�?nbsp;NoSuchProduct的Exception.

对于工厂�Ҏ(gu��)��来说
实质上它是让工厂实现了抽象的工厂接口�Q�它把具体怎么生��一�U�东西，攑֜�具体的工厂去实现了，所�?#8221;延迟到子�c�M��实现“
public interface Creator
{
  public Prouct factory();
}

public SubCreator1 implent Creator
{
   public Prouct factory()
  {
   return new ConcreteProduct1();
   }
}

public SubCreator2 implent Creator
{
   public Prouct factory()
  {
    return new ConcreteProduct2();
   }
}
��h��意：(x��)�q�回�c�d��是Product型的�Q�！
�q�样客户端调用是直接new 一个具体工厂的实例�Q�然后命令它�ȝ��产，而对于具体工厂的父类�Q�既工厂接口�Q�接口完全可以改成子�cȝ��承父�c�L��实现�Q�只是这样不好，不符合OO的原则）�Q�它完全不知道什么��品被生��了，甚至它连那个具体工厂被实例化它都不知�?br />
抽象工厂模式
抽象工厂模式意图�?#8220;提供一个创��Z��p�d��相关或相互依赖对象的接口�Q�而无需指定他们具体的类”或�ؓ(f��)特定的客��P��或情况）提供特定�p�d��的对象�?br />
public interface Creator
{
   public ProuctA factoryA();
   public ProuctB factoryB();
}

public interface ProductA     //ProductA 接口
{
}

public interface ProductB     //ProductB 接口
{
}

public class ConCreator1 implent Creator
{
   public ProuctA factoryA()
  {
   return new ConcreteProductA1();
   }

   public ProuctB factoryB()
  {
   return new ConcreteProductB1();
   }
}

public class ConCreator2 implent Creator
{
   public ProuctA factoryA()
   {
    return new ProductA2();
    }

   public ProuctB factoryB()
   {
   return new ProductB2();
    }
}

public class ProductA1 implements  ProductA
{
public  ProductA1()
   {
    }
}
public class ProductA2 implements  ProductA
{
public  ProductA2()
   {
    }
}
public class ProductB1 implements  ProductB
{
public  ProductB1()
   {
    }
}
public class ProductB2 implements  ProductB
{
public  ProductB2()
   {
    }
}
实际上是�q�样�?br /> 1�Q�两个工厂类ConCreator1�Q�ConCreator2都实��C��Creator接口
2�Q�ProuctA1,ProductA2都实��C��ProductA接口
3�Q�ProuctB1,ProductB2都实��C��ProductB接口
4�Q�ConCreator1负责生��ProductA�c�d��的��?包括ProductA1�Q�ProductB1)
5�Q�ConCreator2负责生��ProductB�c�d��的��?包括ProductA2�Q�ProductB2)
6�Q�工厂方法也有这��L(f��ng)��特征�Q�也��是说Creator不知道什么被生��出来�Q�甚至不知道ConCreator1�q�是ConCreator2被实例化了，因�ؓ(f��)client高兴调那一个工厂，��p��那一个工厂，��是说工厂能生��什么，对客��L(f��ng)��是可见的。甚臌��有一�U�情况，客户端高兴�v来就生��了ProductA1,我就不生产ProductA2,因�ؓ(f��)上面的例子中它们�q�都是松散的�Q�没有绑定在一�?br />

于是提出另外一个例子，也是老提��L(f��ng)��?sh��)脑�c�d��的例�?br />
1�Q�电(sh��)脑生产商是接口，
2�Q�CUP是接口，
3�Q�硬盘是接口�Q?br /> 4�Q�IBM工厂是制造IBM品牌的电(sh��)脑的工厂
5�Q�DELL工厂是制造DEll品牌的电(sh��)脑的工厂
��论方便，��p��为电(sh��)�?CUP+��盘�Q?br /> 6�Q�所以呀CUP有IBM的CPU和DELL的CPU
7�Q�同��L(f��ng)��盘也是有IBM的硬盘和DELL的硬�?br /> 8�Q�IBM工厂生��IBM的CPU和IBM的硬盘，�l�对不生产DELL的CPU�Q�也不生产DELL的硬�?br /> 9�Q�同样DELL工厂也是一�?br />

public interface  �?sh��)脑生��?br /> {
   public CPU 刉��CPU();
   public ��盘刉��硬�?);
}

public interface CPU
{
}

public interface ��盘
{
}

public class IBM的CPU implements CPU
{
   public     IBM的CPU();
}

public class IBM的硬�?nbsp;implements ��盘
{
    public     IBM的硬�?);
}

public class DELL的CPU implements CPU
{
    public     DELL的CPU();
}

public class DELL的硬�?nbsp;implements ��盘
{
   public     DELL的硬�?);
}

//下面是IBM工厂
public class  IBM工厂
{
   private CPU IBM的CPU�U�有变量=null;
   private ��盘 IBM的硬盘私有变�?null;
   private CPU 刉��IBMCPU()
  {
     return  new IBM的CPU();
   }
private ��盘刉��IBM��盘()
{
    return  new IBM的CPU();
}
public �?sh��)�?nbsp; 刉��IBM�?sh��)�?)
{
  try{
  IBM的CPU�U�有变量=刉��IBMCPU();
  IBM的硬盘私有变�?刉��IBM��盘();
  if(IBM的CPU�U�有变量!=null&&IBM的硬盘私有变�?=null)
  retrun  (IBM的CPU�U�有变量+IBM的硬盘私有变�?;
    //�l�装成IBM�?sh��)�?br />    }
  catch(Exception e)
    {
    System.out.println("刉��IBM�?sh��)脑��p�|�Q?);
     }
   }
}
}

�q�样�Q�客��L(f��ng)��无法通过命��o(h��)单生产出一个CPU来，�q�样抽象才真正成��Z��个完整��品的工厂�Q�只要向工厂发出生��的命令，一台完整的�?sh��)脑��q��产出来了�Q�而工厂怎么生��的，生��了哪些部�Ӟ��外界��q��不见了，外界��q��道这个工厂是生��IBM�?sh��)脑整机的工厂�?br />
DELL�?sh��)脑工厂一�?

----------------------------�ȝ��----------------------------

工厂�Ҏ(gu��)��模式�Q?br /> 一个抽象��品类�Q�可以派生出多个具体产品�c�R�?nbsp;
一个抽象工厂类�Q�可以派生出多个具体工厂�c�R�?nbsp;
每个具体工厂�c�d��能创��Z��个具体��品类的实例�?br />
抽象工厂模式�Q?br /> 多个抽象产品�c�，每个抽象产品�c�d��以派生出多个具体产品�c�R�?nbsp;
一个抽象工厂类�Q�可以派生出多个具体工厂�c�R�?nbsp;
每个具体工厂�c�d��以创建多个具体��品类的实例�?nbsp;

区别�Q?br /> 工厂�Ҏ(gu��)��模式只有一个抽象��品类�Q�而抽象工厂模式有多个�?nbsp;
工厂�Ҏ(gu��)��模式的具体工厂类只能创徏一个具体��品类的实例，而抽象工厂模式可以创建多个�?/font>

保尔�?/a> 2006-07-18 11:20 发表评论

Singleton�Q�单态）模式 �?Double-Checked Locking�Q�双重检查锁定）模式

Tue, 18 Jul 2006 02:56:00 GMT
��保一个特定的�c�d��有一个对象被实例化�?br />
Singleton�Q�用于单�U�程应用�E�序
public class Singleton {
　　private Singleton(){}
　　//在自己内部定义自�׃��个实例，是不是很奇怪？
　　//注意�q�是private 只供内部调用
　　private static Singleton instance = new Singleton();
　　//�q�里提供了一个供外部讉K��本class的静态方法，可以直接讉K��　　
　　public static Singleton getInstance() {
　　　　return instance; 　　
　　 }
}
Double-Checked Locking�Q�用于多�U�程应用�E�序
public class Singleton {
　　private static Singleton instance = null;

　　public static synchronized Singleton getInstance() {

　　//�q�个�Ҏ(gu��)��比上面有所改进�Q�不用每�ơ都�q�行生成对象�Q�只是第一�ơ　　　　
　　//使用时生成实例，提高了效率！
　　if (instance==null)
　　　　instance�Q�new Singleton();
　　return instance; 　　}
}

Double-Checked Locking在java实际上无法得到预期的效果�Q�不能保证singleton的正��性�?br />参考：(x��)�Q�英文）
http://gee.cs.oswego.edu/dl/cpj/jmm.html
http://www.cs.umd.edu/~pugh/java/memoryModel/DoubleCheckedLocking.html

保尔�?/a> 2006-07-18 10:56 发表评论

设计模式的原则和�{�略

Tue, 18 Jul 2006 02:08:00 GMT
1、发现、分��dƈ��装变化炏V�?br />2、优先��用对象组合，而不是类�l�承�?br />3、针�Ҏ(gu��)��口设计而不是实现设计�?br />4、开放－��闭原则�Q�模块、类和方法应该对扩展是开攄��Q�而对更改是封闭的�?img src ="http://m.tkk7.com/renyangok/aggbug/58695.html" width = "1" height = "1" />

保尔�?/a> 2006-07-18 10:08 发表评论

Adapter�Q�适配器）模式

Tue, 11 Jul 2006 00:52:00 GMT
��一个类的接口�{换成客户希望的另外一个接口。Adapter模式使得原本�׃��接口不兼容而不能一起工作的那些�c�d��以一起工作�?
有时�Q��ؓ(f��)复用而设计的工具��q��不能够被复用的原因仅仅是因�ؓ(f��)它的接口与专业应用领域所需要的接口不匹配�?br />    适配器模式有�cȝ��适配器模式和对象的适配器模式两�U�不同的形式�?br />
一、类的适配器模�?br />    �cȝ��适配器模式把适配的类的API转换成目标类的API�?br />

目标(Target)角色�Q�这��是所期待得到的接口�?
�?Adaptee)角色�Q�现有需要适配的接口�?
适配�?Adapter)角色�Q�适配器类是本模式的核心。适配器把源接口�{换成目标接口。显然这一角色不可以是接口�Q�而必��L��具体�c�R�?/li>
/**
* 定义Client使用的与特定领域相关的接�?br /> */
public interface Target {
    void sampleOperation1();
    void sampleOperation2();
}
/**
* 定义一个已�l�存在的接口�Q�这个接口需要适配
*/
public class Adaptee {
    public void sampleOperation1() {
        // ......
    }
}
/**
* 对Adaptee与Target接口�q�行适配
*/
public class Adapter extends Adaptee implements Target {
    public void sampleOperation2() {
        // ......
    }
}

二、对象适配�?br />    与类的适配器模式一��P��对象适配器模式把适配的类的API转换成�ؓ(f��)目标�cȝ��API�Q�与�cȝ��适配器模式不同的是，对象的适配器模式不是��用��承关�p�连接到Adaptee�c�，而是使用委派关系�q�接到Adaptee�c�R��示意代码如下：(x��)
/**
* 定义Client使用的与特定领域相关的接�?br /> */
public interface Target {
    void sampleOperation1();
    void sampleOperation2();
}
/**
* 定义一个已�l�存在的接口�Q�这个接口需要适配
*/
public class Adaptee {
    public void sampleOperation1() {
        // ......
    }
}
/**
* 对Adaptee与Target接口�q�行适配
*/
public class Adapter implements Target {
    private Adaptee adaptee;
    public Adapter(Adaptee adaptee) {
        super();
        this.adaptee = adaptee;
    }
    public void sampleOperation1() {
        adaptee.sampleOperation1();
    }
    public void sampleOperation2() {
        // ......
    }
}

�c�适配器模式和对象适配器模式的异同�Q�Target接口和Adaptee�c�都相同�Q�不同的是类适配器的Adapter�l�承Adaptee实现Target�Q�对象适配器的Adapter实现Target聚集Adaptee�?br />
适配器模式的用意是将接口不同而功能相同或者相�q�的两个接口加以转换�?br />
三、JDBC驱动软�g与适配器模�?br />    JDBC�l�出一个客��L(f��ng)��通用的界面，每个数据库引擎的JDBC驱动软�g都是一个介于JDBC接口和数据库引擎接口之间的适配器��Y件�?br />

保尔�?/a> 2006-07-11 08:52 发表评论

Facade�Q�外观）模式

Mon, 10 Jul 2006 09:15:00 GMT
Facade模式的定�?/em> : 为子�pȝ��中的一�l�接口提供一个一致的界面.。现在的软�g都是按照模块�q�行划分�Q�对不同的模块分别进行编�E�。但是在用户开来，不同的模块应该具有统一的接口，换句话说�Q�我们应该可以通过�l�一的接口访问系�l�中的所有功能�?
    有一个很典型的例子就是编译系�l�。通常我们��编译系�l�分解�ؓ(f��)�Q�Compile和Link两个步骤。一个Compile又可以分解�ؓ(f��)词法分析、语法分析、语义分析、中间代码生成等�{�步骤。对于用��h��Ԍ��我们不可能将�q�些模块分别提供�l�他们，让他们依�ơ调用。相反的�Q�我们应该提供一个统一的接口，使得用户可以方便的��用各个功能，例如IDE �?/p>
Facade一个典型应用就是数据库JDBC的应�?如下例对数据库的操作:
public class DBCompare {
　　Connection conn = null;
　　PreparedStatement prep = null;
　　ResultSet rset = null;
　　try {
　　　　Class.forName( "" ).newInstance();
　　　　 conn = DriverManager.getConnection( "" );
　　　　
　　　　 String sql = "SELECT * FROM
WHERE = ?";
　　　　 prep = conn.prepareStatement( sql );
　　　　 prep.setString( 1, "" );
　　　　 rset = prep.executeQuery();
　　　　 if( rset.next() ) {
　　　　　　　　System.out.println( rset.getString( "　　　　　}
　　} catch( SException e ) {
　　　　 e.printStackTrace();
　　} finally {
　　　　 rset.close();
　　　　 prep.close();
　　　　 conn.close();
　　}
}
上例是Jsp中最通常的对数据库操作办�?
在应用中,�l�常需要对数据库操�?每次都写上述一�D�代码肯定比较麻�?需要将其中不变的部分提炼出�?做成一个接�?�q�就引入了facade外观对象.如果以后我们更换Class.forName中的也非常方�?比如从Mysql数据库换到Oracle数据�?只要更换facade接口中的driver��可�?
我们做成了一�?a target="_blank">Facade接口,使用该接�?上例中的�E�序��可以更改如�?
public class DBCompare {

　 String sql = "SELECT * FROM
WHERE = ?";　　

　　try {
　　　　Mysql msql=new mysql(sql);
　　　　 prep.setString( 1, "" );
　　　　 rset = prep.executeQuery();
　　　　 if( rset.next() ) {
　　　　　　　　System.out.println( rset.getString( "　　　　　}
　　} catch( SException e ) {
　　　　 e.printStackTrace();
　　} finally {
　　　　 mysql.close();
　　　　 mysql=null;
　　}
}
可见非常��?所有程序对数据库访问都是��用改接口,降低�pȝ��的复杂�?增加了灵�z�L�?
如果我们要��用连接池,也只要针对facade接口修改��可�?

�׃��囑֏�以看�? facade实际上是个理��系�l�间关系,降低�pȝ��间耦合度的一个常用的办法,也许你已�l�不知不觉在使用,��管不知道它?y��u)��是facade.

保尔�?/a> 2006-07-10 17:15 发表评论

Bridge�Q�桥接）模式

Mon, 10 Jul 2006 09:13:00 GMT

Bridge模式的目的：(x��)把抽象部分和行�ؓ(f��)部分分离�Q��它们都能独立变化�?br />

��M��事物对象都有抽象和行��Z��分，例如人，人是一�U�抽象，人分男�h和女人等�Q��h有行为，行�ؓ(f��)也有各种具体表现�Q�所以，“�h”与“�h的行为”两个概念也反映了抽象和行�ؓ(f��)之分�?/p>
在面向对象设计的基本概念中，对象�q�个概念实际是由属性和行�ؓ(f��)两个部分�l�成的，属性我们可以认为是一�U�静止的�Q�是一�U�抽象，一般情况下�Q�行为是包含在一个对象中�Q�但是，在有的情况下�Q�我们需要将�q�些行�ؓ(f��)也进行归�c�，形成一个�ȝ��行�ؓ(f��)接口�Q�这��是桥模式的用处�?br />

��M��Q�Bridge模式��是使抽象和行�ؓ(f��)分离�Q�做到各自的独立发展�Q�就是说抽象和行为各抽象��Z��个接口。当需要扩展行为或者抽象部分时�Q?br />只需扩展相应部分�Q�而不用修改原来的�l�构�?br />
例子一�Q?/strong>
假如有个�c�DrawGraph有个��d��的接口，当然�q�个圆�Ş可以用铅�W�画�Q�也可以用钢�W�画。其中画圆是抽象部分�Q?br />用铅�W�画和用钢笔��L��行�ؓ(f��)部分。往往�q�个时候我们分别会(x��)定义铅笔�c�PencilDraw�Q�钢�W�类PenDraw来实现Draw�Q?br />�q�样��׃��得抽象部分和行�ؓ(f��)部分固定的捆�l�在一��P��扩展性不强。假如要动态增加一个用�_�笔�ȝ��行�ؓ(f��)和一个画方�Ş的抽象部分，
��必然要新定义一个ChalkDraw�c�，DrawGraph�c�里增加drawRectangle接口。显然这是很�ȝ��的�?/p>
Bridge模式是这样实现的�Q?br />//抽象部分
public abstract class DrawGraph {

private ToolDraw toolDraw;
public void setToolDraw(){
  this.toolDraw = ToolDrawSingleton.getToolDraw();//用Singleton模式来选工兗��?/strong>
}

public ToolDraw getToolDraw(){
  return toolDraw;
}

public abstract void draw();
}

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

//�ȝ��?br />public class DrawRectangle implements DrawGraph{
public DrawRectangle(){
  setToolDraw();
}
public void draw(){
  System.out.pritnln(toolDraw.getName() + " draw rectangle");
}
}

//行�ؓ(f��)部分
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�c�L��联系抽象和行为。通过此类来选工�?br />public class ToolDrawSingleton{
private static ToolDraw toolDraw;

public ToolDrawSingleton(ToolDraw toolDraw){
  this.toolDraw = toolDraw
}
public static ToolDraw getToolDraw(){
  return toolDraw;
}
}

假如我们现在要用�_�笔来画一个方�?一个圆形：(x��)
//取得工具
ToolDrawSingleton tool = new ToolDrawSingleton(new ChalkDraw());
//��L��?br />DrawGraph drawRectangle = new DrawRectangle();
drawRectangle.draw();
//��d��?br />drawRectangle = new DrawCircle();
drawRectangle.draw();

例子二：(x��)
例如,一杯咖啡�ؓ(f��)�?子类实现�c�Mؓ(f��)四个�Q�中杯加奶、大杯加奶�?中杯不加奶、大杯不加奶�?/p>
但是�Q�我们注意到�Q�上面四个子�c�M��有概念重叠，可从另外一个角度进行考虑�Q�这四个�c�d��际是两个角色的组合：(x��)抽象和行为，其中抽象为：(x��)中杯和大杯；行�ؓ(f��)为：(x��)加奶不加�Ӟ��如加��汁加苹果汁�Q?

实现四个子类在抽象和行�ؓ(f��)之间发生了固定的�l�定关系�Q�如果以后动态增加加葡萄汁的行�ؓ(f��)�Q�就必须再增加两个类�Q�中杯加葡萄汁和大杯加葡萄汁。显然�؜�?扩展性极差�?/p>
那我们从分离抽象和行为的角度�Q��用Bridge模式来实现�?/p>
如何实现?
以上面提到的咖啡 ��Z��. 我们原来打算只设计一个接�?抽象�c?,使用Bridge模式�?我们需要将抽象和行为分开,加奶和不加奶属于行�ؓ(f��),我们��它们抽象成一个专门的行�ؓ(f��)接口.

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

public abstract class Coffee
{
　　CoffeeImp coffeeImp;

　　public void setCoffeeImp() {
　　　　this.CoffeeImp = CoffeeImpSingleton.getTheCoffeImp();
　　}

　　public CoffeeImp getCoffeeImp() {return this.CoffeeImp;}

　　public abstract void pourCoffee();
}

其中CoffeeImp 是加不加奶的行�ؓ(f��)接口,看其代码如下:

public abstract class CoffeeImp
{
　　public abstract void pourCoffeeImp();
}

现在我们有了两个抽象�c?下面我们分别对其�q�行�l�承,实现concrete class:

//中杯
public class MediumCoffee extends Coffee
{
　　public MediumCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯�q�是大杯 ,重复2�ơ是中杯
　　　　for (int i = 0; i < 2; i++)
　　　　{

　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}

//大杯
public class SuperSizeCoffee extends Coffee
{
　　public SuperSizeCoffee() {setCoffeeImp();}

　　public void pourCoffee()
　　{
　　　　CoffeeImp coffeeImp = this.getCoffeeImp();
　　　　//我们以重复次数来说明是冲中杯�q�是大杯 ,重复5�ơ是大杯
　　　　for (int i = 0; i < 5; i++)
　　　　{

　　　　　　coffeeImp.pourCoffeeImp();
　　　　}
　　
　　}
}

上面分别是中杯和大杯的具体实�?下面再对行�ؓ(f��)CoffeeImp�q�行�l�承:

//加奶
public class MilkCoffeeImp extends CoffeeImp
{
　　MilkCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　System.out.println("加了��味的牛�?);
　　}
}

//不加�?br />public class FragrantCoffeeImp extends CoffeeImp
{
　　FragrantCoffeeImp() {}

　　public void pourCoffeeImp()
　　{
　　　　System.out.println("什么也没加,清香");
　　}
}

Bridge模式的基本框架我们已�l�搭好了,别忘记定义中�q�有一�?动态结�?我们现在可以喝到臛_��四种咖啡:
1.中杯加奶
2.中杯不加�?br />3.大杯加奶
4.大杯不加�?/p>
看看是如何动态结合的,在��用之�?我们做个准备工作,设计一个单态类(Singleton)用来hold当前的CoffeeImp:

public class CoffeeImpSingleton
{
　　private static CoffeeImp coffeeImp;

　　public CoffeeImpSingleton(CoffeeImp coffeeImpIn)
　　 {this.coffeeImp = coffeeImpIn;}

　　public static CoffeeImp getTheCoffeeImp()
　　{
　　　　return coffeeImp;
　　}
}

看看中杯加奶和大杯加�?是怎么出来�?

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

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

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

注意: Bridge模式的执行类如CoffeeImp和Coffee是一对一的关�p? 正确创徏CoffeeImp是该模式的关键�?br />

保尔�?/a> 2006-07-10 17:13 发表评论

亚洲国产精品无码久久一区二区,久久精品国产精品亚洲艾,亚洲av片在线观看

Composite�Q�组合）模式

Proxy�Q�代理）模式

Prototype�Q�原型）模式

Template Method�Q�模板方法）模式

Observer�Q�观察者）模式

Decorator�Q�装饎ͼ�模式

Strategy�Q�策略）模式

���单工厂，Factory Method�Q�工厂方法）和Abstract Factory�Q�抽象工厂）模式

Singleton�Q�单态）模式 �?Double-Checked Locking�Q�双重检查锁定）模式

设计模式的原则和�{�略

Adapter�Q�适配器）模式

Facade�Q�外观）模式

Bridge�Q�桥接）模式

��单工厂，Factory Method�Q�工厂方法）和Abstract Factory�Q�抽象工厂）模式