用户操作
[即时聊天] [发私信] [加为好友]
刘晓伟ID:lxwde
167788次访问,排名457好友0人,关注者2
lxwde的文章
原创 27 篇
翻译 34 篇
转载 0 篇
评论 244 篇
最近评论
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--特化创建(Specialized creation)收藏

    新一篇: 翻译TIPatterns--太多(Too many) | 旧一篇: 翻译TIPatterns--封装创建(Encapsulating creation)

    特化创建(Specialized creation)


    原型(Prototype)

        通过克隆某个原型的实例来创建对象。“模式重构(Pattern Refactoring)”一章会给出这种模式的一个例子。


    生成器(Builder)
        Builder模式的目的是为了将对象的构造与它的“表示”(representation)分离开来,这样对象就可以有多个不同的“表示”。对象构造的过程保持不变,但是最终创建的对象可以有不同的表示。GoF指出,Abstract Factory模式与Builder模式的主要区别就在于Builder模式遵循一定的步骤一步步创建对象,这样一来,按照时间顺序创建对象就显得非常重要了。此外,“director”似乎是In addition, it seems that the “director” gets a stream of pieces that it passes to the Builder, and each piece is used to perform one of the steps in the build process.
        GoF给出的一个例子是文本格式转换器。待转换的文本是RTF格式的,当解析文本的时候,解析指令被传给文本转换器,文本转换器根据不同的输出格式(ASCII,TeX,或者“GUI文本工具”)可能有不同的实现。尽管最终生成的“对象”(整个转换后的文件)是over time的???,但是如果把每个RTF格式的转换指令都认为是一个对象,我觉得这更像是Bridge模式,因为某一具体类型的转换器扩展了基类的接口。另外,这个问题通常的解决方案使得前端(front end)可以有多个读取者,而转换器则在后端(back end)工作, 这正是Bridge模式的主要特征。
        在我看来,Builder和常规factory最本质的区别在于,Builder用多个步骤来创建对象,而且这些步骤对于Builder对象来说都是外部的。但是,GoF 强调的是(通过Builder)你可以用同样的步骤创建不同的对象实体(representations)。他们从未说明“representation”到底指什么。(难道说“representation”是指过大的对象? 那么,如果对象实体被分割成小的对象,是否就不需要使用Builder了呢?)

        GoF 还给出了另外一个例子,创建迷宫对象,在迷宫内部添加房间,给房间加上门。这是一个需要多部完成的过程,但是,所谓不同的 “对象实体(representations)”,也就是是“常规的(standard)”和“复杂的(complex)”迷宫――实际上并不是说它们是不同类型的迷宫,而是指它们的复杂程度不一样。换了是我的话,我想我会试图创建一个迷宫构造器(maze builder)用它来创建任意复杂度的迷宫。Maze builder的最终变体其实根本就不创建迷宫对象了,它只是计算现有迷宫所包含的房间数量。

        RFT转换器和迷宫构造器这两个例子都不是讲解Builder模式的非常有说服力的例子。有读者建议说Sax的XML解析器,或者是标准的编译器解析器可能更适合用来说明Builder模式。

        下面这个例子可能比较适合用来说明Builder模式,至少它更能说明Builder模式的意图。我们可能会把媒体(media)创建为不同的表现形式,本例中可能是书籍,杂志或者网站。这个例子主要说明创建对象的步骤是相同的,这样它们才可以被抽象到director类里。


    //: builder:BuildMedia.java

    // Example of the Builder pattern

    package builder;

    import java.util.*;

    import junit.framework.*;

     

    // Different "representations" of media:

    class Media extends ArrayList {}

    class Book extends Media {}

    class Magazine extends Media {}

    class WebSite extends Media {}

     

    // ... contain different kinds of media items:

    class MediaItem {

      private String s;

      public MediaItem(String s) { this.s = s; }

      public String toString() { return s; }

    }

    class Chapter extends MediaItem {

      public Chapter(String s) { super(s); }

    }

    class Article extends MediaItem {

      public Article(String s) { super(s); }

    }

    class WebItem extends MediaItem {

      public WebItem(String s) { super(s); }

    }

     

    // ... but use the same basic construction steps:

    class MediaBuilder {

      public void buildBase() {}

      public void addMediaItem(MediaItem item) {}

      public Media getFinishedMedia() { return null; }

    }

     

    class BookBuilder extends MediaBuilder {

      private Book b;

      public void buildBase() {

        System.out.println("Building book framework");

        b = new Book();

      }

      public void addMediaItem(MediaItem chapter) {

        System.out.println("Adding chapter " + chapter);

        b.add(chapter);

      }

      public Media getFinishedMedia() { return b; }

    }  

     

    class MagazineBuilder extends MediaBuilder {

      private Magazine m;

      public void buildBase() {

        System.out.println("Building magazine framework");

        m = new Magazine();

      }

      public void addMediaItem(MediaItem article) {

        System.out.println("Adding article " + article);

        m.add(article);

      }

      public Media getFinishedMedia() { return m; }

    }  

     

    class WebSiteBuilder extends MediaBuilder {

      private WebSite w;

      public void buildBase() {

        System.out.println("Building web site framework");

        w = new WebSite();

      }

      public void addMediaItem(MediaItem webItem) {

        System.out.println("Adding web item " + webItem);

        w.add(webItem);

      }

      public Media getFinishedMedia() { return w; }

    }  

     

    class MediaDirector { // a.k.a. "Context"

      private MediaBuilder mb;

      public MediaDirector(MediaBuilder mb) {

        this.mb = mb; // Strategy-ish

      }

      public Media produceMedia(List input) {

        mb.buildBase();

        for(Iterator it = input.iterator(); it.hasNext();)

          mb.addMediaItem((MediaItem)it.next());

        return mb.getFinishedMedia();

      }

    };

     

    public class BuildMedia extends TestCase {

      private List input = Arrays.asList(new MediaItem[] {

        new MediaItem("item1"), new MediaItem("item2"),

        new MediaItem("item3"), new MediaItem("item4"),

      });

      public void testBook() {

        MediaDirector buildBook =

          new MediaDirector(new BookBuilder());

        Media book = buildBook.produceMedia(input);

        String result = "book: " + book;

        System.out.println(result);

        assertEquals(result,

          "book: [item1, item2, item3, item4]");

      }

      public void testMagazine() {

        MediaDirector buildMagazine =

          new MediaDirector(new MagazineBuilder());

        Media magazine = buildMagazine.produceMedia(input);

        String result = "magazine: " + magazine;

        System.out.println(result);

        assertEquals(result,

          "magazine: [item1, item2, item3, item4]");

      }

      public void testWebSite() {

        MediaDirector buildWebSite =

          new MediaDirector(new WebSiteBuilder());

        Media webSite = buildWebSite.produceMedia(input);

        String result = "web site: " + webSite;

        System.out.println(result);

        assertEquals(result,

          "web site: [item1, item2, item3, item4]");

      }

      public static void main(String[] args) {

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

      }

    } ///:~

     


        注意到,从某种角度来说上面这个例子也可以看成是比较复杂的State模式,因为director的行为取决于你所使用的builder的具体类型。Director不是简单的将请求传递给下层的State对象,而是把State对象当作一个Policy对象来使用,最终自己来完成一系列的操作。这么以来,Builder模式就可以被描述成使用某种策略来创建对象。

     

    练习:
    1.将一个文本文件作为一系列单词读入(an input stream of words),考虑使用正则表达式。写一个Builder将这些单词读入到一个java.util.TreeSet,然后再写一个Builder创建一个java.util.HashMap用来保存单词和它出现的次数(也就是统计单词出现的次数)。

     

    目录

     

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

    新一篇: 翻译TIPatterns--太多(Too many) | 旧一篇: 翻译TIPatterns--封装创建(Encapsulating creation)

    评论:没有评论。

    发表评论  


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