第七讲:建造者模式

Product:House

Builder:HouseBuilder(工程队)

ConcreteBuilder:PingFangBuilder、GongyuBuilder

Director:组合的模式,包含Builder,包含工程队,由Director来指使工程队做事.组合不是聚合,Director包含了Builder.

construct()是建造方法,不是构造函数.就是Director的makeHouse()方法.

演变的过程:自己做->工程队做->设计师做.

客户端代码越来越少越来越简洁.



工厂:GongyuBuidler、PingFangBuilder


public class GongyuBuilder implements HouseBuilder{
    House house = new House();
    @Override
    public void makeFloor() {
        // TODO Auto-generated method stub
        house.setFloor("公寓-->地板");
    }

    @Override
    public void makeWall() {
        // TODO Auto-generated method stub
        house.setWall("公寓-->墙");
    }

    @Override
    public void makeHousetop() {
        // TODO Auto-generated method stub
        house.setHousetop("公寓-->房顶");
    }

    @Override
    public House getHouse() {
        // TODO Auto-generated method stub
        return house;
    }

}
/*
 * 房子
 *
 */
public class House {
      //地板
    private String floor;//复合属性可能是其它类的对象.这里做简单一些
      //墙
    private String wall;
      //屋顶
    private String housetop;
    public String getFloor() {
        return floor;
    }
    public void setFloor(String floor) {
        this.floor = floor;
    }
    public String getWall() {
        return wall;
    }
    public void setWall(String wall) {
        this.wall = wall;
    }
    public String getHousetop() {
        return housetop;
    }
    public void setHousetop(String housetop) {
        this.housetop = housetop;
    }

}
//工人有很多种.有些是修公寓的,有些是修其他的.
/*
 *  工程队
 */
public interface HouseBuilder {
     //修地板
    public void makeFloor();
    // 修墙
    public void makeWall();
    //修屋顶
    public void makeHousetop();

    public House getHouse();
}
public class HouseDirector {
   //private HouseBuilder builder;

/*public HouseDirector(HouseBuilder builder) {
    super();
    this.builder = builder;
}*/
   //有些书籍不在HouseDirector的构造函数中传递buidler(工程队)的引用
//public void makeHouse(){
    public void makeHouse(HouseBuilder builder){//第二种方式在方法中传递builder
    //第二种方式更加规范,第一种方式不是错的,但是耗费资源,因为builder完全没有必要做成一个属性.
    //在方法里面做接收builder就可以了,做成属性比较耗资源.

        /*this.builder.makeFloor();
    this.builder.makeHousetop();
    this.builder.makeWall();*/
        builder.makeFloor();
        builder.makeHousetop();
        builder.makeWall();
}
/*public HouseBuilder getBuilder() {
    return builder;
}

public void setBuilder(HouseBuilder builder) {
    this.builder = builder;
}
  */
}
//客户端要修建一个房子
public class MainClass {
    public static void main(String[] args) {
        //客户直接修造房子
/*        House house = new House();
        house.setFloor("地板");
        house.setWall("墙");
        house.setHousetop("屋顶");*/
        //原本是修平房,现在改成修公寓了,要把这些属性都改掉.
        //这种方式的话又要直接修改客户端,而且对象的创建细节全部放在客户那里.
        //客户亲自去修.

        //一般是:客户->开发商->工人

        //由工程队来修
        //HouseBuilder builder = new PingFangBuilder();
        HouseBuilder builder = new GongyuBuilder();
        //调用工程队来修.
/*builder.makeFloor();
builder.makeWall();
builder.makeHousetop();*/
        //由设计者调用工程队来做
        //HouseDirector director = new HouseDirector(builder);
        HouseDirector director = new HouseDirector();
        //以后学了反射之后动态控制加载哪一个工程队,更加方便了,客户端无需修改了.
        //只需要添加一个新的builder就可以了.
        //director.makeHouse();
        director.makeHouse(builder);
        House house = builder.getHouse();
System.out.println(house.getFloor());
System.out.println(house.getWall());
System.out.println(house.getHousetop());
    }
}
//修平房的工人,实现修房子这个接口.
/*
 * 平房工程队
 */
public class PingFangBuilder implements HouseBuilder{
    House house = new House();
    @Override
    public void makeFloor() {
        // TODO Auto-generated method stub
        house.setFloor("平房-->地板");//builder建筑者为你修房子
    }

    @Override
    public void makeWall() {
        // TODO Auto-generated method stub
        house.setWall("平房-->墙");
    }

    @Override
    public void makeHousetop() {
        // TODO Auto-generated method stub
        house.setHousetop("平房-->房顶");
    }

    @Override
    public House getHouse() {
        // TODO Auto-generated method stub
        return house;
    }

}
时间: 2024-11-10 11:12:50

第七讲:建造者模式的相关文章

好菜每回味不同—建造者模式

<大话设计模式>中讲建造者模式(Builder Pattern)引用一个例子:麦当劳.肯德基的汉堡不管在哪家店里吃,什么时间时间去吃,至少在中国,味道基本都是一样.而那道“鱼香肉丝”几乎是所有大小中餐馆饭店都有的一道菜,但却可以吃出万种口味来,这是为什么呢? 建造者模式(Builder Pattern):将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 建造者模式(Builder Pattern)结构图 Builder是为了创建一个Product对象的各个部件指定的抽

浅析设计模式(七)——创建型模式之Builder(建造者模式)

建造者模式Builder 本文的内容: 一.建造者模式的定义 二.建造者模式的参与者及其角色 三.建造者模式的类图 四.建造者模式的示例 五.参考 一.建造者模式的定义  将一个复杂的对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 可以理解为对象的分步构建或者逐步完善. 二.建造者模式的参与者及其角色 1. Builder: 为创建一个产品对象的各个部件指定抽象接口. 2. ConcreteBuilder: 实现Builder的接口以构造和装配该产品的各个部件. 定义并明确它所

一段对话讲完建造者模式

截止今天,小秋学习Java刚刚满三个月.此刻的小秋感觉自己Java学的还不错,想去帅地面前炫耀一番,于是,就发生了一下一番对话-.. 得意的小秋 帅地:嗨,小秋,看你今天气色不错啊.最近Java学的怎么样了? 小秋:说实话,比起三个月前我学指针的那段日子,这Java太友好了,感觉就是分分种的事(暗自得意). 帅地:我靠,你这口气还挺大啊.从c的面向过程到Java的面向对象,还习惯不? 小秋:哎,还行,无非就是"一切皆对象",Java中的对象感觉类似于C中的结构体.反正不过三七二十一,我

设计模式(五) : 创建型模式--建造者模式

建造者模式的意图是将产品的内部表象和产品的生产过程分割开来. 类图: 示意性代码: package com.javadesignpattern.builder; public interface Builder { public void buildPart1(); public void buildPart2(); public Product retrieveProduct(); } ? 1 2 3 4 5 6 7 package com.javadesignpattern.builder;

C# 设计模式巩固笔记 - 建造者模式

前言 写给自己-贵在坚持.建造者模式不复杂,但是想个形象的例子好难. 介绍-建造者模式 定义:将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示. 实现 建造者模式主要是应对复杂对象,在之前讲的滑板鞋的例子看上去不是很适合,因为它并不复杂.但是我们把一双鞋子拆分一下:鞋底.鞋带.鞋面 等等.原来它也并不简单,下面通过建造者模式来实现一下造鞋子的流程: 首先是建造者类: /// <summary> /// 建造者基类 /// </summary> public

建造者模式(11)

今天,我们来讲一下建造者模式. 一.案例 我们来用winform画一个小人,一个头,一个身体,两只手,两条腿. 我们一般想到的代码如下: 1 /// <summary> 2 /// 画小人 3 /// </summary> 4 /// <param name="sender"></param> 5 /// <param name="e"></param> 6 private void pictu

C#设计模式(5)-建造者模式

引言 上一篇介绍了设计模式中的抽象工厂模式-C#设计模式(3)-抽象工厂模式,本篇将介绍建造者模式: 点击这里查看全部设计模式系列文章导航 建造者模式简介 建造者模式是将一个复杂对象的构建与表示分离,使得同样的构建过程可以创建不同的表示. 在软件系统中,有时候会面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂的对象的各个部分可能面临着剧烈的变化,但是把他们组合在一起的算法很稳定.提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化,从而保持

Java设计模式——建造者模式

建造者模式(Builder Pattern)属于创建形的设计模式,使用多个简单的对象一步一步构建成一个复杂的对象. 主要解决:主要解决在软件系统中,有时候面临着"一个复杂对象"的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法却相对稳定. 何时使用:一些基本部件不会变,而其组合经常变化的时候. 应用实例: 1.去肯德基,汉堡.可乐.薯条.炸鸡翅等是不变的,而其组合是经常变化的,生成出所谓的&quo

Android设计模式--建造者模式

回头看自己写的东西,在关于Android自定义控件时,写的代码适用性比较高,但是看上去没有什么技术含量,所以在学习设计模式的时候,想想有些东西是否能够改进,比如说: 自定义Dialog是Android应用必须的,系统的控件实在是太难看了: 在构建中,完全是,new完对象之后,需要什么构建什么,这样写没有问题,可读性也还行,就是看上去不咋的. 以下是小部分代码片段: package com.example.demo.Builder; /** * * @author qubian * @data 2

一天一个设计模式——Builder建造者模式

一.模式说明 在现实世界中,当我们要构造一个大型工程时(建一个大楼),通常的做法是先建造工程的每个独立部分,然后再逐步构造完成(先打地基,再搭框架,最后逐层累造).在程序设计领域,构造一个复杂的类时(或一些具有类似结构的复杂类时),也可以采用类似的思想:如果要创建一个用于构造文档的类(或者是word,或者是html),虽然具体的文档有不同的结构,但是构造这些对象有相同的套路:创建标题,创建内容,创建条目,结束文档.Builder建造者模式就是用来构造复杂的类的. 二.模式类图 三.模式时序图 四