亚洲精品综合久久中文字幕,亚洲国产精品乱码一区二区,亚洲黄色在线网站

Eric_jiang — Sun, 31 Oct 2010 09:24:00 GMT

具体元素的接口与实现�c?br />
public interface Person {
    void accept(Visitor visitor);
}

public class Woman implements Person{

public void accept(Visitor visitor) {
        visitor.visit(this);
}
}

public class Man implements Person{

public void accept(Visitor visitor) {
visitor.visit(this);
}
}

讉K��者接口与实现�c�，分别代表男�h与女人在不同的状态下的表�?br />
public interface Visitor {
    public void visit(Man man);
    public void visit(Woman girl);
}

//成功时Man与Woman的不同表�?br /> public class Success implements Visitor{

public void visit(Man man) {
System.out.println("当男人成功时�Q�背后多半有一个伟大的女�h");
}

public void visit(Woman woman) {
System.out.println("当女人成功时�Q�背后大多有一个不成功的男�?);
}
}

//恋爱时Man与Woman的不同表�?br /> public class Love implements Visitor{

public void visit(Man man) {
System.out.println("当男人恋爱时�Q�凡事不懂也装懂");
}

public void visit(Woman girl) {
System.out.println("当女人恋爱时�Q�遇事懂也装不懂");
}
}

ObjectStructure与客��L(f��ng)��试代码

import java.util.*;

public class ObjectStructure {
private List elements = new ArrayList();

public void attach(Person element){
elements.add(element);
}

public void detach(Person element){
elements.remove(elements);
}

//遍历各种具体元素�q�执行他们的accept�Ҏ(gu��)��
public void display(Visitor visitor){
for(Person p:elements){
p.accept(visitor);
}
}
}

public class Client {
    public static void main(String[] args) {
ObjectStructure o = new ObjectStructure(); //依赖于ObjectStructure
//实例化具体元�?br /> o.attach(new Man());
o.attach(new Woman());

//当成功时不同元素的不同反�?br /> Visitor success = new Success();         //依赖于抽象的Visitor接口
o.display(success);

//当恋爱时的不同反�?br /> Visitor amativeness = new Love();        //依赖于抽象的Visitor接口
o.display(amativeness);

}
}

需求的变化

假设现在需求要扩展数据�l�构�Q�增加一�U�具体元素，男与女之外的一�U�不明物体，我们暂时把它�U�Cؓ(f��)“怪兽”�Q�在既有讉K��者模式的架构下，应该怎样�Q�首先增加一个Bruce�c�，实现Person接口。最�ȝ��的是要修改访问者接口及(qi��ng)其所有具体访问�?

因�ؓ(f��)Visit�Ҏ(gu��)��中没有包含访问Bruce对象的行为，因此我们被迫要去手工更改Visitor(包括抽象的，具体�?�Q�在其中��d��有关Bruce对象的行为，�q�严重违反了“开�?��闭”原则。究其原因在于目前的�l�构下，被访问对象与讉K��对象互相依赖�Q�自然不利于分离变化�Q�必��d��掉一层依赖关�p�R�?br />
我们��试把Visitor对Person(元素)的依赖关�p�d��掉，抽象出对应每个具体元素的ElementVisitor接口 -->ManVisitor,WomanVisitor�Q�然后把Visitor对Person的依赖关�p��{�U�d��ManVisitor�?WomanVisitor�w�上�?br />
现在Visitor接口已经没有��M��抽象�Ҏ(gu��)��Q�只是一个空接口�Q�每一个具体元素对应有一个ElementVisitor接口�Q�每一个元素对应的ElementVisitor接口有访问该元素的visit(),相当把原来在Visitor接口中声明工作，交由各个具体ElementVisitor接口完成�?br />

�l�过攚w��后的代码：(x��)
原Visitor接口

public interface Visitor {
    //退化到没有��M��抽象�Ҏ(gu��)��
}

新增加ManVisitor,WomanVisitor接口

public interface ManVisitor {
    public void visit(Man man);
}

public interface WomanVisitor {
    public void visit(Woman w);
}

具体Visitor实现�cȝ��在同时实�?个接�?br />
//由实现Visitor接口扩展成实现Visitor,WomanVisitor,ManVisitor三个接口
public class Success implements Visitor,WomanVisitor,ManVisitor{

public void visit(Man man) {
System.out.println("当男人成功时�Q�背后多半有一个伟大的女�h");
}

public void visit(Woman girl) {
System.out.println("当女人成功时�Q�背后大多有一个不成功的男�?);
}
}

//由实现Visitor接口扩展成实现Visitor,WomanVisitor,ManVisitor三个接口
public class Love implements Visitor,WomanVisitor,ManVisitor{

public void visit(Man man) {
System.out.println("当男人恋爱时�Q�凡事不懂也装懂");
}

public void visit(Woman girl) {
System.out.println("当女人恋爱时�Q�遇事懂也装不懂");
}
}

Person接口没有变化,依旧只依赖于Visitor接口

public interface Person {
    void accept(Visitor visitor);
}

攚w��后的具体元素类Man与Woman

public class Man implements Person {

// 先对visitor�q�行�c�d��转换�Q�再执行visit�Ҏ(gu��)��Q�因为Visitor接口已经没有声明��M��抽象�Ҏ(gu��)��?br /> public void accept(Visitor visitor) {
if (visitor instanceof ManVisitor) {
ManVisitor mv = (ManVisitor) visitor;
mv.visit(this);
}
}
}

public class Woman implements Person {

// 先对visitor�q�行�c�d��转换�Q�再执行visit�Ҏ(gu��)��Q�因为Visitor接口已经没有声明��M��抽象�Ҏ(gu��)��?br /> public void accept(Visitor visitor) {
if (visitor instanceof WomanVisitor) {
WomanVisitor wv = (WomanVisitor) visitor;
wv.visit(this);
}
}
}

ObjectStructure与客��L(f��ng)��试代码没有变化

import java.util.*;

public class ObjectStructure {
private List elements = new ArrayList();

public void attach(Person element){
elements.add(element);
}

public void detach(Person element){
elements.remove(elements);
}

//遍历各种具体元素�q�执行他们的accept�Ҏ(gu��)��
public void display(Visitor visitor){
for(Person p:elements){
p.accept(visitor);
}
}
}

public class Client {
    public static void main(String[] args) {
ObjectStructure o = new ObjectStructure(); //依赖于ObjectStructure
//实例化具体元�?br /> o.attach(new Man());
o.attach(new Woman());

//当成功时不同元素的不同反�?br /> Visitor success = new Success();         //依赖于抽象的Visitor接口
o.display(success);

//当恋爱时的不同反�?br /> Visitor amativeness = new Love();        //依赖于抽象的Visitor接口
o.display(amativeness);
}
}

��x��攚w��完毕！我们执行客户端测试代码，�l�果昄��Q?br /> 当男人成功时�Q�背后多半有一个伟大的女�h
当女人成功时�Q�背后大多有一个不成功的男�?br /> 当男人恋爱时�Q�凡事不懂也装懂
当女人恋爱时�Q�遇事懂也装不懂

此时�Q�客��L(f��ng)��仍然只依赖于Visitor�I�接口与ObjectStructure�c�R��可能一开始大家会(x��)认�ؓ(f��)�I�接口没有什么用�Q�现在就能体现出他的威力了，使客��L(f��ng)��与具体Visitor的高度解耦！也正是这�U�思维的核心在JavaAPI中也有类似的应用�Q�这�U�空接口被称为标识接口。比如java.io.Serializable与java.rmi.Remote�{�，标识接口里没有�Q何方法和属性，标识不对实现接口不对实现它的�c�L��M��语义上的要求�Q�它仅仅是表明实现它的类属于一�U�特定的�c�d��?br /> 上面具体讉K��者实现的多个接口被称为�؜合类型。这个概��c(di��n)��Java与模式》中有提�?qi��ng)过�Q�当一个具体类处于一个类的等�U�结构之中的时候，��个具体类定义一个�؜合类型是可以保证��Z��q�个�c�d��的可插入性的关键�?br />
=================================无敌分界�U?===================================

讲了�q�么长，现在我们��试下改造后的访问者模�?br /> 首先增加一�U�行�?状�?�Q�即原访问者模式的优点

增加一个具体访问者Fail,修改一下客��L(f��ng)��试代码

public class Fail implements Visitor,ManVisitor,WomanVisitor{

public void visit(Man man) {
System.out.println("当男人失败时�Q�闷头喝酒，谁也不用�?);
}

public void visit(Woman woman) {
System.out.println("当女人失败时�Q�眼泪汪汪，谁也劝不�?);
}
}

public class Client {
    public static void main(String[] args) {
ObjectStructure o = new ObjectStructure(); //依赖于ObjectStructure
//实例化具体元�?br /> o.attach(new Man());
o.attach(new Woman());

//当成功时不同元素的不同反�?br /> Visitor success = new Success();         //依赖于抽象的Visitor接口
o.display(success);
System.out.println();

//当恋爱时的不同反�?br /> Visitor amativeness = new Love();        //依赖于抽象的Visitor接口
o.display(amativeness);
System.out.println();

//新增加失败时的不同反�?br /> Visitor fail = new Fail();
o.display(fail);
}
}

�l�果昄��Q?br /> 当男人成功时�Q�背后多半有一个伟大的女�h
当女人成功时�Q�背后大多有一个不成功的男�?br />
当男人恋爱时�Q�凡事不懂也装懂
当女人恋爱时�Q�遇事懂也装不懂

当男人失败时�Q�闷头喝酒，谁也不用�?br /> 当女人失败时�Q�眼泪汪汪，谁也劝不�?br />

增加新的行�ؓ(f��)(状�?与原来一��h��便！只需要增加一个具体访问者即可！
现在我们来增加一个具体元�?正是写这��文章的初衷)

首先增加一个具体元素Bruce

public class Bruce implements Person{

public void accept(Visitor visitor) {
if(visitor instanceof BruceVisitor){
BruceVisitor bv = (BruceVisitor) visitor;
bv.visit(this);
}
//�q�个else可写可不�?br /> else{
String s = visitor.getClass().getName();
String state = s.substring(s.lastIndexOf(".")+1,s.length());
System.out.println("�?.原来怪兽�?+state+"的时候是没有行�ؓ(f��)�?!");
}
}
}

//按照新的思维方式增加一个对应的ElementVisitor接口
public interface BruceVisitor {
    public void visit(Bruce bruce);
}

我们让Success�q�个具体讉K��者多实现一个BruceVisitor讉K��者接�?和修改一下客��L(f��ng)��代码�q�行��试

public class Success implements Visitor,WomanVisitor,ManVisitor,BruceVisitor{

public void visit(Man man) {
System.out.println("当男人成功时�Q�背后多半有一个伟大的女�h");
}

public void visit(Woman girl) {
System.out.println("当女人成功时�Q�背后大多有一个不成功的男�?);
}

public void visit(Bruce bruce) {
System.out.println("当怪兽成功�?........无语..........");
}
}

public class Client {
    public static void main(String[] args) {
ObjectStructure o = new ObjectStructure(); //依赖于ObjectStructure

o.attach(new Man());
o.attach(new Woman());
o.attach(new Bruce());    //新增一�U�具体元素Bruce

Visitor success = new Success();         //依赖于抽象的Visitor接口
o.display(success);
System.out.println();

Visitor amativeness = new Love();        //依赖于抽象的Visitor接口
o.display(amativeness);
System.out.println();

Visitor fail = new Fail();
o.display(fail);
}
}

昄��l�果�Q?br /> 当男人成功时�Q�背后多半有一个伟大的女�h
当女人成功时�Q�背后大多有一个不成功的男�?br /> 当怪兽成功�?........无语..........

当男人恋爱时�Q�凡事不懂也装懂
当女人恋爱时�Q�遇事懂也装不懂
�?.原来怪兽在Love的时候是没有行�ؓ(f��)�?!

当男人失败时�Q�闷头喝酒，谁也不用�?br /> 当女人失败时�Q�眼泪汪汪，谁也劝不�?br /> �?.原来怪兽在Fail的时候是没有行�ؓ(f��)�?!

�q�个�l�果你满意吗�Q?br /> 虽然�Q�这只是部分�W�合“开�?��闭”原则�Q�我们不需要修改Visitor接口�Q�但�q�是得去修改Success实现新的接口。但是修改具体类比修�Ҏ(gu��)��口的代�h(hu��n)��得多，不需要重新编译所有访问接口和具体讉K��者。��我们面对新的变化也容易得多。而且�q�还有一个好处，��是可以让各�U�元素有选择地让别�h讉K��Q�如上述例子�Q�这样��讉K��者模式的�q�用��h��更加灉|��?

Eric_jiang 2010-10-31 17:24 发表评论

Eric_jiang — Fri, 29 Oct 2010 12:56:00 GMT

�c�适配�?
客户的开发�h员定义了一个接口，期望用这个接口来完成整数的求和操作，接口定义如下�Q?

public interface Operation{
      public int add(int a,int b);
}
开发�h员在了解�q�个接口的定义后�Q�发��C��个第三方�c�，里面有一个方法能实现他们期望的功能，其代码如下：(x��)

public class OtherOperation{
      public int otherAdd(int a,int b){
           return a + b;
      }
}
以上�W�三方类OtherOperation的方法public int otherAdd(int a,int b)所提供的功能，完全能符合客��L(f��ng)��期望�Q�所以只需要想办法把OtherOperation的otherAdd(int a,int b)和客��L(f��ng)��Operation接口联系��h��Q�让�q�个�W�三方类来�ؓ(f��)客户提供他们期望的服务就行了�Q�这样就避免了开发�h员再度去研究�c�M��OtherOperation的otherAdd(int a,int b)�Ҏ(gu��)��的实玎ͼ�利用已有的轮子，避免重复发明�Q�，�q�方法之一�Q�就是用适配器模式：(x��)

public class AdapterOperation extends OtherOperation implements Operation{
      public int add(int a,int b){
           return otherAdd(a,b);
      }
}
以上��是适配器的实现�Ҏ(gu��)��之一�Q�类适配器，在以上实��C��存在着三中角色分别是：(x��)
1�Q�适配目标角色�Q�Operation�?
2�Q�适配�c�（原）角色�Q�OtherOperation�?
3�Q�适配器角�Ԍ��(x��)AdapterOperation�?
其中适配器角色是适配器模式的核心�?
适配器的主要工作��是通过��装现有的功能，使他满��需要的接口�?
对象适配�?
我们再来看看另一�U�情况：(x��)
假如客户接口期望的功能不止一个，而是多个�Q?

public interface Operation{
      public int add(int a,int b);
      public int minus(int a,int b);
      public int multiplied(int a,int b);
}
而能提供�q�些实现的原可能不止一个：(x��)

public class OtherAdd{
      public int otherAdd(int a,int b){
           return a + b;
      }
}

public class OtherMinus{
      public int minus(int a,int b){
           return a - b;
      }
}

public class OtherMultiplied{
      public int multiplied(int a,int b){
           return a * b;
      }
}
�׃��java是不能实现多�l�承的，所以我们不能通过构徏一个适配器，让他来��承所有原以完成我们的期望�Q�这时候怎么办呢?只能用适配器的另一�U�实�?-对象适配器：(x��)

public class AdapterOperation implements Operation{
      private OtherAdd add;
      private OtherMinus minus;
      private OtherMultiplied multiplied;

      public void setAdd(OtherAdd add){
            this.add = add;
      }

      public void setMinus(OtherMinus minus){
            this.minus = minus;
      }

      public void setMultiplied(OtherMultiplied multiplied){
            this.multiplied = multiplied;
      }

      //适配加法�q�算
      public int add(int a,int b){
           return add.otherAdd(a,b);
      }

      //适配减法�q�算
      public int minus(int a,int b){
          return minus.minus(a,b);
      }

      //适配乘法�q�算
      public int multiplied(int a,int b){
         return multiplied.multiplied(a,b);
      }
}

上面代码很明显，适配器�ƈ不是通过�l�承来获取适配�c�（原）的功能的�Q�而是通过适配�cȝ��对象来获取的�Q�这��p��决了java不能多��承所带来的不便了。这也是java提倡的�~�程思想之一�Q�即��量使用聚合不要使用�l�承�?�q�有一�U�情冉|��需要��用对象适配器的。我们来看看�Q�单我们的客��h��供的需求�ƈ不是一个明��的接口�Q�而是一个类�Q��ƈ没有定义期望的方法，如下

public class A{
   public int add(int a,int b){
      return a + b;
   }
}

现在客户要一个新�c�B�Q�要求能在保留类A功能的情况下增加一个运��减法的功能�Q��ƈ要求B能随时替换掉A但不能对已有�pȝ��造成影响。这��h��们只能新��Z��个类B�Q��ƈ让B�l�承A�?

public class B extends A{
    b(){
      super();
    }

    public int minus(int a,int b){
           //待实现的减法�q�算函数..
    }
}

�q�时候，我们发现�c�C已经提供了实现减法的函数�Q?

public class C{
    public int minus(int a,int b){
           return a - b;
    }
}

��Z��避免重复去设计该函数�Q�我们决定引入C�c�，通过适配C�c�L��辑ֈ�我们的期望，但问题是A和C都是一个具体类�Q�我们无法让B同时�l�承�q�个两个�c�，而B�l�承A又是必须的，所以我们只能考虑把C�l�内聚到B内部�Q�对象适配器又得派上用��Z��?

public class B extends A{
    private C c;
    B(){
      super();
    }
    public void setMinus(C c){
         this.c= c;
    }
    public int minus(int a,int b){
           return c.minus(a,b);
    }
}

�q�样�Q�在需要A�cȝ��地方都能用B�c�L��代替�Q�同时又保证了新的功能的引入�?
更灵�zȝ��实现--隐藏目标接口的抽象适配�?
做java 桌面应用的都知道WindowListener接口�Q?

public interface WindowListener extends EventListener{
public void windowActivated(WindowEvent e)�Q?br /> public void windowClosed(WindowEvent e)�Q?br /> public void windowClosing(WindowEvent e)�Q?br /> public void windowDeactivated(WindowEvent e)�Q?br /> public void windowDeiconified(WindowEvent e)�Q?br /> public void windowIconified(WindowEvent e)�Q?br /> public void windowOpened(WindowEvent e)�Q?br /> }

要实现这个接口，我们��必��d��现它所定义的所有方法，但是实际上，我们很少需要同时用到所有的�Ҏ(gu��)��Q�我们要的只是其中的两三个。�ؓ(f��)了不使我们实现多余的�Ҏ(gu��)��Q?
jdk WindowListener提供了一个WindowListener的默认实现类WindowAdapter�c�，�q�是一个抽象类�Q?

public abstract class WindowAdapter implements WindowListener{
public void windowActivated(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowClosing(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowOpened(WindowEvent e){}
}

WindowAdapter�c�d��WindowListener接口的所有有�Ҏ(gu��)��都提供了�I�实玎ͼ�
有了WindowAdapter�c�，我们只需要去�l�承WindowAdapter�Q�然后选择我们所兛_��的方法来实现��p��了，�q�样��避免了直接��d��现WindowListener接口�?

Eric_jiang 2010-10-29 20:56 发表评论

�{�略模式

Eric_jiang — Sat, 16 Oct 2010 13:21:00 GMT

设计模式解读之一�Q?�{�略模式
1. 模式定义

把会(x��)变化的内容取出�ƈ��装��h��Q�以便以后可以轻易地改动或扩充部分，而不影响不需要变化的其他部分�Q?br />
2. 问题�~��v
当涉�?qi��ng)至代码�l�护�Ӟ��Z��复用目的而��用��承，�l�局�q�不完美。对父类的修改，�?x��)媄响到子类型。在��类中增加的�Ҏ(gu��)��Q�会(x��)��D��子类型有该方法，甚至�q�那些不该具备该�Ҏ(gu��)��的子�c�d��也无法免除。示例，一个鸭子类型：(x��)

public abstract class Duck {
//所有的鸭子均会(x��)叫以�?qi��ng)游泻I��所以父�c�M��处理�q�部分代�?br /> public void quack() {
System.out.println("Quack");
}

public void swim() {
System.out.println("All ducks float, even decoys.");
}

//因�ؓ(f��)每种鸭子的外观是不同的，所以父�c�M��该方法是抽象的，由子�c�d��自己完成�?br /> public abstract void display();
}

public class MallardDuck extends Duck {
//野鸭外观昄��为绿�?br /> public void display() {
System.out.println("Green head.");
}
}

public class RedHeadDuck extends Duck {
//�U�头鸭显�C�Zؓ(f��)�U�头
public void display() {
System.out.println("Red head.");
}
}

public class RubberDuck extends Duck {

//��皮鸭叫��Cؓ(f��)吱吱叫，所以重写父�c�M��改写行�ؓ(f��)
public void quack() {
System.out.println("Squeak");
}

//��皮鸭显�C�Zؓ(f��)黄头
public void display() {
System.out.println("Yellow head.");
}
}

上述代码�Q�初始实现得非常好。现在我们如果给Duck.java中加入fly()�Ҏ(gu��)��的话�Q�那么在子类型中均有了该�Ҏ(gu��)��Q�于是我们看��C��?x��)飞的橡皮鸭子，你看�q�吗�Q�当�Ӟ��我们可以在子�c�M��通过�I�实现重写该�Ҏ(gu��)��以解册��Ҏ(gu��)��对于子类型的影响。但是父�c�M��再增加其它的�Ҏ(gu��)��呢？

通过�l�承在父�c�M��提供行�ؓ(f��)�Q�会(x��)��D��以下�~�点�Q?br />
a. 代码在多个子�c�M��重复;
b. �q�行时的行�ؓ(f��)不容易改变；
c. 改变�?x��)牵一发动全��n�Q�造成部分子类型不惌��的改变；

好啦�Q�还是刚才鸭子的例子�Q�你也许惛_��使用接口�Q�将飞的行�ؓ(f��)、叫的行为定义�ؓ(f��)接口�Q�然后让Duck的各�U�子�c�d��实现�q�些接口。这时侯代码�c�M��于：(x��)

public abstract class Duck {
//��变化的行�ؓ(f��) fly() 以及(qi��ng)quake()从Duck�c�M��分离出去定义形成接口�Q�有需求的子类中自行去实现

public void swim() {
System.out.println("All ducks float, even decoys.");
}

public abstract void display();
}

//变化�?fly() 行�ؓ(f��)定义形成的接�?br /> public interface FlyBehavior {
void fly();
}

//变化�?quack() 行�ؓ(f��)定义形成的接�?br /> public interface QuackBehavior {
void quack();
}

//野鸭子会(x��)飞以�?qi��ng)叫�Q�所以实现接�?nbsp; FlyBehavior, QuackBehavior
public class MallardDuck extends Duck implements FlyBehavior, QuackBehavior{
public void display() {
System.out.println("Green head.");
}

public void fly() {
System.out.println("Fly.");
}

public void quack() {
System.out.println("Quack.");
}
}

//�U�头鸭子�?x��)飞以�?qi��ng)叫，所以也实现接口 FlyBehavior, QuackBehavior
public class RedHeadDuck extends Duck implements FlyBehavior, QuackBehavior{
public void display() {
System.out.println("Red head.");
}

public void fly() {
System.out.println("Fly.");
}

public void quack() {
System.out.println("Quack.");
}
}

//��皮鸭不�?x��)飞�Q�但�?x��)吱吱叫�Q�所以只实现接口QuackBehavior
public class RubberDuck extends Duck implements QuackBehavior{
//��皮鸭叫��Cؓ(f��)吱吱�?br /> public void quack() {
System.out.println("Squeak");
}

//��皮鸭显�C�Zؓ(f��)黄头
public void display() {
System.out.println("Yellow head.");
}
}

上述代码虽然解决了一部分问题�Q�让子类型可以有选择地提供一些行�?例如 fly() �Ҏ(gu��)��不�?x��)出现在��皮鸭�?.但我们也看到�Q�野鸭子MallardDuck.java和红头鸭子RedHeadDuck.java的一些相同行��Z��码不能得到重复��用。很大程度上�q�是从一个火坑蟩到另一个火坑�?br />
在一�D늨�序之后，让我们从�l�节中蟩出来�Q�关注一些共性问题。不��用什么语�a��Q�构��Z��么应用，在��Y件开发上�Q�一直伴随着的不变的真理是：(x��)需要一直在变化。不��当初��Y件设计得多好�Q�一�D�|��间之后，��L��需要成长与改变�Q�否则��Y件就�?x��)死亡�?br /> 我们知道�Q��承在某种�E�度上可以实��C��码重用，但是父类(例如鸭子�c�Duck)的行为在子类型中是不断变化的�Q�让所有子�c�d��都有�q�些行�ؓ(f��)是不恰当的。我们可以将�q�些行�ؓ(f��)定义为接口，让Duck的各�U�子�c�d��d��玎ͼ�但接口不��h��实现代码�Q�所以实现接口无法达��C��码复用。这意味着�Q�当我们需要修�Ҏ(gu��)��个行为，必须往下追�t��ƈ在每一个定义此行�ؓ(f��)的类中修改它�Q�一不小心，�?x��)造成新的错误�?br />
设计原则�Q�把应用中变化的地方独立出来�Q�不要和那些不需要变化的代码混在一赗��这样代码变化引��L(f��ng)��不经意后果变��，�pȝ��变得更有�Ҏ(gu��)��?br />
按照上述设计原则�Q�我们重新审视之前的Duck代码�?br />
1) 分开变化的内容和不变的内�?br />
Duck�c�M��的行�?fly(), quack(), 每个子类型可能有自己�Ҏ(gu��)��的表玎ͼ��q�就是所谓的变化的内宏V�?br /> Duck�c�M��的行�?swim() 每个子类型的表现均相同，�q�就是所谓不变的内容�?br />
我们��变化的内容从Duck()�c�M��剥离出来单独定义形成接口以及(qi��ng)一�p�d��的实现类型。将变化的内容定义�Ş成接口可实现变化内容和不变内容的剥离。其实现�c�d��可实现变化内容的重用。这些实现类�q��Duck.java的子�c�d��Q�而是专门的一�l�实现类�Q�称之�ؓ(f��)"行�ؓ(f��)�c?。由行�ؓ(f��)�c�而不是Duck.java的子�c�d��来实现接口。这��P��才能保证变化的行为独立于不变的内宏V��于是我们有�Q?br />
变化的内容：(x��)

//变化�?fly() 行�ؓ(f��)定义形成的接�?br /> public interface FlyBehavior {
void fly();
}

//变化�?fly() 行�ؓ(f��)的实现类之一
public class FlyWithWings implements FlyBehavior {
public void fly() {
System.out.println("I'm flying.");
}
}

//变化�?fly() 行�ؓ(f��)的实现类之二
public class FlyNoWay implements FlyBehavior {
public void fly() {
System.out.println("I can't fly.");
}
}

-----------------------------------------------------------------

//变化�?quack() 行�ؓ(f��)定义形成的接�?br /> public interface QuackBehavior {
void quack();
}

//变化�?quack() 行�ؓ(f��)实现�c�M��一
public class Quack implements QuackBehavior {
public void quack() {
System.out.println("Quack");
}
}

//变化�?quack() 行�ؓ(f��)实现�c�M��?br /> public class Squeak implements QuackBehavior {
public void quack() {
System.out.println("Squeak.");
}
}

//变化�?quack() 行�ؓ(f��)实现�c�M��?br /> public class MuteQuack implements QuackBehavior {
public void quack() {
System.out.println("<< Slience >>");
}
}

通过以上设计�Q�fly()行�ؓ(f��)以及(qi��ng)quack()行�ؓ(f��)已经和Duck.java没有什么关�p�，可以充分得到复用。而且我们很容易增加新的行�?既不影响现有的行为，也不影响Duck.java。但是，大家可能有个疑问�Q�就是在面向对象中行��Z��是体��Cؓ(f��)�Ҏ(gu��)��吗？��Z��么现在被定义形成�c?例如Squeak.java)�Q�在OO中，�c�M��表的"东西"一般是既有状�?实例变量�Q�又有方法。只是在本例中碰�?东西"是个行�ؓ(f��)。既使是行�ؓ(f��)�Q�也有属性及(qi��ng)�Ҏ(gu��)��Q�例如飞行行为，也需要一些属性记录飞行的状态，如飞行高度、速度�{��?br />
2) 整合变化的内容和不变的内�?br />
Duck.java��?fly()以及(qi��ng)quack()的行为委拖给行�ؓ(f��)�c�d��理�?br />
不变的内容：(x��)

public abstract class Duck {

//��行为类声明为接口类型，降低对行为实现类型的依赖
FlyBehavior flyBehavior;
QuackBehavior quackBehavior;

public void performFly() {
//不自行处理fly()行�ؓ(f��)�Q�而是委拖�l�引用flyBehavior所指向的行为对�?br /> flyBehavior.fly();
}

public void performQuack() {
quackBehavior.quack();
}

public void swim() {
System.out.println("All ducks float, even decoys.");
}

public abstract void display();
}

Duck.java不关心如何进�?fly()以及(qi��ng)quack(), �q�些�l�节交由具体的行为类完成�?br />
public class MallardDuck extends Duck{
public MallardDuck() {
flyBehavior=new FlyWithWings();
quackBehavior=new Quack();
}

public void display() {
System.out.println("Green head.");
}
}

��试�c�：(x��)

public class DuckTest {
public static void main(String[] args) {
Duck duck=new MallardDuck();
duck.performFly();
duck.performQuack();
}
}

在Duck.java子类型MallardDuck.java的构造方法中�Q�直接实例化行�ؓ(f��)�c�d��Q�在�~�译的时侯便指定具体行�ؓ(f��)�c�d��。当�Ӟ��我们可以�Q?br />
1) 我们可以通过工厂模式或其它模式进一步解�?可参考后�l�模式讲�?;
2) 或做到在�q�行时动态地改变行�ؓ(f��)�?br />
3) 动态设定行�?br />
在父�c�Duck.java中增加设定行为类型的setter�Ҏ(gu��)��Q�接受行为类型对象的参数传入。�ؓ(f��)了降藕，行�ؓ(f��)参数被声明�ؓ(f��)接口�c�d��。这��P��既便在运行时�Q�也可以通过调用�q�二个方法以改变行�ؓ(f��)�?br />
public abstract class Duck {
//在刚才Duck.java中加入以下二个方法�?br /> public void setFlyBehavior(FlyBehavior flyBehavior) {
this.flyBehavior=flyBehavior;
}

public void setQuackBehavior(QuackBehavior quackBehavior) {
this.quackBehavior=quackBehavior;
}

//其它�Ҏ(gu��)��同，省略...
}

��试�c�：(x��)

public class DuckTest {
public static void main(String[] args) {
Duck duck=new MallardDuck();
duck.performFly();
duck.performQuack();
duck.setFlyBehavior(new FlyNoWay());
duck.performFly();
}
}

如果�Q�我们要加上火箭助力的飞行行为，只需再新建FlyBehavior.java接口的实现类型。而子�c�d��可通过调用setQuackBehavior(...)�Ҏ(gu��)��动态改变。至此，在Duck.java增加新的行�ؓ(f��)�l�我们代码所带来的困�l�已不复存在�?br />
该是�ȝ��的时侯了�Q�让我们从代码的水中��出来，做一只在水面上自由游动的鸭子�?

3. 解决�Ҏ(gu��)��

MallardDuck �l�承 Duck抽象�c�；        -> 不变的内�?br /> FlyWithWings 实现 FlyBehavior接口�Q?nbsp; -> 变化的内�?行�ؓ(f��)或算�?br /> 在Duck.java提供setter�Ҏ(gu��)��以装配关�p�； -> 动态设定行�?br />
以上��是�{�略模式的实��C��步曲。接下来�Q�让我们透过步骤看本�?

1) 初始�Q�我们通过�l�承实现行�ؓ(f��)的重用，��D��了代码的�l�护问题�?nbsp;       -> �l�承, is a
2) 接着�Q�我们将行�ؓ(f��)剥离成单独的�c�d��q�声明�ؓ(f��)不变内容的实例变量�ƈ通过 -> �l�合, has a
setter�Ҏ(gu��)��以装配关�p�；

�l�承�Q�可以实现静态代码的复用�Q�组合，可以实现代码的弹性维护；使用�l�合代替�l�承�Q�可以��代码更好地适应软�g开发完后的需求变化�?br />
�{�略模式的本质：(x��)��用�l�承�Q�多用组�?br />

Eric_jiang 2010-10-16 21:21 发表评论

Eric_jiang — Thu, 09 Sep 2010 08:35:00 GMT

一�?模式定义:
在不破坏��装的前提下�Q�捕获一个对象的内部状态，�q�在该对象之外保存这个状态。这样就可以��该对象恢复到原先保存前的状态�?br /> 二�?模式解说
在程序运行过�E�中�Q�某些对象的状态处在�{换过�E�中�Q�可能由于某�U�原因需要保存此时对象的状态，以便�E�序�q�行到某个特定阶�D�，需要恢复到对象之前处于某个�Ҏ(gu��)��的状态。如果��用一些公有接口让其它对象来得到对象的状态，便会(x��)暴露对象的实现细节�?br />
三�?�l�构�?br />
1) 备忘录（Memento�Q�角�Ԍ��(x��)备忘录角色存�?#8220;备忘发�v角色”的内部状态�?#8220;备忘发�v角色”�Ҏ(gu��)��需要决定备忘录角色存储“备忘发�v角色”的哪些内部状态。�ؓ(f��)了防�?#8220;备忘发�v角色”以外的其他对象访问备忘录。备忘录实际上有两个接口�Q?#8220;备忘录管理者角�?#8221;只能看到备忘录提供的�H�接口——对于备忘录角色中存攄��属性是不可见的�?#8220;备忘发�v角色”则能够看��C��个宽接口——能够得到自己放入备忘录角色中属性�?
2) 备忘发�v�Q�Originator�Q�角�Ԍ��(x��)“备忘发�v角色”创徏一个备忘录�Q�用以记录当前时��d��的内部状态。在需要时使用备忘录恢复内部状态�?
3) 备忘录管理者（Caretaker�Q�角�Ԍ��(x��)负责保存好备忘录。不能对备忘录的内容�q�行操作或检查�?/font>

class WindowsSystem{

private String state;

public Memento createMemento(){ //创徏�pȝ��备䆾
      return new Memento(state);
}

public void restoreMemento(Memento m){ //恢复�pȝ��
      this.state=m.getState();
}

public String getState() {
  return state;
}

public void setState(String state) {
  this.state = state;
  System.out.println("当前�pȝ��处于"+this.state);
}

}

class Memento{
private String state;

public Memento(String state) {
this.state = state;
}

public String getState() {
return state;
}

public void setState(String state) {
this.state = state;
}
}

class User{

private Memento memento;

public Memento retrieveMemento() { //恢复�pȝ��
return this.memento;
}

public void saveMemento(Memento memento){ //保存�pȝ��
this.memento = memento;
}

}

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

}

在本例中�Q�W(xu��)indowsSystem是发起�h角色(Orignation),Memento是备忘录角色(Memento),User是备忘录��理角色(Caretaker)。Memento提供了两个接口（注意�q�里的接�?�q�不是java中的接口�Q�它指的是可被外界调用的�Ҏ(gu��)��Q�：(x��)一个是为WindowsSystem �cȝ��宽接口，能够得到WindowsSystem攑օ�Memento的state属性，代码见WindowsSystem的createMemento�Ҏ(gu��)��和restoreMemento�Ҏ(gu��)��Q�createMemento�Ҏ(gu��)��向Memento攑օ�state属性，restoreMemento�Ҏ(gu��)��获得攑օ�的state属性。另一个是为User�c�L��供的�H�接口，只能��理Memento而不能对它的内容�q�行��M��操作�Q�见User�c�）�?br /> 五�?优缺�?br /> 1�Q?保持��装边界使用备忘录可以避免暴露一些只应由原发器管理却又必��d��储在原发器之外的信息。该模式把可能很复杂的Originator内部信息对其他对象屏蔽�v来，从而保持了��装边界�?
2�Q?它简化了原发�?在其他的保持��装性的设计中，Originator负责保持客户��h��q�的内部状态版本。这��把所有存储管理的重�Q交给了Originator。让客户��理它们��h��的状态将�?x��)简化Originator�Q��ƈ且��得客户工作结束时无需通知原发器�?
3�Q?使用备忘录可能代价很�?如果原发器在生成备忘录时必须拯��q�存储大量的信息�Q�或者客户非帔R��J�地创徏备忘录和恢复原发器状态，可能�?x��)导致非常大的开销。除非封装和恢复Originator状态的开销不大�Q�否则该模式可能�q�不合适�?
4�Q?�l�护备忘录的潜在代�h(hu��n) ��理器负责删除它所�l�护的备忘录。然而，��理器不知道备忘录中有多��个状态。因此当存储备忘录时�Q�一个本来很��的��理器，可能�?x��)��生大量的存储开销�?br /> 六�?适用�?br /> 1�Q�必��M��存一个对象在某一个时�ȝ��Q�部分）状态，�q�样以后需要时它才能恢复到先前的状态�?br /> 2�Q�如果一个用接口来让其它对象直接得到�q�些状态，��会(x��)暴露对象的实现细节�ƈ破坏对象的封装性�?/font>

Eric_jiang 2010-09-09 16:35 发表评论

Eric_jiang — Thu, 09 Sep 2010 07:56:00 GMT

中介者模式（Mediator�Q�：(x��)用一个中介对象来��装一�p�d��的对象交互。中介者��各对象不需要显式地�怺�引用�Q�从而��其耦合松散�Q�而且可以独立地改变它们之间的交互�?br />
通用�c�d��Q?br />
        举例�Q�在一个公叔R��面，有很多部门、员工（我们�l�称他们互相为Colleague“同事”�Q�，��Z��完成一定的��d��Q?#8220;同事”之间肯定有许多需要互盔R��合、交��的�q�程。如果由各个“同事”频繁地到处去与自己有关的“同事”沟通，�q�样肯定�?x��)�Ş成一个多对多的杂��q��联系�|�络而造成工作效率低下�?br />
        此时��需要一位专门的“中介�?#8221;�l�各�?#8220;同事”分配��d��Q�以�?qi��ng)统一跟进大家的进度�ƈ�?#8220;同事”之间实时地进行交互，保证“同事”之间必须的沟通交��。很明显我们知道此时�?#8220;中介�?#8221;担�Q了沟�?#8220;同事”彼此之间的重要角色了�Q?#8220;中介�?#8221;使得每个“同事”都变成一对一的联�p�L��式，减轻了每�?#8220;同事”的负担，增强工作效率�?br />
        大概理清上面��单例子中的意图之后，�l�出中介者模式适用场景�Q?br /> 1、一�l�对象以定义良好但是复杂的方式进行通信。��生的�怺�依赖关系�l�构混�ؕ且难以理解�?br /> 2、一个对象引用其他很多对象�ƈ且直接与�q�些对象通信,��D��难以复用该对象�?br /> 3、想定制一个分布在多个�c�M��的行为，而又不想生成太多的子�c�R�?br />
        其实�Q�中介者模式又被称�?#8220;调停�?#8221;模式�Q�我们可以理解�ؓ(f��)一��小孩子�Q�同事）吉|��了，�q�时��很需要一位大人（调停者）�q�来处理好小孩子们的关系�Q�以免发生不必要的冲�H��?#8220;中介�?#8221;�?#8220;调停�?#8221;只不�q�是同一个英语单�?#8220;Mediator”的不同翻译�Ş了。反正最最重要的是�Q�中介者就是一个处于众多对象，�q�恰当地处理众多对象之间�怺�之间的联�pȝ��角色�?br />
        下面�l�出具体的代码例子，�Ҏ(gu��)��通用�c�d��增加了AbstractColleague抽象同事�c�d��AbstractMediator抽象中介者，另外��是两个具体同事�c�d��一个具体中介者，代码中有较多注释�Q�相应类图也不给��Z��Q�应该不隄��解的�Q?/font>

同事�c�L��Q?br /> //抽象同事�c?nbsp;
abstract class AbstractColleague {
  protected AbstractMediator mediator;
  /**既然有中介者，那么每个具体同事必然要与中介者有联系�Q?br />   * 否则��没必要存在�?�q�个�pȝ��当中�Q�这里的构造函数相�?
  * 于向该系�l�中注册一个中介者，以取得联�p?nbsp;
  */
  public AbstractColleague(AbstractMediator mediator) {
   this.mediator = mediator;
  }
  // 在抽象同事类中添加用于与中介者取得联�p�（��x��册）的方�?br />   public void setMediator(AbstractMediator mediator) {
   this.mediator = mediator;
  }

}

//具体同事A
class ColleagueA extends AbstractColleague {

   //每个具体同事都通过父类构造函��C��中介者取得联�p?
   public ColleagueA(AbstractMediator mediator) {super(mediator);}

   //每个具体同事必然有自己分内的事，没必要与外界相关�?
   public void self(){
  System.out.println("同事A --> 做好自己分内的事�?...");
   }

   //每个具体同事��L��需要与外界交互的操作，通过中介者来处理�q�些逻辑�q�安排工�?br />    public void out() {
    System.out.println("同事A --> ��h��同事B做好分内工作 ...");
    super.mediator.execute("ColleagueB", "self");
   }

}

//具体同事B
class ColleagueB extends AbstractColleague {

   public ColleagueB(AbstractMediator mediator) {
  super(mediator);
   }

   public void self() {
  System.out.println("同事B --> 做好自己分内的事�?...");
   }

   public void out() {
  System.out.println("同事B --> ��h��同事A做好分内工作 ...");
  super.mediator.execute("ColleagueA", "self");
   }
}
//抽象中介�?nbsp;
abstract class AbstractMediator {
   //中介者肯定需要保持有若干同事的联�p�L��?nbsp;
   protected Hashtable colleagues = new Hashtable();
   //中介者可以动态地与某个同事徏立联�p?nbsp;
   public void addColleague(String name, AbstractColleague c) {
   this.colleagues.put(name, c);
   }
   //中介者也可以动态地撤销与某个同事的联系
   public void deleteColleague(String name) {
   this.colleagues.remove(name);
   }
   //中介者必��d��备在同事之间处理逻辑、分配�Q务、促�q�交��的操作
   public abstract void execute(String name, String method);
}
//具体中介�?
class Mediator extends AbstractMediator{
  //中介者最重要的功能，来回奔�L与各个同事之�?
  public void execute(String name, String method) {
   if("self".equals(method)){
    //各自做好分内�?
    if("ColleagueA".equals(name)) {
     ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
     colleague.self();
    }else {
     ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
     colleague.self();
    }

   }else { //与其他同事合�?nbsp;
     if("ColleagueA".equals(name)) {
      ColleagueA colleague = (ColleagueA)super.colleagues.get("ColleagueA");
      colleague.out();
     }else {
      ColleagueB colleague = (ColleagueB)super.colleagues.get("ColleagueB");
      colleague.out();
     }
   }
  }
}

//��试�c?
public class Client {
public static void main(String[] args) {

//创徏一个中介�?nbsp;
AbstractMediator mediator = new Mediator();

  //创徏两个同事
  ColleagueA colleagueA = new ColleagueA(mediator);
  ColleagueB colleagueB = new ColleagueB(mediator);

  //中介者分别与每个同事建立联系
  mediator.addColleague("ColleagueA", colleagueA);
  mediator.addColleague("ColleagueB", colleagueB);

  //同事们开始工�?nbsp;
  colleagueA.self();
  colleagueA.out();
  System.out.println("======================合作愉快�Q��Q务完成！\n");

  colleagueB.self();
  colleagueB.out();
  System.out.println("======================合作愉快�Q��Q务完成！");
  }
}
��试�l�果�Q?
同事A --> 做好自己分内的事�?...
同事A --> ��h��同事B做好分内工作 ...
同事B --> 做好自己分内的事�?...
======================合作愉快�Q��Q务完成！
同事B --> 做好自己分内的事�?...
同事B --> ��h��同事A做好分内工作 ...
同事A --> 做好自己分内的事�?...
======================合作愉快�Q��Q务完成！

虽然以上代码中只有两个具体同事类�Q��ƈ且测试类中也只是创徏了两个同事，但是�q�些我们都可以根据中介者模式的宗旨�q�行适当地扩展，卛_��加具体同事类�Q�然后中介者就得担负更加重的�Q务了。�ؓ(f��)啥？我们看到上面具体中介者类Mediator中的execute()�Ҏ(gu��)��中现在就有一堆冗长的判断代码了。虽然可以把它分解�ƈ增加到Mediator�c�M��的其它private�Ҏ(gu��)��中，但是具体的业务逻辑是少不了的�?br />
所以，在解耦同事类之间的联�pȝ��同时�Q�中介者自�w�也不免��d��q�重�Q�因为几乎所有的业务逻辑都交代到中介者��n上了�Q�可谓是“万众期待”的一个角色了。这��是中介者模式的不��之处�?�?
此外�Q�上面这个代码例子是相当理想的了�Q�有时候我们根本抽取不�?#8220;同事”之间的共性来形成一个AbstractColleague抽象同事�c�，�q�也大大增加了中介者模式的使用隑ֺ��?nbsp;

�׃��上面代码实现中存�?双向兌��暴露在App�?的不��之�?修改上面代码�Q�如下：(x��)

修改后的同事�c�L��Q?/font>

//抽象同事�c?
abstract class AbstractColleague {

  protected AbstractMediator mediator;

  //舍去在构造函��C��建立起与中介者的联系
  //public AbstractColleague(AbstractMediator mediator) {
  //      this.mediator = mediator;
  //}

  // 在抽象同事类中添加用于与中介者取得联�p�（��x��册）的方�?nbsp;
  public void setMediator(AbstractMediator mediator) {
   this.mediator = mediator;
  }
}

//具体同事A

class ColleagueA extends AbstractColleague {

   //舍去在构造函��C��建立起与中介者的联系
   // public ColleagueA(AbstractMediator mediator) {
   // super(mediator);
   // }

   //每个具体同事必然有自己分内的事，没必要与外界相关�?nbsp;
   public void self() {
   System.out.println("同事A --> 做好自己分内的事�?...");
   }

   //每个具体同事��L��需要与外界交互的操作，通过中介者来处理�q�些逻辑�q�安排工�?nbsp;
   public void out() {
   System.out.println("同事A --> ��h��同事B做好分内工作 ...");
   super.mediator.execute("ColleagueB", "self");
   }

}

//具体同事B

class ColleagueB extends AbstractColleague {

  //舍去在构造函��C��建立起与中介者的联系
  // public ColleagueB(AbstractMediator mediator) {
  //      super(mediator);
  // }

  public void self() {
   System.out.println("同事B --> 做好自己分内的事�?...");
  }

  public void out() {
   System.out.println("同事B --> ��h��同事A做好分内工作 ...");
   super.mediator.execute("ColleagueA", "self");
  }
}

修改后的中介者：(x��)

  //抽象中介�?
  abstract class AbstractMediator {
  //中介者肯定需要保持有若干同事的联�p�L��?nbsp;

  protected Hashtable colleagues = new Hashtable();

  //中介者可以动态地与某个同事徏立联�p?nbsp;
  public void addColleague(String name, AbstractColleague c) {
   // 在中介者这里帮助具体同事徏立�v于中介者的联系
   c.setMediator(this);
   this.colleagues.put(name, c);
  }

  //中介者也可以动态地撤销与某个同事的联系
  public void deleteColleague(String name) {
   this.colleagues.remove(name);
  }

  //中介者必��d��备在同事之间处理逻辑、分配�Q务、促�q�交��的操作
  public abstract void execute(String name, String method);
  }

  //��试�c?
  public class Client {

   public static void main(String[] args) {

    //创徏一个中介�?nbsp;
    AbstractMediator mediator = new Mediator();

    //不用构造函��Cؓ(f��)具体同事注册中介者来取得联系�?
    // ColleagueA colleagueA = new ColleagueA(mediator);
    // ColleagueB colleagueB = new ColleagueB(mediator);

    ColleagueA colleagueA = new ColleagueA();
    ColleagueB colleagueB = new ColleagueB();

    //中介者分别与每个同事建立联系
    mediator.addColleague("ColleagueA", colleagueA);
    mediator.addColleague("ColleagueB", colleagueB);

    //同事们开始工�?nbsp;
    colleagueA.self();
    colleagueA.out();
    System.out.println("======================合作愉快�Q��Q务完成！\n");

    colleagueB.self();
    colleagueB.out();
    System.out.println("======================合作愉快�Q��Q务完成！");

   }
  }   ��试之后的结果与修改前一栗��?br />

Eric_jiang 2010-09-09 15:56 发表评论

Eric_jiang — Thu, 09 Sep 2010 07:40:00 GMT

Interpreter模式也叫解释器模式，是由GoF提出�?3�U�设计模式中的一�U�。Interpreter是行为模式之一�Q�它是一�U�特�D�的设计模式�Q�它建立一个解释器�Q�对于特定的计算机程序设计语�a��Q�用来解释预先定义的文法�?br /> 本文介绍设计模式中的解释器（Interpreter�Q�模式的概念�Q�用法，以及(qi��ng)实际应用中怎么样��用Interpreter模式�q�行开发�?/font>

Interpreter模式的概�?/font>

Interpreter是一�U�特�D�的设计模式�Q�它建立一个解释器�Q�对于特定的计算机程序设计语�a��Q�用来解释预先定义的文法。简单地��_(d��)��Interpreter模式是一�U�简单的语法解释器构架�?/font>

Interpreter模式有很多种实现�Ҏ(gu��)��Q�下面我们给出Interpreter模式的一�U�类图来说明Interpreter模式�Q?/font>

在上图中�Q�我们假��N��要在Client中解释某文法�Q�Client调用Context来存储文法规则，�q�调用解释器AbstractionExpression�c�L��(w��i)来对该文法加以解释。注意，上图只是Interpreter模式的一�U�实现方式的�c�d��?/font>

Context
    解释器上下文环境�c�R��用来存储解释器的上下文环境�Q�比如需要解释的文法�{��?br /> AbstractExpression
    解释器抽象类�?br /> ConcreteExpression
    解释器具体实现类�?/p>

Interpreter模式的实现范�?br /> ��Z��帮助大家理解Interpreter模式的基本概念，我们在这里只举一个最��单的例子�?br /> 让一个表辑ּ�a�l�过PlusExpression解释器处理后使该表达�?1�Q�经�q�MinusExpression解释器处理后使该表达�?1�?/p>

代码�Q?/p>

import java.util.ArrayList;
import java.util.List;

public class Client {
    public static void main(String []args) {
        String inputExpr = "10";

        Context context = new Context(inputExpr);

        List list = new ArrayList();

        list.add(new PlusExpression());
        list.add(new PlusExpression());
        list.add(new MinusExpression());
        list.add(new MinusExpression());
        list.add(new MinusExpression());

        for (int i=0;i           AbstractExpression expression = (AbstractExpression)list.get(i);
          expression.interpret(context);
        }

        System.out.println(context.getOutput());
    }
}

/**
* Context
*
*/
class Context {
private String input;
private int output;

    public Context (String input) {
        this. input = input;
    }

    public String getInput() {
        return input;
    }

    public void setInput(String input) {
        this.input = input;
    }

    public int getOutput() {
        return output;
    }

    public void setOutput(int output) {
        this.output = output;
    }
}

/**
* Expression & subclass
*
*/
abstract class AbstractExpression {
public abstract void interpret(Context context);
}

class PlusExpression extends AbstractExpression {
    public void interpret(Context context) {
        System.out.println("PlusExpression ++");
        String input = context.getInput();
        int parsedResult = Integer.parseInt(input);
        parsedResult ++;
        context.setInput(String.valueOf(parsedResult));
        context.setOutput(parsedResult);
    }
}

class MinusExpression extends AbstractExpression {
    public void interpret(Context context) {
        System.out.println("PlusExpression --");
        String input = context.getInput();
        int parsedResult = Integer.parseInt(input);
        parsedResult --;
        context.setInput(String.valueOf(parsedResult));
        context.setOutput(parsedResult);
    }
}

�q�行�q�显�C�Client�Q?/p>

C:\Interpreter>javac *.java
C:\Interpreter>java Client
PlusExpression ++
PlusExpression ++
PlusExpression --
PlusExpression --
PlusExpression --
9
C:\Interpreter>

Eric_jiang 2010-09-09 15:40 发表评论

命��o(h��)模式

Eric_jiang — Thu, 09 Sep 2010 07:29:00 GMT

1.�q�一节我们的��d��是创��Z��个类似智能家居的万能遥控器，控制各种家电(sh��)。我们需要将“��h��”��装成对象（一个命令对象通过在特定接收者上�l�定一�l�动作来��装��h��Q�，以便使用不同的请求、队列、或者日志来参数化其对象——这��是命��o(h��)模式�?/font>

2.我们具体来看一个例子：(x��)

首先我们要完成对命��o(h��)的对象封装：(x��)

public interface Command {
public void execute();
}

只有一个方法，所有的具体命��o(h��)的对象都要实现这个接口，�q�就做到了封装，比如对于灯这个对象，

public class Light {

public Light() {
}

    public void on() {
        System.out.println("Light is on");
    }

    public void off() {
        System.out.println("Light is off");
    }
}

我们可以通过上述接口��装“开�?#8221;�q�个命��o(h��)�Q�这个就是所谓的命��o(h��)对象�Q�它把动作和接收者包�q�对象之中，只暴露一个execute�Ҏ(gu��)��Q?/font>

public class LightOnCommand implements Command {
    Light light;
    public LightOnCommand(Light light) {
        this.light = light;
    }
    public void execute() {
        light.on();
    }
}

而我们的遥控器对于上�q�封装要一无所知，�q�样才能做到解耦：(x��)

public class SimpleRemoteControl {
    Command slot;
    public SimpleRemoteControl() {}
    public void setCommand(Command command) {
        slot = command;
    }
    public void buttonWasPressed() {
        slot.execute();
    }
}

我们现在试着用一下这个遥控器�Q�我们首先创��Z��个遥控器�Q�然后创建开灯这个命令�ƈ�|�于其中�Q�最后按下按键，�q�样�Q�遥控器不知道是哪个对象�Q�实际上是灯�Q�进行了哪个动作�Q�实际上是开灯这个动作）��可以完成请求的发出。如此一来，遥控器和灯之间的耦合性就非常低了�Q?/font>

public class RemoteControlTest {
    public static void main(String[] args) {
        SimpleRemoteControl remote = new SimpleRemoteControl();
        Light light = new Light();
        LightOnCommand lightOn = new LightOnCommand(light);
        remote.setCommand(lightOn);
        remote.buttonWasPressed();
        }
}

很简单的�Q�我们想要在一个遥控机中实现控制多个家�늚�能力��可以用一个数�l�来�l�护�q�样的一�l�命令，可以看做提供了多个命令的插槽�Q?/font>

public class RemoteControl {
    Command[] onCommands;
    Command[] offCommands;
    public RemoteControl() {
        onCommands = new Command[7];
        offCommands = new Command[7];
        Command noCommand = new NoCommand();
        for (int i = 0; i < 7; i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
    }
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
    }
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
    }
    public String toString() {
    }
}

你可能会(x��)注意��C��个叫做noCommand的对象出现在初始化遥控器对象时。这个是个小技巧，我们�q�不��x��ơ都��查某个插槽是不是都绑定了命��o(h��)�Q�那么我们就引入了这个东东，实现一个不做事情的命��o(h��)�Q?/font>

public class NoCommand implements Command {
public void execute() { }
}

�q�样初始化就让每一个插槽都有命令了�Q�以后若不进一步指明命令的插槽�Q�那么就是默认这个noCommand对象。这��是一个典型的“�I�对�?#8221;例子�Q�当你不惌��回一个有意义的对象时�Q�空对象��十分有用，此时�I�对象可以做成判断NULL或者提�C?#8220;未绑�?#8221;信息的工作�?/font>

3.我们在命令模式中也可以设�|�类似undo的撤销命��o(h��)来撤销发出的命令请求：(x��)

public interface Command {
public void execute();
public void undo();
}

我们�q�是拿开�늁��q�个操作来说明，毕竟�q��够简单：(x��)对于一个开灯命令，其对应的撤销命��o(h��)自然�?#8220;关电(sh��)�?#8221;�Q?/font>

public class LightOnCommand implements Command {
    Light light;
    public LightOnCommand(Light light) {
        this.light = light;
    }
    public void execute() {
        light.on();
    }
    public void undo() {
        light.off();
    }
}

虽然�q�简单之极，�q�还没完�Q�我们必��让遥控器记住上�ơ到底做了什么操作，才可能去撤销�Q?/font>

package headfirst.command.undo;

import java.util.*;

//
// This is the invoker
//
public class RemoteControlWithUndo {
    Command[] onCommands;
    Command[] offCommands;
    Command undoCommand;
    public RemoteControlWithUndo() {
        onCommands = new Command[7];
        offCommands = new Command[7];
        Command noCommand = new NoCommand();
        for(int i=0;i<7;i++) {
            onCommands[i] = noCommand;
            offCommands[i] = noCommand;
        }
        undoCommand = noCommand;
    }
    public void setCommand(int slot, Command onCommand, Command offCommand) {
        onCommands[slot] = onCommand;
        offCommands[slot] = offCommand;
    }
    public void onButtonWasPushed(int slot) {
        onCommands[slot].execute();
        undoCommand = onCommands[slot];//记录操作动作
    }
    public void offButtonWasPushed(int slot) {
        offCommands[slot].execute();
        undoCommand = offCommands[slot];//记录操作动作
    }
    public void undoButtonWasPushed() {
        undoCommand.undo();//发出撤销命��o(h��)
    }
    public String toString() {
    }
}

对于�늁��Q�我们只有两�U�状态，但是要是多个状态呢�Q�我们�D一个吊扇的例子�Q�吊扇有多个转速，高中低关�Q�四个状态：(x��)

public class CeilingFan {
    String location = "";
    int level;
    public static final int HIGH = 2;
    public static final int MEDIUM = 1;
    public static final int LOW = 0;
    public CeilingFan(String location) {
        this.location = location;
    }
    public void high() {
        // turns the ceiling fan on to high
        level = HIGH;
        System.out.println(location + " ceiling fan is on high");
    }

    public void medium() {
        // turns the ceiling fan on to medium
        level = MEDIUM;
        System.out.println(location + " ceiling fan is on medium");
    }

    public void low() {
        // turns the ceiling fan on to low
        level = LOW;
        System.out.println(location + " ceiling fan is on low");
    }
    public void off() {
        // turns the ceiling fan off
        level = 0;
        System.out.println(location + " ceiling fan is off");
    }
    public int getSpeed() {
        return level;
    }
}

那么在实现风扇各个�{速命令时�Q�就要去记录在执行这个命令前风扇的�{速，其撤销命��o(h��)中则�Ҏ(gu��)��记录的部分完成undo操作�?/font>

public class CeilingFanHighCommand implements Command {
CeilingFan ceilingFan;
int prevSpeed;

    public CeilingFanHighCommand(CeilingFan ceilingFan) {
        this.ceilingFan = ceilingFan;
    }
    public void execute() {
        prevSpeed = ceilingFan.getSpeed();
        ceilingFan.high();
    }
    public void undo() {
        switch (prevSpeed) {
            case CeilingFan.HIGH:     ceilingFan.high(); break;
            case CeilingFan.MEDIUM: ceilingFan.medium(); break;
            case CeilingFan.LOW:     ceilingFan.low(); break;
            default:                 ceilingFan.off(); break;
        }
    }
}

当然你也可以实现诸如多个命��o(h��)扚w��执行和完成多个撤销操作�?/font>

命��o(h��)模式可以用于工作队列和日志操作等斚w��?/font>

Eric_jiang 2010-09-09 15:29 发表评论

Eric_jiang — Thu, 09 Sep 2010 06:44:00 GMT

　昄��Q�击鼓传��q��合责任链模式的定义。参加游戏的人是一个个的具体处理者对象，击鼓的�h便是客户端对象。花代表酒��o(h��)�Q�是传向处理者的��h��Q�每一个参加游戏的人在接到传来的花�Ӟ��可选择的行为只有两个：(x��)一是将花向下传�Q�一是执行酒�?--喝酒。一个�h不能既执行酒令，又向下家传花�Q�当某一个�h执行了酒令之后，游戏重新开始。击鼓的人�ƈ不知道最�l�是由哪一个做游戏的�h执行酒��o(h��)�Q�当然执行酒令的人必然是做游戏的��Z��中的一个�?/font>

　　击鼓传花的类囄��构如下：(x��)

�?、击鼓传��q��l�的�c�d��定义�?/font>

　　单独考虑击鼓传花�pȝ��Q�那么像贾母、贾赦、贾�ѝ��贾宝玉和贾环等传花者均应当�?#8220;具体传花�?#8221;的对象，而不应当是单独的�c�；但是责�Q链模式往往是徏立在现有�pȝ��的基��之上的，因此铄��l�构和组成不��p��任链模式本��n军_��?/font>

　　�pȝ��的分�?br /> 　　在《红楼梦》第七十五回里生动地描述了贾府里的一场击鼓传花游戏：(x��)“贾母坐下�Q�左垂首贾��Q�贾珍，贄��Q�贾蓉，叛_��首贾政，宝玉�Q�贾环，贑օ��Q�团团围坐�?..贾母便命折一枝桂花来�Q�命一媛_��在屏后击鼓传花。若花到谁手中，饮酒一�?..于是先从贾母��P��ơ贾赦，一一接过。鼓��C��转，恰恰在贾政手中住了，只得饮了酒�?#8221;�q�场游戏接着又把�׃��C��宝玉和贾赦手里，接着又传��C��在贾环手�?..

　　如果用一个对象系�l�描�q�贾府，那么贾母、贾赦、贾�ѝ��贾宝玉和贾环等�{�就应当分别�׃��个个具体�c�M��表，而这场击鼓传花游戏的�c�d��Q�按照责任链模式�Q�应当如下图所�C�：(x��)

�?、红楼梦中的击鼓传花游戏的示意性类图�?
　换言之，在击鼓传花游戏里面，有下面的几种角色�Q?br /> 　抽象传花者，或Handler角色、定义出参加游戏的传�׃�h要遵守的规则�Q�也��是一个处理请求的接口　和对下家的引用；
　具体传花者，或ConcreteHandler角色、每一个传��p��都知道下家是谁�Q�要么执行酒令，要么把花　向下传。这个角色由贾母、贾赦、贾珍、贾琏、贾蓉、贾�ѝ��宝玉、贾环、贾兰等扮演。　击鼓人，或Client角色、即行酒令的击鼓之�h。《红楼梦》没有给出此人的具体姓名�Q�只是说�?#8220;一　媛_��”扮演�?/font>

�?、贾府这�ơ击鼓传��q��C�意性对象图�?

　　可以看出�Q�击鼓传花游戏满��任链模式的定义，是纯的责任链模式的例�?
Java�pȝ��的解下面的类囄��Z��q�些�cȝ��具体接口设计。读者不隄��出，DrumBeater�Q�击鼓者）、Player�Q�传��p��）、JiaMu�Q�贾母）、JiaShe�Q�贾赦）、JiaZheng�Q�贾政）、JiaBaoYu�Q�宝玉）、JiaHuan�Q�贾环）�{�组成这个系�l��?br />

�?、击鼓传��q��c�d��完全�W�合责�Q链模式的定义�?

　　下面是客��L(f��ng)��c�DrumBeater的源代码�Q?/font>

//DrumBeater的源代码
public class DrumBeater
{
　 private static Player player;
　 static public void main(String[] args)
　　 {
　　　 player = new JiaMu( new JiaShe( new JiaZheng( new JiaBaoYu(new JiaHuan(null)))));
　　　　player.handle(4);
　　 }
}

//抽象传花者Play�cȝ��源代�?br /> abstract class Player
{
  abstract public void handle(int i);
  private Player successor;
  public   Player() { successor = null;}

  protected void setSuccessor(Player aSuccessor)
  {
  　 successor = aSuccessor;
  }

  public void next(int index)
  {
  　 if( successor != null )
  　　 {
  　　　 successor.handle(index);
  　　 }
  　 else
  　　 {
  　　　 System.out.println("Program terminated.");
  　　 }
  　 }
  }
}
　

　　抽象�c�Player�l�出了两个方法的实现�Q�以格式setSuccessor()�Q�另一个是next()。前者用来设�|�一个传��p��对象的下家�Q�后者用来将酒��o(h��)传给下家。Player�cȝ��Z��一个抽象方法handle()�Q�代表执行酒令�?/font>

　　下面的这些具体传��p��类��给出handle()�Ҏ(gu��)��的实现�?/font>

//贾母的JiaMu�c?br /> class JiaMu extends Player
{
　　 public JiaMu(Player aSuccessor)
　　 {
　　　 this.setSuccessor(aSuccessor);
　　 }
　　 public void handle(int i)
　　 {
　　　 if( i == 1 )
　　　 {
　　　　 System.out.println("Jia Mu gotta drink!");
　　　 }
　　　 else
　　　 {
System.out.println("Jia Mu passed!");
next(i);
　　　 }
　　 }
}

　
//贾��的JiaShe�c?br /> class JiaShe extends Player
　 {
　　 public JiaShe(Player aSuccessor)
　　 {
　　　 this.setSuccessor(aSuccessor);
　　 }
　　 public void handle(int i)
　　　 {
　　　　 if( i == 2 )
　　　　 {
　　　　　 System.out.println("Jia She gotta drink!");
　　　　 }
　　　　 else
　　　　 {
　　　　　 System.out.println("Jia She passed!");
　　　　　 next(i);
　　　　 }
　　　 }
　 }

　　
//贾政的JiaZheng�c?br /> class JiaZheng extends Player
　 {
　　 public JiaZheng(Player aSuccessor)
　　 {
　　　 this.setSuccessor(aSuccessor);
　　 }
　　 public void handle(int i)
　　 {
　　　 if( i == 3 )
　　　 {
　　　　 System.out.println("Jia Zheng gotta drink!");
　　　 }
　　　 else
　　　 {
　　　　 System.out.println("Jia Zheng passed!");
　　　　 next(i);
　　　 }
　　 }
　 }

　
//贑֮�玉的JiaBaoYu�c?br /> class JiaBaoYu extends Player
　 {
　　 public JiaBaoYu(Player aSuccessor)
　　 {
　　　 this.setSuccessor(aSuccessor);
　　 }
　　 public void handle(int i)
　　 {
　　　 if( i == 4 )
　　　 {
　　　　 System.out.println("Jia Bao Yu gotta drink!");
　　　 }
　　　 else
　　　 {
　　　　 System.out.println("Jia Bao Yu passed!");
　　　　 next(i);
　　　 }
　　 }
　 }

　　
//JiaHuan�c?br /> class JiaHuan extends Player
　 {
　　 public JiaHuan(Player aSuccessor)
　　　 {
　　　　 this.setSuccessor(aSuccessor);
　　　 }
　　 public void handle(int i)
　　 {
　　　 if( i == 5 )
　　　 {
　　　　 System.out.println("Jia Huan gotta drink!");
　　　 }
　　　 else
　　　 {
　　　　 System.out.println("Jia Huan passed!");
　　　　 next(i);
　　　 }
　　 }
　 }

　　可以看出�Q�DrumBeater讑֮�了责任链的成员和他们的顺序：(x��)责�Q铄��贾母开始到贄��Q�周而复始。JiaMu�c�R��JiaShe�c�R��JiaZheng�c�R��JiaBaoYu�c�M��JiaHuan�c�d��是抽象传��p��Player�cȝ��子类�?/font>

　　本节所实现的DrumBeater�c�d��把请求传�l�贾母时�Q�实际上指定了由4号传��p��处理酒令。虽然DrumBeater�q�不知道哪一个传��p��类持有��L(f��ng)��4�Q�但是这个号码在本系�l�一开始就写死的。这当然�q�不�W�合击鼓传花游戏的精��，因�ؓ(f��)�q�个游戏实际上要求有两个同时�q�行的过�E�：(x��)击鼓�q�程和传��p��E�。击鼓应当是定时停止的，当击鼓停止时�Q�执行酒令者就��定了。但是本节这样做可以佉K��题得到简化�ƈ��读者的�_�֊�攑֜�责�Q链模式上�Q�而不是两个过�E�的处理上�?br />
在什么情况下使用责�Q链模�?/font>

　　在下面的情况下��用责任链模式�Q?/font>

　　�W�一、系�l�已�l�有一个由处理者对象组成的链。这个链可能由复合模式给出，

　　�W�一、当有多于一个的处理者对象会(x��)处理一个请求，而且在事先�ƈ不知道到底由哪一个处理者对象处理一个请求。这个处理者对象是动态确定的�?/font>

　　�W�二、当�pȝ��惛_��Z��个请求给多个处理者对象中的某一个，但是不明显指定是哪一个处理者对象会(x��)处理此请求�?/font>

　　�W�三、当处理一个请求的处理者对象集合需要动态地指定时�?/font>

　　使用责�Q链模式的长处和短�?/font>

　　责�Q链模式减低了发出命��o(h��)的对象和处理命��o(h��)的对象之间的耦合�Q�它允许多与一个的处理者对象根据自��q��逻辑来决定哪一个处理者最�l�处理这个命令。换�a�之，发出命��o(h��)的对象只是把命��o(h��)传给铄��构的起始者，而不需要知道到底是链上的哪一个节点处理了�q�个命��o(h��)�?/font>

　　昄��Q�这意味着在处理命令上�Q�允许系�l�有更多的灵�z�L��。哪一个对象最�l�处理一个命令可以因为由那些对象参加责�Q链、以�?qi��ng)这些对象在责�Q链上的位�|�不同而有所不同�?/font>

　　责�Q链模式的实现

　　铄��构的由来

　　值得指出的是�Q�责任链模式�q�不创徏��任链。责任链的创建必��L��pȝ��的其它部分完成�?/font>

　　责�Q链模式减低了��h��的发送端和接收端之间的耦合�Q��多个对象都有��Z��(x��)处理�q�个��h��。一个链可以是一条线�Q�一个树(w��i)�Q�也可以是一个环。链的拓扑结构可以是单连通的或多�q�通的�Q�责任链模式�q�不指定责�Q铄��拓扑�l�构。但是责任链模式要求在同一个时间里�Q�命令只可以被传�l�一个下�Ӟ��或被处理掉）�Q�而不可以传给多于一个下家。在下面的图中，责�Q链是一个树(w��i)�l�构的一部分�?/font>

�?、责任链是系�l�已有的�?w��i)结构的一部分。图中有阴媄的对象给��Z��一个可能的命��o(h��)传播路径�?/font>

　　责�Q铄��成员往往是一个更大的�l�构的一部分。比如在前面所讨论的《红楼梦》中击鼓传花的游戏中�Q�所有的成员都是贑ֺ�的成员。如果责任链的成员不存在�Q�那么�ؓ(f��)了��用责任链模式�Q�就必须创徏它们�Q�责任链的具体处理者对象可以是同一个具体处理者类的实例�?/font>

Eric_jiang 2010-09-09 14:44 发表评论

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

Eric_jiang — Thu, 09 Sep 2010 06:21:00 GMT

��保一个特定的�c�d��有一个对象被实例化�?/font>

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

Eric_jiang 2010-09-09 14:21 发表评论

原型模式

Eric_jiang — Thu, 09 Sep 2010 06:13:00 GMT

原型模式�Q�Prototype�Q�属于创建型模式�Q�实��C��对象的创建；具体而言�Q�它实现了对象的复制�Q�拷贝）�?/font>

关于对象的复�Ӟ��我们需要考虑以下两个问题�Q?/font>

1.对象实时状态的复制�Q?/font>

2.对象引用成员变量的复制�?/font>

如果通过new方式来实例化对象�Q�只能得到对象的初始状态，�q�显然不行。在Java中，所有类都��承于Object�c�，而Object有一个clone()�Ҏ(gu��)��。通过查看JDK文��Q�该clone()�Ҏ(gu��)��虽然能够实现实时状态的复制�Q�解决了问题1�Q�，但是只能实现“��拷�?#8221;�Q�即只能实现基本数据�c�d��Q�包含String�Q�的拯��Q�不能实现引用数据类型的拯��Q��ƈ不能满��原型模式的要求（问题2不能得到解决�Q��?/font>

怎么办？重写�cȝ��clone()�Ҏ(gu��)��Q�通过对象的写入写出来实现“深拷�?#8221;和实时状态复制。重写（Override�Q�需要遵循的条�g是：(x��)�Ҏ(gu��)��名，参数列表和父�c�M��_(d��)��q�回值是父类�q�回值的子类。重写clone�Ҏ(gu��)��完全满��了条件。（无参敎ͼ��Ҏ(gu��)��名一��_(d��)��q�回的所有类都是Object的子�c�；当然可以不重写，�Ҏ(gu��)��名改用其它，但是不徏议。）

可以惌��Q�若一个类含有若干个引用数据类型（�c�）�Q�而该引用数据�c�d��Q�类�Q�中又含有若�q�个引用数据�c�d��…�q�样嵌套下去�Q�需要复制的��׃��是一个类�Q�而是一�?#8220;�c�L��(w��i)”�Q�树(w��i)�l�构�Q�。Java通过��对象序列化到文件或内存�Q�底层封装了对类�?w��i)的遍历和复制过�E�。这个机制已�l�封装，我们无需了解�?/p>

考虑�q�样一个应用场景：(x��)

一个RPG游戏�Q�英雄类含有两个成员变量�Q�一个是英雄名字�Q��ؓ(f��)普通成员变量；一个是英雄属性，为引用成员变量（��装了英雄的状态，如生命倹{��魔法��|��。�ؓ(f��)了实现对象实时拷贝的高效率，我们选择��对象序列化到内存（不是文�g�Q�硬盘）�Q�。通过输入输出��实现对象的“深拷�?#8221;�?/p>

具体的实��C��码如下：(x��)

package com.csufox.Prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

class Property implements java.io.Serializable{
int blood = 100; //生命�?br /> int magic = 100; //��法�?br /> }

class Hero implements java.io.Serializable{ //需要实现序列化接口
String name = "英雄";
Property property = new Property(); //含有引用成员�Q�需�?#8220;�?#8221;拯��

    public Hero clone(){
        Hero copy = null;
        try{
            //实例化ObjectOutputStream�Q�写入字节数�l�输出流
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(this);
            byte[] data = baos.toByteArray(); //data是字节数�l�，存储着对象的拷�?/p>

            //实例化ObjectInputStream�Q�从字节数组输入��中��d��对象
            ByteArrayInputStream bais = new ByteArrayInputStream(data);
            ObjectInputStream ois = new ObjectInputStream(bais);
            copy = (Hero)ois.readObject();
        }catch(Exception ex){ex.printStackTrace();}
        return copy;
    }
}

public class Prototype {
    public static void main(String[] args) throws Exception {
        Hero hero = new Hero();
        hero.property.blood -= 20; //原英雄状态发生改变，生命值减��?0
        Hero copy = hero.clone();
        System.out.println(copy.property.blood); //输出“80”�Q�说明实��C��实时拯��和深拯��
    }
}

�׃��q�C��码可知，原型模式��h��以下特点�Q?/p>

实现Serializable序列化接口；
在类中重写clone()�Ҏ(gu��)��Q�由O(ji��n)bject�l�承而来�Q�；
通过Java I/0�Q�将对象写入内存�Q�然后再从内存读取（反序列化�Q��?

Eric_jiang 2010-09-09 14:13 发表评论

Eric_jiang — Thu, 09 Sep 2010 05:58:00 GMT

Builder模式定义:
��一个复杂对象的构徏与它的表�C�分��?使得同样的构��E�可以创��Z��同的表示.

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

��Z��使用?
是�ؓ(f��)了将构徏复杂对象的过�E�和它的部�g解�?注意: 是解耦过�E�和部�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��解耦过�E�和部�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的代�?/font>

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

Builder模式的应�?br /> 在Java实际使用�?我们�l�常用到"�?(Pool)的概�?当资源提供者无法提供��够的资源,�q�且�q�些资源需要被很多用户反复�׃�n�?��需要��用池.

"�?实际是一�D�内�?当池中有一些复杂的资源�?断肢"(比如数据库的�q�接�?也许有时一个连接会(x��)中断),如果循环再利用这�?断肢",��提高内存��用效�?提高池的性能.修改Builder模式中Director�c�M��之能诊断"断肢"断在哪个部�g�?再修复这个部�?

Eric_jiang 2010-09-09 13:58 发表评论

工厂�Ҏ(gu��)��设计模式

Eric_jiang — Thu, 09 Sep 2010 04:08:00 GMT

在设计模式中,Factory Method也是比较��单的一�?但应用非常广�?EJB,RMI,COM,CORBA,Swing中都可以看到此模式的影子,它是最重要的模式之一.在很多地�Ҏ(gu��)��们都�?x��)看到xxxFactory�q�样命名的类,那么,什么是Factory Method,��Z��么要用这个模�?如何用Java语言来实现该模式,�q�就是本文想要带�l�大家的内容.
基本概念

FactoryMethod是一�U�创建性模�?它定义了一个创建对象的接口,但是却让子类来决定具体实例化哪一个类.当一个类无法预料要创建哪�U�类的对象或是一个类需要由子类来指定创建的对象时我们就需要用到Factory Method 模式�?��单说�?Factory Method可以�Ҏ(gu��)��不同的条件��生不同的实例,当然�q�些不同的实例通常是属于相同的�c�d��,��h��共同的父�c?Factory Method把创��些实例的具体�q�程��装��h��?��化了客户端的应用,也改善了�E�序的扩展�?使得��来可以做最��的改动��可以加入新的待创徏的类. 通常我们��Factory Method作�ؓ(f��)一�U�标准的创徏对象的方�?当发现需要更多的灉|��性的时�?��开始考虑向其它创建型模式转化

��单分�?/p>

�?是Factory Method 模式的结构图,�q�里提供了一些术�?让我们可以进行更方便的描�q?

Product: 需要创建的产品的抽象类.
ConcreteProduct: Product的子�c?一�p�d��具体的��?
Creator: 抽象创徏器接�?声明�q�回Product�c�d��对象的Factory Method.
ConcreteCreator: 具体的创建器,重写C(j��)reator中的Factory Method,�q�回ConcreteProduct�c�d��的实�?

�?: Factory Method 模式�l�构

由此可以清楚的看��L(f��ng)��q��对应关系: Product <====> Creator ; ConreteProduct <====> ConreteCreator

抽象产品对应抽象创徏�?具体产品对应具体创徏�?�q�样做的好处是什么呢?��Z��么我们不直接用具体的产品和具体的创徏器完成需求呢?实际上我们也可以�q�样�?但通过Factory Method模式来完�?客户(client)只需引用抽象的Product和Creater,对具体的ConcreteProduct和ConcreteCreator可以毫不兛_��,�q�样做我们可以获得额外的好处:

首先客户端可以统一从抽象创建器获取产生的实�?Creator的作用将client和��品创��E�分��d��?客户不用操心�q�回的是那一个具体的产品,也不用关心这些��品是如何创徏�?同时,ConcreteProduct也被隐藏在Product后面,ConreteProduct�l�承了Product的所有属�?�q�实��C��Product中定义的抽象�Ҏ(gu��)��,按照Java中的对象造型(cast)原则,通过ConcreteCreator产生的ConcreteProduct可以自动的上溯造型成Product.�q�样一�?实质内容不同的ConcreteProduct��可以在形式上统一为Product,通过Creator提供�l�client来访�?
其次,当我们添加一个新的ConcreteCreator�?�׃��Creator所提供的接口不�?客户端程序不�?x��)有丝毫的改�?不会(x��)带来动一发而牵全��n的灾�? �q�就是良好封装性的体现.但如果直接用ConcreteProduct和ConcreteCreator两个�c�L��无论如何也做不到�q�点�? 优良的面向对象设计鼓�׃��用封�?encapsulation)和委�?delegation),而Factory Method模式��是使用了封装和委托的典型例�?�q�里��装是通过抽象创徏器Creator来体现的,而委托则是通过抽象创徏器把创徏对象的责��d��全交�l�具体创建器ConcreteCreator来体现的.
现在,请再回头看看基本概念中的那段�?开始也许觉得生涩难�?现在是不是已�l�明朗化了很�?

下面让我们看看在 Java 中如何实现Factory Method模式,�q�一步加深对它的认识.

具体实施

先说明一�?用Factory Method模式创徏对象�q�不一定会(x��)让我们的代码更短,实事上往往更长,我们也��用了更多的类,真正的目的在于这样可以灵�zȝ��,有弹性的创徏不确定的对象.而且,代码的可重用性提高了,客户端的应用��化了,客户�E�序的代码会(x��)大大减少,变的更具可读�?

标准实现: �q�里我采用Bruce Eckel 用来描述OO思想的经�怾��?Shape.�q�样大家�?x��)比较熟�?zh��n)�一�?我完全按照图1中所定义的结构写了下面的一�D�|��C�Z��?�q�段代码的作用是创徏不同的Shape实例,每个实例完成两个操作:draw和erase.具体的创��E�委托ShapeFactory来完�?
1.a 首先定义一个抽象类Shape,定义两个抽象的方�?

abstract class Shape {
// 勄��shape
public abstract void draw();
// 擦去 shape
public abstract void erase();
public String name;
public Shape(String aName){
name = aName;
}
}

1.b 定义 Shape的两个子�c? Circle, Square,实现Shape中定义的抽象�Ҏ(gu��)��

// 圆�Ş子类
class Circle extends Shape {
public void draw() {
    System.out.println("It will draw a circle.");
}
public void erase() {
    System.out.println("It will erase a circle.");
}
// 构造函�?br /> public Circle(String aName){
    super(aName);
}
}
// 方�Ş子类
class Square extends Shape {
public void draw() {
    System.out.println("It will draw a square.");
}
public void erase() {
    System.out.println("It will erase a square.");
}
// 构造函�?br /> public Square(String aName){
    super(aName);
}
}

1.c 定义抽象的创建器,anOperation调用factoryMethod创徏一个对�?�q�对该对象进行一�p�d��操作.

abstract class ShapeFactory {
protected abstract Shape factoryMethod(String aName);
// 在anOperation中定义Shape的一�p�d��行�ؓ(f��)
public void anOperation(String aName){
    Shape s = factoryMethod(aName);
    System.out.println("The current shape is: " + s.name);
    s.draw();
    s.erase();
}
}

1.d 定义与circle和square相对应的两个具体创徏器CircleFactory,SquareFactory,实现父类的methodFactory�Ҏ(gu��)��

// 定义�q�回 circle 实例�?CircleFactory
class CircleFactory extends ShapeFactory {
// 重蝲factoryMethod�Ҏ(gu��)��,�q�回Circle对象
protected Shape factoryMethod(String aName) {
return new Circle(aName + " (created by CircleFactory)");
}
}

// 定义�q�回 Square 实例�?SquareFactory
class SquareFactory extends ShapeFactory {
// 重蝲factoryMethod�Ҏ(gu��)��,�q�回Square对象
protected Shape factoryMethod(String aName) {
return new Square(aName + " (created by SquareFactory)");
}
}

1.e ��试�c?��h��意这个客��L(f��ng)��E�序多么��z?既没有罗嗦的条�g判断语句,也无需兛_��ConcreteProduct和ConcreteCreator的细�?因�ؓ(f��)�q�里我用anOperation��装了Product里的两个�Ҏ(gu��)��,所以连Product的媄子也没看�?当然把Product里方法的具体调用攑ֈ�客户�E�序中也是不错的).

class Main {
public static void main(String[] args){
    ShapeFactory sf1 = new SquareFactory();
    ShapeFactory sf2 = new CircleFactory();
    sf1.anOperation("Shape one");
    sf2.anOperation("Shape two");
}
}

�q�行�l�果如下:

The current shape is: Shape one (created by SquareFactory)

It will draw a square.

It will erase a square.

The current shape is: Shape two (created by CircleFactory)

It will draw a circle.

It will erase a circle.

参数化的Factory Method: �q�种方式依靠指定的参��C��为标志来创徏对应的实�?�q�是很常见的一�U�办�?比如JFC中的BorderFactory��是个很不错的例�? 以下的这个例子是用字�W�串作�ؓ(f��)标记来进行判断的,如果参数的类型也不一�?那就可以用到�q�蝲函数来解册��个问�?定义一�p�d��参数和方法体不同的同名函�?�q�里java.util.Calendar.getInstance()又是个极好的例子.参数化的创徏方式克服了Factory Method模式一个最显著的缺�?��是当具体��品比较多�?我们不得不也建立一�p�d��与之对应的具体构造器. 但是在客��L(f��ng)��我们必须指定参数来决定要创徏哪一个类.
2.a 我们在第一�U�方法的基础上进行修�?首先自定义一个的异常,�q�样当传入不正确的参数时可以得到更明昄��报错信息.

class NoThisShape extends Exception {
public NoThisShape(String aName) {
super(aName);
}
}

2.b��L��了ShapeFactory的两个子�c?改�ؓ(f��)由ShapeFactory直接负责实例的创�? ShapeFactory自己变成一个具体的创徏�?直接用参数化的方法实现factoryMethod�q�回多种对象.

abstract class ShapeFactory {
private static Shape s;
private ShapeFactory() {}

static Shape factoryMethod(String aName, String aType) throws NoThisShape{
    if (aType.compareTo("square")==0)
      return new Square(aName);
    else if (aType.compareTo("circle")==0)
      return new Circle(aName);
    else throw new NoThisShape(aType);
}

// 在anOperation中定义Shape的一�p�d��行�ؓ(f��)
static void anOperation(String aName, String aType) throws NoThisShape{
    s = factoryMethod(aName, aType);
    System.out.println("The current shape is: " + s.name);
    s.draw();
    s.erase();
}
}

2.c ��试�c?�q�里客户端必��L��定参数来军_��具体创徏哪个�c?�q�个例子里的anOperation是静态函�?可以直接引用.

class Main {
public static void main(String[] args) throws NoThisShape{
    ShapeFactory.anOperation("Shape one","circle");
    ShapeFactory.anOperation("Shape two","square");
    ShapeFactory.anOperation("Shape three", "delta");
}
}

�q�行�l�果如下:

The current shape is: Shape one
It will draw a circle.
It will erase a circle.
The current shape is: Shape two
It will draw a square.
It will erase a square.
Exception in thread "main" NoThisShape: delta
        at ShapeFactory.factoryMethod(ShapeFactory.java:10)
        at ShapeFactory.anOperation(ShapeFactory.java:15)
        at Main.main(Main.java:5)

动态装载机�?
有的时候我们会(x��)把ConcreteProduct的实例传�l�创建器作�ؓ(f��)参数,�q�种情况�?如果在创建器里完成创��E?��必��d��断参数的具体�c�d��(用instanceof),然后才能产生相应的实�?那么比较好的做法是利用Java的动态装载机制来完成�q��g�?比如:

我们得到一个Shape的子�c�s,但不知道具体是那个子�c?��可以利用Class�c�自带的�Ҏ(gu��)��newInstance()得到实例

return (Shape)s.getClass().newInstance();

�q�种�Ҏ(gu��)��有兴��得读者可以自己尝�?限于��幅,不写具体代码出来�?

回页�?

后话:

看完�q�篇文章�?�怿�读者对Factory Method模式有一个比较清楚的了解�?我想说的�?我们不仅应该兛_��一个具体的模式有什么作�?如何��d��现这个模�?更应该透过现象看本�?不但知其�?�q�要知其所以然.要通过�Ҏ(gu��)��式的学习(f��n)加深寚w��向对象思想的理�?让自��q��认识得到升华.Factory Method模式看似��?实则深刻.抽象,��装,�l�承,委托,多�?针对接口�~�程�{�面向对象中的概念都在这里得��C��一一的体�?只有抓住了它的本�?我们才能够不拘于形式的灵�z�运�?而不是�ؓ(f��)了��用模式而��用模�?

Eric_jiang 2010-09-09 12:08 发表评论

代理模式�Q�静态代理和动态代理）

Eric_jiang — Thu, 09 Sep 2010 03:47:00 GMT

一�?Proxy模式定义:
为其他对象提供一�U�代理以控制�q�个对象的访问�?br /> 二�?模式解说
Proxy代理模式是一�U�结构型设计模式�Q�主要解决的问题是：(x��)在直接访问对象时带来的问题，比如��_(d��)��(x��)要访问的对象在远�E�的机器上。在面向对象�pȝ��中，有些对象�׃��某些原因�Q�比如对象创建开销很大�Q�或者某些操作需要安全控�Ӟ��或者需要进�E�外的访问）�Q�直接访问会(x��)�l��用者或者系�l�结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的讉K��?�q�个讉K��层也叫代理。Proxy模式是最常见的模式，在我们生�z�M��处处可见�Q�例如我们买火�R��不一定非要到火�R站去乎ͼ�可以��C��些火车票的代售点��M��。寄信不一定是自己��d��Q�可以把信委托给邮局�Q�由邮局把信送到目的圎ͼ�现实生活中还有很多这��L(f��ng)��例子�Q�就不一一列�D了�?
三�?�l�构�?br /> Proxy模式�l�构囑֦��?

四�?一个例�?br /> 举一个比较俗的例子，一个男孩boy喜欢上了一个女孩girl�Q�男孩一直想认识奛_��Q�直接去和女孩打招呼吧，又觉得不好意思（�q�个男孩比较害羞�Q�。于是男孩想��Z��一个办法，委托奛_��的室友Proxy��d��他搞定这件事�Q�获得一些关于女孩的信息�Q�如有没有BF�{?�q�就叫知��q��|��才能百战不殆�Q�。下面给��个例子的�E�序实现�Q?/p>

interface GirlInfo{
public void hasBoyFriend();
}

class Girl implements GirlInfo{

  public void hasBoyFriend(){
   System.out.println("�q�没有男朋友");
  }

}

class Proxy implements GirlInfo{

  private GirlInfo girl;

  public Proxy(GirlInfo girl){
   this.girl=girl;
  }
  public void hasBoyFriend(){
   this.girl.hasBoyFriend();
  }

}

public class ProxyClient {

public static void main(String[] args) {
  GirlInfo girl=new Girl();
  Proxy proxy=new Proxy(girl);
  proxy.hasBoyFriend();
}

}
从这个例子我们可以看出，Proxy模式是不是和Adapter模式差不多，都是调用一个已有对象的�Ҏ(gu��)��来完成功能。但是他们之间还是有区别的，那就是Proxy模式的目标类必须要实现某个接口，代理�c�L��有必要实现该接口�Q�模式是�ȝ��Q�它的实现是�zȝ��Q�如果一味的�怿�某些书上的实玎ͼ�学习(f��n)模式也就失去了意义。有的书上称�q�种实现为静态代理，之所以这��h��Z��区别于Proxy模式在jdk中的另一�U�实�?jdk中的实现�U�Cؓ(f��)动态代理。下面用jdk中的�Ҏ(gu��)��l�出�q�个例子的实现。代码如�?

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface GirlInfo{
public void hasBoyFriend();
}

class Girl implements GirlInfo{

  public void hasBoyFriend(){
   System.out.println("�q�没有男朋友");
  }

}

class GirlProxy implements InvocationHandler{
  private Object delegate;
  public Object bind(Object delegate){
   this.delegate=delegate;
   return Proxy.newProxyInstance(delegate.getClass().getClassLoader(), delegate.getClass().getInterfaces(),this);
  }

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

   method.invoke(delegate, args);
   return null;
  }

}

public class ProxyClient {

  public static void main(String[] args) {
   GirlProxy girlProxy=new GirlProxy();
   GirlInfo girl=(GirlInfo)girlProxy.bind(new Girl());
   girl.hasBoyFriend();
  }

}

五�?适用�?br /> 1�Q?假如有一个外部组件包�Q�不允许实现其接口，则就只能使用其动态代理了�?br /> 2�Q?直接讉K��一个对象很困难�Q�或者说不能讉K��Q�此时只能是找个代理去访问，然后把结果反馈给自己�?br /> 六�?优缺�?br /> 1) 优点: 向客��L(f��ng)��隐藏了访问某个对象的�l�节�?qi��ng)复杂性；可以动态地调用一个对象中的方法，且无需实现固定的接口�?br /> 2) �~�点�Q�暂时没发现

Eric_jiang 2010-09-09 11:47 发表评论

抽象工厂模式

Eric_jiang — Thu, 09 Sep 2010 03:34:00 GMT

抽象工厂模式�Q�Abstract Factory�Q�：(x��)为创��Z��l�相��x��者互�怾�赖的对象提供一个接口，而无需指定它们对应的具体类�?br /> 通用�c�d��如下�Q?

例如�Q�我们现在有两种产品A和B�Q�而��品A和B分别都有两个厂商1�?�q�行生��Q�在�q�里我们把不同的厂商1、厂�?理解为牌�?和牌�?�Q�那么厂�?��q��产A1、B1�Q�厂�?生��A2、B2�?br /> 此时�Q�不同的厂商肯定要生产自��q��产品�Q�如A1、B1�Q�，每个厂商都有自己的一�p�d��产品�Q�这��׃��上面抽象工厂模式的描�q�类��g��?br /> 该例子的�c�d��如下�Q?

具体代码实现如下�Q?br /> //定义不同的��品之间的一定具备的标准�Q�用interface实现
//其中的method()�Ҏ(gu��)��可看作提取出不同产品的共性，如手机都有类似的功能
interface IProductA{
public void method();
}

interface IProductB{
public void method();
}

//实现了��品标准实现的一�p�d��具体产品
//�׃��已经设计好A1由厂�?生��Q�故以下输出代码�?#8220;厂商x”
class ProductA1 implements IProductA{
public void method() {
System.out.println("厂商1 生��ProductA1 ...");
}
}

class ProductA2 implements IProductA{
public void method() {
System.out.println("厂商2 生��ProductA2 ...");
}
}

class ProductB1 implements IProductB{
public void method() {
System.out.println("厂商1 生��ProductB1 ...");
}
}

class ProductB2 implements IProductB{
public void method() {
System.out.println("厂商2 生��ProductB2 ...");
}
}

//每一�U�牌子的产品生��工厂�Q�即不同的厂商负责自��q��子��品的生��
abstract class Factory1{
abstract IProductA getProductA1();
abstract IProductB getProductB1();
}

abstract class Factory2{
abstract IProductA getProductA2();
abstract IProductB getProductB2();
}

//具体的工厂用来生产相关的产品
class ConcreteFactory1 extends Factory1{
public IProductA getProductA1() {
return new ProductA1();
}
public IProductB getProductB1() {
return new ProductB1();
}
}

class ConcreteFactoryB extends Factory2{
public IProductA getProductA2() {
return new ProductA2();
}
public IProductB getProductB2() {
return new ProductB2();
}
}

//��试�c?
public class Client {
public static void main(String[] args) {
    //厂商1负责生��产品A1、B1
    Factory1 factory1 = new ConcreteFactory1();
    IProductA productA1 = factory1.getProductA1();
    IProductB productB1 = factory1.getProductB1();

    productA1.method();
    productB1.method();

    //厂商2负责生��产品A2、B2
    Factory2 factory2 = new ConcreteFactoryB();
    IProductA productA2 = factory2.getProductA2();
    IProductB productB2 = factory2.getProductB2();

    productA2.method();
    productB2.method();
}
}
�q�行�l�果�Q?br /> 厂商1 生��ProductA1 ...
厂商1 生��ProductB1 ...
厂商2 生��ProductA2 ...
厂商2 生��ProductB2 ...

其实�Q�上例中本来可以不用��C��两个抽象工厂�Q�只剩一个也可，但是�q�样子与我们现实生活中不同厂商各自生产自��q��产品有点不同�Q�所以就��其分开��Z��个了�Q�也��是��两个厂商完全地分离开�?br /> �׃��面类囑֏�以知道，一旦�Q何一个厂商开发出了��品C的话�Q�那么这个厂商肯定需要扩展自��q��工厂来投入到C产品的生产中�Q�那么此时工�?和工�?��需要进行一定的改变了，�q�很明显不符合开闭原则�?/font>

Eric_jiang 2010-09-09 11:34 发表评论

外观模式

Eric_jiang — Thu, 09 Sep 2010 03:22:00 GMT

Facade模式是这��h��q�的:
为子�pȝ��中的一�l�接口提供一个统一接口。Facade模式定义了一个更高层的接口，使子�pȝ��更加�Ҏ(gu��)��使用�?/font>

大致意思是��_(d��)��(x��)使用一�U�比原有方式更简单的办法与系�l�交互。例如，我们拿一个文�Ӟ��q�个文�g攑֜�了第二抽屉里�Q�而第二个抽屉的钥匙放在了�W�一个抽屉里�Q�我们要惛_��个文�Ӟ��W�一步肯定要拿到�W�一个抽屉的钥匙�Q�然后打开它再拿出�W�二个抽屉的钥匙�Q�最后打开�W�二个抽屉取出文件�?br /> 我就上面说的那个情�Ş写一下实��C��?/font>

class DrawerOne {

public void open(){

System.out.println("�W�一个抽屉被打开�?);

getKey();

}

public void getKey(){

System.out.println("得到�W�二个抽屉的钥匙");

}

class DrawerTwo{

public void open(){

System.out.println("�W�二个抽屉被打开�?);

getFile();

}

public void getFile(){

System.out.println("得到�q�个重要文�g");

}

public class Client{

public static void main(String []args){

DrawerOne darwerOne=new DrawerOne();

DrawerTwo darwerTwo=new DrawerTwo();

darwerOne.open();

darwerTwo.open();

}

�׃��没有使用Fa?ade模式�Q�可以看到要惛_��到这个文件要首先打开�W�一个抽屉，然后再打开�W�二个抽屉，在我们实际所开发的�pȝ��中，有时候客戯��实现某一操作�Q��ƈ不需要知道实现这一操作的详�l�步骤，而是��单地点击某一个按钮就可以得到自己惌��的结果。下面对上面的代码��用Fa?ade模式�q�行改进�Q�徏立一个FacadeDrawer�c�：(x��)

class DrawerFacade{

DrawerOne darwerOne=new DrawerOne();

DrawerTwo darwerTwo=new DrawerTwo();

public void open(){

darwerOne.open();

darwerTwo.open();

}

修改Client�c�：(x��)

public class DrawerClient{

public static void main(String []args){

DrawerFacade drawer=new DrawerFacade();

drawer.open();

}

输出�l�果如下�Q?/font>

�W�一个抽屉被打开�?/font>

得到�W�二个抽屉的钥匙

�W�二个抽屉被打开�?/font>

得到�q�个重要文�g

正如上面所��_(d��)��客户端client�Q�它�q�不需要关心子�pȝ��Q�而是兛_��DrawerFacade所留下来的和外部交互的接口�Q�而子�pȝ��在DrawerFacade的聚合�?/font>

以上只是个�h拙见�Q�哪里有不正��的地方�Q�希望大家多多批评指正。^_^

Facade模式主要适用于以下几�U�情�?

1)不需要��用一个复杂系�l�的所有功能，而且可以创徏一个新的类�Q�包含访问系�l�的所有规则。如果只需要��用系�l�的部分功能�Q�那么你为新�c�L��创徏的API��比原系�l�的API��单的多�?/font>

2)希望��装或者隐藏系�l�原�pȝ��?/font>

3)希望使用原系�l�的功能�Q�而且�q�希望增加一些新的功能�?/font>

4) �~�写新类的成本小于所有�h学会(x��)使用或者未来维护原�pȝ��上所需的成本�?/font>

Eric_jiang 2010-09-09 11:22 发表评论

享元模式

Eric_jiang — Thu, 09 Sep 2010 03:13:00 GMT

一、FlyWeight模式定义:

�q�用�׃�n技术有效地支持大量�l�粒度对象�?/font>

二、模式解�?/font>

也就是说在一个系�l�中如果有多个相同的对象�Q�那么只�׃�n一份就可以了，不必每个都去实例化一个对象。在Flyweight模式中，�׃��要��生各�U�各��L(f��ng)��对象�Q�所以在Flyweight(享元)模式中常出现Factory模式。Flyweight的内部状态是用来�׃�n�?Flyweight factory负责�l�护一个对象存储池�Q�F(tu��n)lyweight Pool�Q�来存放内部状态的对象。Flyweight模式是一个提高程序效率和性能的模�?�?x��)大大加快程序的�q�行速度�?/font>

三、结构图

享元模式所涉及(qi��ng)的角色有抽象享元角色、具体（单纯�Q��n元角艌Ӏ�复合��n元角艌Ӏ��n员工厂角�Ԍ��以及(qi��ng)客户端角色等�?/font>

抽象享元角色�Q�F(tu��n)lyweight�Q�：(x��)此角色是所有的具体享元�cȝ��类�Q��ؓ(f��)�q�些�c�规定出需要实现的公共接口或抽象类。那些需要外蕴状�?External State)的操作可以通过�Ҏ(gu��)��的参��C��入。抽象��n元的接口使得享元变得可能�Q�但是�ƈ不强制子�c�d��行共享，因此�q��所有的享元对象都是可以�׃�n的�?/font>

具体享元(ConcreteFlyweight)角色�Q�实现抽象��n元角色所规定的接口。如果有内蕴状态的话，必须负责为内蕴状态提供存储空间。��n元对象的内蕴状态必��M��对象所处的周围环境无关�Q�从而��得��n元对象可以在�pȝ��内共享。有时候具体��n元角色又叫做单纯具体享元角色�Q�因为复合��n元角色是由单�U�具体��n元角色通过复合而成的�?/font>

复合享元(UnsharableFlyweight)角色�Q�复合��n元角色所代表的对象是不可以共享的�Q�但是一个复合��n元对象可以分解成为多个本�w�是单纯享元对象的组合。复合��n元角色又�U�做不可�׃�n的��n元对象。这个角色一般很��用�?/font>

享元工厂(FlyweightFactoiy)角色�Q�本角色负责创徏和管理��n元角艌Ӏ�本角色必须保证享元对象可以被系�l�适当地共享。当一个客��L(f��ng)��对象��h��一个��n元对象的时候，享元工厂角色需要检查系�l�中是否已经有一个符合要求的享元对象�Q�如果已�l�有了，享元工厂角色��应当提供这个已有的享元对象�Q�如果系�l�中没有一个适当的��n元对象的话，享元工厂角色��应当创��Z��个新的合适的享元对象�?/font>

客户�?Client)角色�Q�本角色�q�需要自行存储所有��n元对象的外蕴状态�?/font>

四、一个例�?/font>

import java.util.Hashtable;

/**
*
* @author flustar
* @version 1.0
* Creation date: Jan 25, 2008 1:33:49 PM
*/

// "Flyweight"

abstract class Character
{
    protected char symbol;
    protected int width;
    protected int height;
    protected int ascent;
    protected int descent;
    protected int pointSize;

public abstract void Display(int pointSize);
}

// "ConcreteFlyweight"

class CharacterA extends Character
{
    // Constructor
    public CharacterA()
    {
      this.symbol = 'A';
      this.height = 100;
      this.width = 120;
      this.ascent = 70;
      this.descent = 0;
    }

    public void Display(int pointSize)
    {
      this.pointSize = pointSize;
     System.out.println(this.symbol +
        " (pointsize " + this.pointSize + ")");
    }
}

// "ConcreteFlyweight"

class CharacterB extends Character
{
    // Constructor
    public CharacterB()
    {
      this.symbol = 'B';
      this.height = 100;
      this.width = 140;
      this.ascent = 72;
      this.descent = 0;
    }

    public void Display(int pointSize)
    {
      this.pointSize = pointSize;
     System.out.println(this.symbol +
        " (pointsize " + this.pointSize + ")");
    }

}

// C, D, E, etc.

// "ConcreteFlyweight"

class CharacterZ extends Character
{
    // Constructor
    public CharacterZ()
    {
      this.symbol = 'Z';
      this.height = 100;
      this.width = 100;
      this.ascent = 68;
      this.descent = 0;
    }

    public void Display(int pointSize)
    {
      this.pointSize = pointSize;
      System.out.println(this.symbol +
        " (pointsize " + this.pointSize + ")");
    }
}
// "FlyweightFactory"

class CharacterFactory
{
private Hashtable characters = new Hashtable();

    public Character GetCharacter(char key)
    {
      // Uses "lazy initialization"
      Character character = (Character)characters.get(key);
      if (character == null)
      {
        switch (key)
        {
          case 'A': character = new CharacterA(); break;
          case 'B': character = new CharacterB(); break;
            //
          case 'Z': character = new CharacterZ(); break;
        }
        characters.put(key, character);
      }
      return character;
    }
}
// test application
public class Test
{
    public static void main(String []args)
    {
      // Build a document with text
      String document = "AAZZBBZB";
      char[] chars = document.toCharArray();

CharacterFactory f = new CharacterFactory();

// extrinsic state
int pointSize = 10;

      // For each character use a flyweight object
      for(char c : chars)
      {
        pointSize++;
        Character character = f.GetCharacter(c);
        character.Display(pointSize);
      }
    }
}

五�?适用�?/p>

Flyweight模式的有效性很大程度上取决于如何��用它以及(qi��ng)在何处��用它。当以下情况都成立时使用Flyweight模式�?/p>

1�Q�一个应用程序��用了大量的对象�?/p>

2�Q�完全由于��用大量的对象�Q�造成很大的存储开销�?/p>

3�Q�对象的大多数状态都可变为外部状态�?/p>

4�Q�如果删除对象的外部状态，那么可以用相对较?y��u)��的�׃�n对象取代很多�l�对象�?/p>

5�Q�应用程序不依赖对象标识�?/p>

六、优�~�点

1�Q��n元模式��得系�l�更加复杂。�ؓ(f��)了��对象可以�׃�n�Q�需要将一些状态外部化�Q�这使得�E�序的逻辑复杂化�?

2�Q��n元模式将享元对象的状态外部化�Q�而读取外部状态��得运行时间稍微变�ѝ�?br />

Eric_jiang 2010-09-09 11:13 发表评论

�l�合模式

Eric_jiang — Thu, 09 Sep 2010 02:59:00 GMT

设计模式之Composite(�l�合)

Composite定义:
��对象以�?w��i)�Ş�l�构�l�织��h��,以达�?#8220;部分�Q�整�?#8221; 的层�ơ结构，使得客户端对单个对象和组合对象的使用��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��
　　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��?
　　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模式的实�?

我们再看看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?/p>

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�合体内的部件方�? 增加删除遍历.

�? ��试�E�序与源�E�序的组�l�结构，“分离但等�?#8221;原则
�? junit.jar加入到classpath中，可以被javac��d��扑ֈ��Q�但不能j(lu��)ava��d��识别�?/p>

junit与ant构徏工具的集�?/p>

如果junit��d��下面没有讄��子元素，那将无法打印��l�的信息�?br /> 一个junit��d��下可以有多个子元�?的usefile属性决定是否生成文件�?br /> junitreport��d��首先把多个test-....xml文�g合�ƈ成一个汇�ȝ��xml文�g�Q�其todir属性指定该文�g的存储目�?其report子元素用于指定生成的html文�g的目录。在用junitreport之前�Q�要��心junit的haltonfaiure�?/p>

batchtest指定的java源文件或class文�g�Q�而不是要�q�行的测试类名称�Q�junit从这些文件中扑և�要运行的��试�c�d��?/p>

�? junit与ant构徏工具的集成的例子,

Eric_jiang 2010-09-09 10:59 发表评论

Eric_jiang — Thu, 09 Sep 2010 02:08:00 GMT

一、要完成的�Q�?/font>

此系�l�中的三个部分是气象站（获取实际气象数据的物理装�|�）、WeatherData对象�Q�追�t�来自气象站的数据，�q�更新布告板�Q�和布告板（昄��目前天气状况�l�用��L(f��ng)��Q��?/font>

二、Observer模式

1、定义观察者模�?/font>

观察者模式定义了对象之间的一对多依赖�Q�这样一来，当一个对象改变状态时�Q�它的所有依赖者都�?x��)收到通知�q�自动更新�?/font>

2.设计气象�?/font>

三、代码实�?/p>

1�Q�定义接�?/p>

�Q?�Q�Subject接口

Subject.java

package com.leanhuadeng.DesignPattern.Observer;

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

�Q?�Q�Observer接口

Observer.java
package com.leanhuadeng.DesignPattern.Observer;

public interface Observer {
public void update(float temp,float humidity,float pressure);
}

�Q?�Q�Displayment接口

Displayment.java

package com.leanhuadeng.DesignPattern.Observer;

public interface Displayment {
public void display();
}

2�Q�实现接�?/p>

�Q?�Q�WeatherData

WeatherData.java

package com.leanhuadeng.DesignPattern.Observer;

import java.util.ArrayList;

public class WeatherData implements Subject {
    private ArrayList observers;
    private float temperature;
    private float humidity;
    private float pressure;

    public WeatherData(){
        observers=new ArrayList();
    }

    public void notifyObservers() {
        for(int i=0;i             Observer observer=(Observer)observers.get(i);
            observer.update(temperature, humidity, pressure);
        }
    }

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

    public void removeObserver(Observer o) {
        int i=observers.indexOf(o);
        if(i>=0){
            observers.remove(i);
        }
    }
    public void measurementsChanged(){
        notifyObservers();
    }
    public void setMeasurements(float temperature,float humidity,float pressure){
        this.temperature=temperature;
        this.humidity=humidity;
        this.pressure=pressure;
        measurementsChanged();
    }
}

�Q?�Q�CurrentConditionsDisplay

CurrentConditionsDisplay.java

package com.leanhuadeng.DesignPattern.Observer;

public class CurrentConditionsDisplay implements Observer, Displayment {
    private float temperature;
    private float humidity;
    private Subject weatherData;

    public CurrentConditionsDisplay(Subject weatherData){
        this.weatherData=weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float temp, float humidity, float pressure) {
        this.temperature=temp;
        this.humidity=humidity;
        display();
    }

    public void display() {
        System.out.println("Current conditions:"+temperature+"F degrees and "+humidity+"% humidity");
    }

}

�Q?�Q�StatisticsDisplay

StatisticsDisplay.java

package com.leanhuadeng.DesignPattern.Observer;

import java.util.*;

public class StatisticsDisplay implements Observer, Displayment {
    private float maxTemp = 0.0f;
    private float minTemp = 200;
    private float tempSum= 0.0f;
    private int numReadings;
    private WeatherData weatherData;

    public StatisticsDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float temp, float humidity, float pressure) {
        tempSum += temp;
        numReadings++;

        if (temp > maxTemp) {
            maxTemp = temp;
        }

        if (temp < minTemp) {
            minTemp = temp;
        }

display();
}

    public void display() {
        System.out.println("Avg/Max/Min temperature = " + (tempSum / numReadings)+ "/" + maxTemp + "/" + minTemp);
    }
}

�Q?�Q�ForecastDisplay

ForecastDisplay.java

package com.leanhuadeng.DesignPattern.Observer;

import java.util.*;

public class ForecastDisplay implements Observer, Displayment {
    private float currentPressure = 29.92f;
    private float lastPressure;
    private WeatherData weatherData;

    public ForecastDisplay(WeatherData weatherData) {
        this.weatherData = weatherData;
        weatherData.registerObserver(this);
    }

    public void update(float temp, float humidity, float pressure) {
                lastPressure = currentPressure;
        currentPressure = pressure;

display();
}

    public void display() {
        System.out.print("Forecast: ");
        if (currentPressure > lastPressure) {
            System.out.println("Improving weather on the way!");
        } else if (currentPressure == lastPressure) {
            System.out.println("More of the same");
        } else if (currentPressure < lastPressure) {
            System.out.println("Watch out for cooler, rainy weather");
        }
    }
}

3�Q�实现气象站

WeatherStation.java

package com.leanhuadeng.DesignPattern.Observer;

public class WeatherStation {
    public static void main(String[] args){
        WeatherData weatherData=new WeatherData();

        CurrentConditionsDisplay currentDisplay=new CurrentConditionsDisplay(weatherData);
        StatisticsDisplay statisticsDisplay = new StatisticsDisplay(weatherData);
        ForecastDisplay forecastDisplay = new ForecastDisplay(weatherData);

        weatherData.setMeasurements(80, 65, 30.4f);
        weatherData.setMeasurements(82, 70, 29.2f);
        weatherData.setMeasurements(78, 90, 29.2f);

    }
}

Eric_jiang 2010-09-09 10:08 发表评论

Eric_jiang — Thu, 09 Sep 2010 01:32:00 GMT

一、要完成的�Q�?/span>

星巴兹（Starbuzz�Q�是以扩张速度最快而闻名的咖啡�q�锁店。如果你在街角看到它的店�Q�在寚w��街上肯定�q�会(x��)看到另一家。因为扩张速度实在太快了，他们准备更新订单�pȝ��Q�以合乎他们的饮料供应要求。他们原先的�c�设计是�q�样�?#8230;…

购买咖啡�Ӟ��也可以要求在其中加入各种调料�Q�例如：(x��)蒸奶�Q?/span>Steamed Milk�Q�、豆��（Soy�Q�、摩卡（Mocha�Q�也��是巧克力风呻I��或覆盖奶泡。星巴兹�?x��)根据所加入的调料收取不同的费用。所以订单系�l�必��考虑到这些调料部分�?/span>

二、Decorator模式

1、一个原�?/font>

�c�d��该对扩展开放，对修改关�?/font>

2、定义装饰者模�?/font>

装饰者模式动态地��责任附加到对象上。若要扩展功能，装饰者提供了比��承更有弹性的替代�Ҏ(gu��)��?br />

3.分析��d��

4.设计��d��

三、代码实�?/font>

1�Q�定义抽象类

�Q?�Q�饮料抽象类Beverage

Beverage.java

package com.leanhuadeng.DesignPattern.Decorator;

/*
* Beverage是一个抽象类,有两个方�?br /> */
public abstract class Beverage {
        public String description="Unknown Beverage";

        /*
         * getDescription()已经在此实现�?但是cost()必须在子�c�M��实现
         */
        public String getDescription() {
            return description;
        }

        public abstract double cost();
}

三、代码实�?br />
(2)调料抽象�c�CondimentDecorator
CondimentDecorator.java
package com.leanhuadeng.DesignPattern.Decorator;
/*
* 首先,必须让CondimentDecorator能够取代Beverage,所以将CondimentDecorator扩展自Beverage�c?br /> */
public abstract class CondimentDecorator extends Beverage {

//所有的调料装饰者都必须重新实现getDescription()�Ҏ(gu��)��.
public abstract String getDescription();
}

2�Q�饮料实�?/font>

(1)Espresso

Espresso.java

package com.leanhuadeng.DesignPattern.Decorator;

/**//*
* 首先,必须让CondimentDecorator能够取代Beverage,所以将CondimentDecorator扩展自Beverage�c?br /> */
public abstract class CondimentDecorator extends Beverage {

//所有的调料装饰者都必须重新实现getDescription()�Ҏ(gu��)��.
public abstract String getDescription();
}

(2)HouseBlend

HouseBlend.java

package com.leanhuadeng.DesignPattern.Decorator.drink;

import com.leanhuadeng.DesignPattern.Decorator.Beverage;

public class HouseBlend extends Beverage {


    public HouseBlend() {
        description="House Blend Coffee";
    }

    @Override
    public double cost() {
        return 0.89;
    }

}

(3)DarkRoast

DarkRoast.java

package com.leanhuadeng.DesignPattern.Decorator.drink;

import com.leanhuadeng.DesignPattern.Decorator.Beverage;

public class DarkRoast extends Beverage {


    public DarkRoast() {
        description="Dark Roast Coffee";
    }

    @Override
    public double cost() {
        return 0.99;
    }
}

(4)Decaf

Decaf.java

package com.leanhuadeng.DesignPattern.Decorator.drink;

import com.leanhuadeng.DesignPattern.Decorator.Beverage;

public class Decaf extends Beverage {


    public Decaf() {
        description="Decaf Coffee";
    }

    @Override
    public double cost() {
        return 1.05;
    }
}

3�Q�调料实�?/font>

(1)Mocha

Mocha.java

package com.leanhuadeng.DesignPattern.Decorator.condiment;

import com.leanhuadeng.DesignPattern.Decorator.Beverage;
import com.leanhuadeng.DesignPattern.Decorator.CondimentDecorator;

public class Mocha extends CondimentDecorator {
    /*
     * 要让Mocha能够引用一个Beverage,做法如下:一是用一个实例变量记录饮�?也就是被装饰�?
     * 二是惛_��法让装饰�?饮料)记录到实例变量中,��x��饮料当作构造器的参�?再由构造器��此饮料记录在实例变量中
     */
    Beverage beverage;

    public Mocha(Beverage beverage) {
        this.beverage = beverage;
    }

    @Override
    public String getDescription() {
        /*
         * 我们希望叙述不只是描�q�饮�?而是完整的连调料都描�q�出�?br />          */
        return beverage.getDescription()+",Mocha";
    }

    @Override
    public double cost() {
        /*
         * 要计��带Mocha饮料的�h(hu��n)�?首先把调用委托给装饰对象,以计��h(hu��n)�?然后再加上Mocha的�h(hu��n)�?得到最后结�?br />          */
        return 0.20+beverage.cost();
    }
}

(2)Soy

Soy.java

package com.leanhuadeng.DesignPattern.Decorator.condiment;

import com.leanhuadeng.DesignPattern.Decorator.Beverage;
import com.leanhuadeng.DesignPattern.Decorator.CondimentDecorator;

public class Soy extends CondimentDecorator {
Beverage beverage;

    public Soy(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Soy";
    }

    public double cost() {
        return .15 + beverage.cost();
    }
}

(3)Whip

Whip.java

package com.leanhuadeng.DesignPattern.Decorator.condiment;

import com.leanhuadeng.DesignPattern.Decorator.Beverage;
import com.leanhuadeng.DesignPattern.Decorator.CondimentDecorator;

public class Whip extends CondimentDecorator {
    Beverage beverage;

    public Whip(Beverage beverage) {
        this.beverage = beverage;
    }

    public String getDescription() {
        return beverage.getDescription() + ", Whip";
    }

    public double cost() {
        return .10 + beverage.cost();
    }
}

4�Q�测试类StarbuzzCoffee

StarbuzzCoffee.java

package com.leanhuadeng.DesignPattern.Decorator;

import com.leanhuadeng.DesignPattern.Decorator.condiment.Mocha;
import com.leanhuadeng.DesignPattern.Decorator.condiment.Soy;
import com.leanhuadeng.DesignPattern.Decorator.condiment.Whip;
import com.leanhuadeng.DesignPattern.Decorator.drink.DarkRoast;
import com.leanhuadeng.DesignPattern.Decorator.drink.Espresso;
import com.leanhuadeng.DesignPattern.Decorator.drink.HouseBlend;

public class StarbuzzCoffee {
    public static void main(String args[]){
        /*
         * 订一杯Espresso,不需要调�?打印出它的描�q�和价钱.
         */
        Beverage beverage=new Espresso();
        System.out.println(beverage.getDescription()+" $"+beverage.cost());

        /*
         * 刉��一个DarkRoast对象,用Mocha,Whip装饰�?br />          */
        Beverage beverage2=new DarkRoast();
        beverage2=new Mocha(beverage2);
        beverage2=new Mocha(beverage2);
        beverage2=new Whip(beverage2);
        System.out.println(beverage2.getDescription()+" $"+beverage2.cost());

        /*
         * 最�?再来一杯调料�ؓ(f��)豆浆,摩卡\奶��的HouseBlend咖啡
         */
        Beverage beverage3=new HouseBlend();
        beverage3=new Soy(beverage3);
        beverage3=new Mocha(beverage3);
        beverage3=new Whip(beverage3);
        System.out.println(beverage3.getDescription()+" $"+beverage3.cost());
    }
}

Eric_jiang 2010-09-09 09:32 发表评论