lxwde
最近评论
mldstk:wow power leveling
lshvs2006:你好,你設計的東東非常不錯。
但是,現在有個疑問,不知道,怎樣保存設計的文件,
存成XML 文件格式可能會好一點,但是,不知道如何去存? 需要調用什么接口 或是 需要寫什么 方法嗎?

期待您的指教。謝謝

lsh2011@163.com
zeeler:补上这一部分吧(本人中文表述能力没有lxwde强哦 :) ):
The Singleton
也许最简单的设计模式是Singleton模式了,它可以给某种类型提供唯一的对象,下面是个例子:
(译者按:例子省略)
创建一个唯一对象的关键是防止客户程序员(client programmer)用其他任意方法创建对象,只能用你提供的方法。你必须把所有构造器写成p……
zeeler:翻译的不错呀,全力支持!
不过在Design principles和Classifying patterns之间还有个The Singleton部分好像lxwde漏掉了?还是Bruce Eckel修改版面了?
总之,支持呀,本来我也想翻译一下的,不过没有lxwde这么有毅力,翻译一节就停了,实在很累的,所以非常敬佩lxwde能坚持做这么多!
roger_77:可惜,
这个库被boost放弃了,加入另一个ASIO的网络类库
文章分类
收藏
    相册
    链接
    My articles on codeproject
    SharpFormEditor下载
    Thinking in Patterns中文版
    友情链接
    alai04
    C++的罗浮宫
    fatalerror99
    存档
    软件项目交易
    订阅我的博客
    XML聚合  FeedSky
    订阅到鲜果
    订阅到Google
    订阅到抓虾
    订阅到BlogLines
    订阅到Yahoo
    订阅到GouGou
    订阅到飞鸽
    订阅到Rojo
    订阅到newsgator
    订阅到netvibes

    翻译 翻译TIPatterns--封装创建(Encapsulating creation)收藏

    新一篇: 翻译TIPatterns--特化创建(Specialized creation) | 旧一篇: 翻译TIPatterns--分解共同性(Factoring Commonality)

    封装创建(Encapsulating creation)


        当你发现需要向某个系统添加一些新类型的时候,最明智的做法就是先利用多态(polymorphism)为这些新类型创建一个公共接口。这可以使系统其余部分的代码与新加入的那些特定类型相分离。加入新的类型可能并不需要更改现有的代码。。。或者至少看上去不需要。初看起来,如果你用上面说的这种设计方法修改代码,那么唯一需要改动的就是继承新类型的地方,但事实上并非完全如此。你仍然需要创建新类型的对象,而且在创建的地方你必须指定用哪个构造函数。因此,如果用于创建对象的那部分代码分散在整个程序里(添加新类型的时候你会面临这个问题),你仍然需要找出所有与类型相关的代码。这种情况下,主要的问题是新类型(对象)的创建而不是新类型的使用(这个问题可以用多态来解决),但实际效果是一样的:添加一个新类型总会带来问题。
        解决办法是强制使用一个common factory来创建对象,而不允许创建对象的代码分散在整个系统里。如果所有需要创建对象的那些代码都借助于这个工厂(factory)来完成创建,那么添加新类型的时候你需要做的只是修改这个工厂就可以了。
        因为所有面向对象的代码都会用到创建对象,而且大多数情况下你会通过添加新的类型来扩展程序,所以我猜想factory模式(系列)可能是最广泛使用的设计模式。
        尽管只有简单工厂方法(Simple Factory Method)才是真正意义上的单件(Singleton),但你会发现每一个特定的工厂类(这些类属于更为通用的factory模式)实际上都只有一个实例。

     


    简单工厂方法(Simple Factory method)

        我们用下面的例子,重温一下Shape系统。
        (实现factory模式)常用的方法是把factory声明为基类的静态方法(static method)。

    //: factory:shapefact1:ShapeFactory1.java

    // A simple static factory method.

    package factory.shapefact1;

    import java.util.*;

    import junit.framework.*;

     

    abstract class Shape {

     public abstract void draw();

     public abstract void erase();

     public static Shape factory(String type) {

      if(type.equals("Circle")) return new Circle();

      if(type.equals("Square")) return new Square();

      throw new RuntimeException(

       "Bad shape creation: " + type);

     }

    }

     

    class Circle extends Shape {

     Circle() {} // Package-access constructor

     public void draw() {

      System.out.println("Circle.draw");

     }

     public void erase() {

      System.out.println("Circle.erase");

     }

    }

     

    class Square extends Shape {

     Square() {} // Package-access constructor

     public void draw() {

      System.out.println("Square.draw");

     }

     public void erase() {

      System.out.println("Square.erase");

     }

    }

     

    public class ShapeFactory1 extends TestCase  {

     String shlist[] = { "Circle", "Square",

      "Square", "Circle", "Circle", "Square" };

     List shapes = new ArrayList();

     public void test() {

      Iterator it = Arrays.asList(shlist).iterator();

      while(it.hasNext())

       shapes.add(Shape.factory((String)it.next()));

      it = shapes.iterator();

      while(it.hasNext()) {

       Shape s = (Shape)it.next();

       s.draw();

       s.erase();

      }

     }

     public static void main(String args[]) {

      junit.textui.TestRunner.run(ShapeFactory1.class);

     }

    } ///:~

     


        factory() 方法需要传入一个参数来决定要创建的Shape的具体类型; 在上面的例子里(参数)碰巧是一个字符串(String),它也可以是其它任意类型。当加入新的Shape类型的时候(我们假定被创建对象的初始化代码是来自系统以外的,而不是像上面那个例子使用一个硬编码(hard-coded)的数组),系统唯一需要改动的代码就是factory()方法。为了促使创建对象的代码只包含在factory()方法里,特定类型的Shape类的构造函数都被声明为package权限,这样一来只有factory()方法可以调用这些构造函数,而位于包(package)以外的那部分代码则没有足够的权限(调用这些构造函数)。

     

     

    多态工厂(Polymorphic factories)
       上例中,静态的factory()方法使得所有创建对象的操作都集中在一个地方完成,这也就是唯一需要你修改代码的地方。这当然是一个还算不错的的解决办法,它封装了创建对象的过程。然而,《设计模式》强调使用Factory Method是为了使不同类型的工厂可以由基本类型的工厂派生(subclass)出来(上面例子是一个特例)。但是,那本书没有给出具体例子,只是重复了用于说明抽象工厂(Abstract Factory)的那个例子(你会在本书下一节看到一个Abstract Factory的例子)。下面的例子,我们修改了ShapeFactory1.java使得工厂方法成为一个单独的类的虚函数。请注意,特定类型的Shape类是根据需要动态加载的。

    //: factory:shapefact2:ShapeFactory2.java

    // Polymorphic factory methods.

    package factory.shapefact2;

    import java.util.*;

    import junit.framework.*;

     

    interface Shape {

     void draw();

     void erase();

    }

     

    abstract class ShapeFactory {

     protected abstract Shape create();

     private static Map factories = new HashMap();

     public static void

      addFactory(String id, ShapeFactory f) {

       factories.put(id, f);

      }

      // A Template Method:

      public static final

       Shape createShape(String id) {

        if(!factories.containsKey(id)) {

         try {

          // Load dynamically

          Class.forName("factory.shapefact2." + id);

         } catch(ClassNotFoundException e) {

          throw new RuntimeException(

           "Bad shape creation: " + id);

         }

         // See if it was put in:

         if(!factories.containsKey(id))

          throw new RuntimeException(

          "Bad shape creation: " + id);

        }

        return

         ((ShapeFactory)factories.get(id)).create();

       }

    }

     

    class Circle implements Shape {

     private Circle() {}

     public void draw() {

      System.out.println("Circle.draw");

     }

     public void erase() {

      System.out.println("Circle.erase");

     }

     private static class Factory

      extends ShapeFactory {

       protected Shape create() {

        return new Circle();

       }

      }

      static {

       ShapeFactory.addFactory(

        "Circle", new Factory());

      }

    }

     

    class Square implements Shape {

     private Square() {}

     public void draw() {

      System.out.println("Square.draw");

     }

     public void erase() {

      System.out.println("Square.erase");

     }

     private static class Factory

      extends ShapeFactory {

       protected Shape create() {

        return new Square();

       }

      }

      static {

       ShapeFactory.addFactory(

        "Square", new Factory());

      }

    }

     

    public class ShapeFactory2 extends TestCase  {

     String shlist[] = { "Circle", "Square",

      "Square", "Circle", "Circle", "Square" };

     List shapes = new ArrayList();

     public void test() {

      // This just makes sure it will complete

      // without throwing an exception.

      Iterator it = Arrays.asList(shlist).iterator();

      while(it.hasNext())

       shapes.add(

       ShapeFactory.createShape((String)it.next()));

      it = shapes.iterator();

      while(it.hasNext()) {

       Shape s = (Shape)it.next();

       s.draw();

       s.erase();

      }

     }

     public static void main(String args[]) {

      junit.textui.TestRunner.run(ShapeFactory2.class);

     }

    } ///:~

     


        现在工厂方法(factory method)出现在它自己的类ShapeFactory里,名字改成了create()方法。它是一个受保护的(protected)方法,也就是说它不能被直接调用,但可以被重载。Shape类的子类必须创建与之对应的ShapeFactory的子类,并且通过重载create()函数来创建它自己的实例。实际上一系列Shape对象的创建是通过调用ShapeFactory. createShape( ) 来完成的。 CreateShape()是个静态方法, 它根据传入的标示,通过查找ShapeFactory   的 Map 成员变量找到与之相应的工厂对象 (factory obejct)。 然后,找到的factory对象即被用来创建shape对象,但你可以想象一下更为棘手的问题:(与某种Shape类型相对应的)工厂对象被调用者用来以更为复杂的方式创建对象。但是,大多数情况下你似乎并不需要用到复杂的多态工厂方法(polymorphic factory method),在基类里加一个静态方法(像ShapeFactory1.java 那样)就足以解决问题了。
        注意到,ShapeFactory的初始化必须通过加载Map数据成员才能完成(Map的元素是factory对象),而这些初始化代码又位于Shape实现类的静态初始化语句里。这样一来,每加入一个新的类型你就必须得继承原来的类型(指Shape?),创建一个factory,然后添加静态初始化语句用以加载Map对象。这些额外的复杂性又一次暗示我们:如果不需要创建单独的factory对象,那最好还是使用静态工厂方法。

     

     

    抽象工厂(Abstract factories)
        抽象工厂(abstract factory)模式看起来很像前面我们看到的那些factory对象,只不过它有多个而不是一个factory方法。每一个factory 方法创建一个不同类型的对象。基本思想是:在创建工厂对象的地方,由你来决定如何使用该工厂对象创建的那些对象。《设计模式》里给出的例子实现了在不同用户图形界面(GUIs)之间的可移植性:你根据自己使用的GUI来创建一个与之对应的factory对象,在这以后,当你需要用到菜单,按钮,滚动条这些东西的时候,它会根据你使用的GUI自动创建合适的对象。这样,你就可以把实现不同GUI之间切换的代码分离出来,使它集中在一个地方。

        作为另外一个例子,假设你要创建一个通用的游戏环境,而且你还想要支持不同类型的游戏。下面的例子用抽象工厂给出了它的一种可能的实现。

    //: factory:Games.java

    // An example of the Abstract Factory pattern.

    package factory;

    import junit.framework.*;

     

    interface Obstacle {

     void action();

    }

     

    interface Player {

     void interactWith(Obstacle o);

    }

     

    class Kitty implements Player {

     public void interactWith(Obstacle ob) {

      System.out.print("Kitty has encountered a ");

      ob.action();

     }

    }

     

    class KungFuGuy implements Player {

     public void interactWith(Obstacle ob) {

      System.out.print("KungFuGuy now battles a ");

      ob.action();

     }

    }

     

    class Puzzle implements Obstacle {

     public void action() {

      System.out.println("Puzzle");

     }

    }

     

    class NastyWeapon implements Obstacle {

     public void action() {

      System.out.println("NastyWeapon");

     }

    }

     

    // The Abstract Factory:

    interface GameElementFactory {

     Player makePlayer();

     Obstacle makeObstacle();

    }

     

    // Concrete factories:

    class KittiesAndPuzzles

     implements GameElementFactory {

      public Player makePlayer() {

       return new Kitty();

      }

      public Obstacle makeObstacle() {

       return new Puzzle();

      }

     }

     

     class KillAndDismember

      implements GameElementFactory {

       public Player makePlayer() {

        return new KungFuGuy();

       }

       public Obstacle makeObstacle() {

        return new NastyWeapon();

       }

      }

     

      class GameEnvironment {

       private GameElementFactory gef;

       private Player p;

       private Obstacle ob;

       public GameEnvironment(

        GameElementFactory factory) {

         gef = factory;

         p = factory.makePlayer();

         ob = factory.makeObstacle();

        }

        public void play() { p.interactWith(ob); }

      }

     

      public class Games extends TestCase  {

       GameElementFactory

        kp = new KittiesAndPuzzles(),

        kd = new KillAndDismember();

       GameEnvironment

        g1 = new GameEnvironment(kp),

        g2 = new GameEnvironment(kd);

       // These just ensure no exceptions are thrown:

       public void test1() { g1.play(); }

       public void test2() { g2.play(); }

       public static void main(String args[]) {

        junit.textui.TestRunner.run(Games.class);

       }

      } ///:~

     


        在上面的游戏环境里,Player对象与Obstale对象交互,根据你所选择的游戏类型,player和obstacle的各自类型也会不同。你通过选择某个特定的GameElementFactory来决定游戏的类型,然后GameElementFactory会控制初始化和游戏的进行。在上面的例子里,初始化和游戏的进行都非常简单,但那些活动(初始条件和状态变化)可以在很大程度上决定游戏的结局。这里,GameEnvironment不是用来给其它类继承的 ,尽管那么做很可能也说的通。
        上面的代码也包含了双向分发(Double Dispatching)和工厂方法(Factory Method)两种模式,我们会在后面讲解它们。

     

    练习:
    1. 写一个Triangle(三角形)类,添加到ShapeFactory1.java。
    2. 写一个Triangle(三角形)类,添加到ShapeFactory2.java。
    3. 给GameEnvironment添加新的类型,写一个GnomesAndFairies添加到Games.java。
    4. 改写ShapeFactory2.java,用一个Abstract Factory来创建不同规格(sets)的shapes(比如说,用一个特定类型的工厂对象来创建“thick shapes”,用另外一个工厂对象来创建“thin shapes”,但是每个工厂对象都可以创建所有类型的shapes,包括:circles,squares,triangles等等。)。

     

    目录

     

    发表于 @ 2004年08月10日 09:28:00|评论(loading...)|编辑

    新一篇: 翻译TIPatterns--特化创建(Specialized creation) | 旧一篇: 翻译TIPatterns--分解共同性(Factoring Commonality)

    评论:没有评论。

    发表评论  


    当前用户设置只有注册用户才能发表评论。如果你没有登录,请点击登录
    Csdn Blog version 3.1a
    Copyright © lxwde