大话设计模式第十三章之建造者模式

package com.build;

/**
 * 建造胖子
 * @author 黄二狗
 *
 */
public class PersonFatBuilder {
   public PersonFatBuilder()
   {

   }

    public void build()
    {
        System.out.println("大头");
        System.out.println("大腿");
        System.out.println("粗腰");
    }

}
package com.build;

/**
 * 建造瘦人
 * @author 黄二狗
 *
 */
public class PersonThinBuilder {

    public PersonThinBuilder()
    {

    }

    public void build()
    {
        System.out.println("小头");
        System.out.println("小腿");
        System.out.println("细腰");
    }

}
package com.build;

public class Client {

    //出场
    public static void main(String[] args) {

        //建造胖子
        PersonFatBuilder fatBuild=new PersonFatBuilder();
        //建造瘦子
        PersonThinBuilder thinBuild=new PersonThinBuilder();

        fatBuild.build();
        System.out.println("=========");
        thinBuild.build();
    }
}



上面代码的缺点是流程不够规范 在一个build方法里面还是有可能出错。

package com.build;

public interface  PersonBuilder {

    public abstract void buildHead();
    public abstract void buildBody();
    public abstract void buildArmLeft();
    public abstract void buildArmRight();
    public abstract void buildLegLeft();
    public abstract void buildLegRight();

}
package com.build;

/**
 * 建造胖子
 * @author 黄二狗
 *
 */
public class PersonFatBuilder implements PersonBuilder{
   public PersonFatBuilder()
   {

   }

    @Override
    public void buildHead() {
        System.out.println("大头");
    }

    @Override
    public void buildBody() {
        System.out.println("大身体");

    }

    @Override
    public void buildArmLeft() {
        System.out.println("左大胳膊");

    }

    @Override
    public void buildArmRight() {
        System.out.println("右大胳膊");

    }

    @Override
    public void buildLegLeft() {
        System.out.println("左大腿");

    }

    @Override
    public void buildLegRight() {
        System.out.println("右大腿");

    }

}
package com.build;

/**
 * 建造瘦人
 * @author 黄二狗
 *
 */
public class PersonThinBuilder  implements PersonBuilder{

    public PersonThinBuilder()
    {

    }

    @Override
    public void buildHead() {
        System.out.println("小头");
    }

    @Override
    public void buildBody() {
        System.out.println("小身体");

    }

    @Override
    public void buildArmLeft() {
        System.out.println("左小胳膊");

    }

    @Override
    public void buildArmRight() {
        System.out.println("右小胳膊");

    }

    @Override
    public void buildLegLeft() {
        System.out.println("左小腿");

    }

    @Override
    public void buildLegRight() {
        System.out.println("右小腿");

    }

}
package com.build;

/**
 * 建造指导者 如果没有该类 用户需要知道怎么建出来的 但是用户根本就不想知道这些
 * @author 黄二狗
 *
 */
public class PersonDirector {  

     private PersonBuilder pb;
     public PersonDirector(PersonBuilder pb)
     {
         this.pb=pb;
     }

     //流程规范
     public void createPerson()
     {
         pb.buildHead();
         pb.buildBody();
         pb.buildArmLeft();
         pb.buildArmRight();
         pb.buildLegLeft();
         pb.buildLegRight();
     }
}
package com.build;

public class Client {

    //出场
    public static void main(String[] args) {

    PersonFatBuilder pfb=new PersonFatBuilder();
    PersonDirector pdThin=new PersonDirector(pfb);
package com.build2;

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

//产品 由多个部件组成
public class Product {
  List<String> parts=new ArrayList<String>();

  public void add(String part)
  {
      parts.add(part);
  }

  public void show()
  {
      System.out.println("产品创建====");
      for(String part:parts)
      {
          System.out.println(part);
      }
  }
}


package com.build2;

public interface Builder {
    //假设产品由两个部件组成
    void buildPartA();
    void buildPartB();
    Product getResult();
}
package com.build2;

public class ConcreteBuilder1 implements Builder{

    private Product product=new Product();
    @Override
    public void buildPartA() {
        product.add("部件A");

    }

    @Override
    public void buildPartB() {
        product.add("部件B");
    }

    @Override
    public Product getResult() {
        return product;
    }

}
package com.build2;

public class ConcreteBuilder2 implements Builder{

    private Product product=new Product();
    @Override
    public void buildPartA() {
        product.add("部件X");

    }

    @Override
    public void buildPartB() {
        product.add("部件Y");
    }

    @Override
    public Product getResult() {
        return product;
    }

}
package com.build2;

public class Director {
  public void construct(Builder builder)
  {
      builder.buildPartA();
      builder.buildPartB();
  }
}
package com.build2;

public class Client {
 public static void main(String[] args) {
     Director director=new Director();
     Builder builder=new ConcreteBuilder1();
     director.construct(builder);
     Product product=builder.getResult();
     product.show();

}
}

    pdThin.createPerson();

    System.out.println("===========");

    PersonThinBuilder ptb=new PersonThinBuilder();
    PersonDirector pdFat=new PersonDirector(ptb);
    pdFat.createPerson();

    }
}



package com.build2;

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

//产品 由多个部件组成
public class Product {
  List<String> parts=new ArrayList<String>();

  public void add(String part)
  {
      parts.add(part);
  }

  public void show()
  {
      System.out.println("产品创建====");
      for(String part:parts)
      {
          System.out.println(part);
      }
  }
}
package com.build2;

public interface Builder {
    //假设产品由两个部件组成
    void buildPartA();
    void buildPartB();
    Product getResult();
}
package com.build2;

public class ConcreteBuilder1 implements Builder{

    private Product product=new Product();
    @Override
    public void buildPartA() {
        product.add("部件A");

    }

    @Override
    public void buildPartB() {
        product.add("部件B");
    }

    @Override
    public Product getResult() {
        return product;
    }

}
package com.build2;

public class ConcreteBuilder2 implements Builder{

    private Product product=new Product();
    @Override
    public void buildPartA() {
        product.add("部件X");

    }

    @Override
    public void buildPartB() {
        product.add("部件Y");
    }

    @Override
    public Product getResult() {
        return product;
    }

}
package com.build2;

public class Director {
  public void construct(Builder builder)
  {
      builder.buildPartA();
      builder.buildPartB();
  }
}
package com.build2;

public class Client {
 public static void main(String[] args) {
     Director director=new Director();
     Builder builder=new ConcreteBuilder1();
     director.construct(builder);
     Product product=builder.getResult();
     product.show();

}
}

时间: 2024-10-05 04:55:04

大话设计模式第十三章之建造者模式的相关文章

大话设计模式第十三章---建造者模式比较

<?php class Product { private $_parts = array(); public function add(string $part) { $this->_parts[] = $part; } public function show() { echo "\n PRODUCT CREATEING...<br/>"; foreach ($this->_parts as $part) { echo $part; echo &quo

大话设计模式读书笔记1——简单工厂模式

最近几日,重温了一下<大话设计模式>这本书,当时读的仓促,有很多没有注意的地方,现在仔细翻看起来,发现这值得细细品味的一本书!! 好东西就要记下来!!! 第一章笔记:从一个简单的计算器程序来看简单工厂模式. 变化的地方就要封装,用一个单独的类来做创造实例的过程这就是工厂. UML图: /// <summary> /// 运算类 /// </summary> public class Operation { public double Number1 { get; set

设计模式总结篇系列:建造者模式(Builder)

关于建造者模式网上有很多文章,也有些不同的理解.在此结合网上其他文章对建造者模式进行总结. 总体说来,建造者模式适合于一个具有较多的零件(属性)的产品(对象)的创建过程.根据产品创建过程中零件的构造是否具有一致的先后顺序,可以将其分为如下两种形式. 一.通过Client.Director.Builder和Product形成的建造者模式 Builder负责Product类对象的具体过程构建,Director负责指导Build,要求Builder按照其指定的顺序去完成Produt的构造.最后通过Bu

云计算设计模式(十三)——领导人选举模式

云计算设计模式(十三)——领导人选举模式 通过协调合作,在分布式应用程序的任务实例集合执行的操作,选举一个实例作为承担管理的其他实例责任的领导者.这个模式可以有助于确保任务实例不互相冲突,导致争用共享资源,或与其他的任务实例正在执行的工作无意中干扰. 背景和问题 一个典型的云应用包括行动协调的方式很多任务.这些任务都可以是实例运行相同的代码和需要访问相同的资源,或者它们可能是可并行工作,以执行复杂计算的各个部分. 任务实例可能为多的时间自主运行,但它也可能是必要的,以协调各实例的操作,以确保它们

java设计模式(二)单例模式 建造者模式

(三)单例模式 单例模式应该是最常见的设计模式,作用是保证在JVM中,该对象只有一个实例存在. 优点:1.减少某些创建比较频繁的或者比较大型的对象的系统开销. 2.省去了new操作符,降低系统内存使用频率,减轻GC压力. 3.保证核心代码的唯一性,比如交易引擎. 单例模式看似是最简单的设计模式. public class Singleton { //私有构造方法,防止实例化 private Singleton(){ } //创建类的实例的时候加载 private static Factory f

.NET设计模式(4):建造者模式(Builder Pattern)(转)

概述 在软件系统中,有时候面临着“一个复杂对象”的创建工作,其通常由各个部分的子对象用一定的算法构成:由于需求的变化,这个复杂对象的各个部分经常面临着剧烈的变化,但是将它们组合在一起的算法确相对稳定.如何应对这种变化?如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化,从而保持系统中的“稳定构建算法”不随着需求改变而改变?这就是要说的建造者模式. 本文通过现实生活中的买KFC的例子,用图解的方式来诠释建造者模式. 意图 将一个复杂的构建与其表示相分离,使得同样的构建过程可以创建不同的表

《大话设计模式》笔记(1)——创建型模式

1.简单工厂模式/静态工厂方法 定义:简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例. UML: PS:这个设计模式太简单了,没什么好解说的,简单来说就是通过传入一个标识到工厂类方法中,返回相应的具体产品. 2.工厂方法模式 定义:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法使得一个类的实例化延迟到其子类. UML: PS:简单工厂模式的优点在于工厂类中包含了必要的逻辑判断,根据客户端传入的标识来动态实例化相应的类. 工厂方法模式是把简单工厂的内部逻辑判断,移到了客户

Java中的设计模式(八):建造者模式

介绍 今天我们将研究java中的Builder模式.Builder 设计模式是一种创造性的设计模式,如工厂模式和抽象工厂模式. 当Object包含许多属性时,引入了Builder模式来解决Factory和Abstract Factory设计模式的一些问题. 当Object包含许多属性时,Factory和Abstract Factory设计模式存在三个主要问题. 从客户端程序传递到Factory类的参数太多,可能容易出错,因为大多数情况下,参数的类型是相同的,而从客户端来说,很难维护参数的顺序.

设计模式@第12章:组合模式

第12章:组合模式 一.看一个学校院系展示需求 编写程序展示一个学校院系结构:需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院, 一个学院有多个系.如图: ----------清华大学-------------- ----------计算机学院------------ 计算机科学与技术 软件工程 网络工程 ---------信息工程学院----------- 通信工程 信息工程 二.传统方案解决学校院系展示(类图) 传统方案解决学校院系展示存在的问题分析 将学院看做是学校的子类