《Java设计模式》之构建者模式

概述：

 
       构造者模式（Builder Pattern）：构造者模式将一个复杂对象的构造过程和它的表现层分离开来。使得相同的构建过程能够创建不同的表示，又称为生成器模式。

     Builder模式 主要用于“构建一个复杂的对象”。

把复杂对象的创建过程加以抽象，通过子类继承和重写方法。来得到具有复合属性的对象。

      同一时候为了统一创建过程，把对象的创建操作统一封装到Director的方法中。

      因为一个复杂对象的单个属性可能会发生变化（比如：制造汽车时使用的某一部件属于不同的厂家）可是整个复杂对象的构建过程却不会发生变化（比如：汽车的构建图纸已经固定，仅仅须要把部件依照图纸装配好）

    GOF：讲一个复杂对象的构建与其表示相分离，使得同样的构建过程能够创建不同的表示。即构建过程同样，可是子部件却不同样。

抽象工厂注重的是不同的工厂生产不同的产品。builder注重的是某个产品由不同的零件组成，产品的生产project。

Director就是负责产品组装的。是控制生产过程的；而builder是负责产品部件生产的。这样就实现了“过程”和“部件”的解耦。

抽象工厂通过不同的构建过程生成不同的对象表示，而Builder模式通过同样的构建过程生成不同的表示。

适用性：

    1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

    2.当构造过程必须同意被构造的对象有不同的表示时。

结构图(Struct):  

生活中的样例：

             



import java.util.ArrayList;

抽象的创建者类。主要给详细的创建者类创建模板。详细的创建者继承该类后，重写方法。用自己的方式创建风格不同的复杂对象的属性。但整体复杂对象的结构已经固定。

abstract class Builder{
    public abstract void BuildDoor();
    public abstract void BuildWall();
    public abstract void BuildWindows();
    public abstract void BuildHouseCeiling();
    public abstract House GetHouse();
}

具有复杂属性的对象。

class House{
    private ArrayList <String>parts=new ArrayList<String>();
    public void add(String str){
        parts.add(str);
    }
    public void show()
    {
        for(String part:parts)
        {
            System.out.println(part+"\t");
        }
        System.out.println("\n");
    }

}

统一创建的过程。将创建过程统一。也能够有详细的流程

class Director{
    public void construct(Builder builder){
        builder.BuildDoor();
        builder.BuildWall();
        builder.BuildWindows();
        builder.BuildHouseCeiling();
    }
}

详细的创建者类，负责创建具有不同表示的复杂对象

class ChineseBuilder extends Builder{
    private House chineseHouse=new House();
    public void BuildDoor() {
        chineseHouse.add("ChineseDoor");
    }
    public void BuildWall() {
        chineseHouse.add("ChineseWall");
    }
    public void BuildWindows() {
        chineseHouse.add("ChineseWindows");
    }
    public void BuildHouseCeiling() {
        chineseHouse.add("ChineseHouserCeiling");
    }
    public House GetHouse() {
        return chineseHouse;
    }

}

class EnglandBuilder extends Builder{
    private House englandHouse=new House();
    public void BuildDoor() {
        englandHouse.add("EnglandDoor");
    }
    public void BuildWall() {
        englandHouse.add("EnglandWall");
    }
    public void BuildWindows() {
        englandHouse.add("EnglandWindows");
    }
    public void BuildHouseCeiling() {
        englandHouse.add("EnglandHouserCeiling");
    }
    public House GetHouse() {
        return englandHouse;
    }

}
public class BuilderPattern {
    public static void main(String[] args) {
        Builder chineseBuilder=new ChineseBuilder();
        Builder englandBuilder=new EnglandBuilder();
        Director director=new Director();
        director.construct(chineseBuilder);
        House chineseHouse=chineseBuilder.GetHouse();
        chineseHouse.show();
        director.construct(englandBuilder);
        House englandHouse=englandBuilder.GetHouse();
        englandHouse.show();
    }

}

在这里转贴一下这位

forumID=125&threadID=28019&messageID=241582" style="text-decoration:none; color:rgb(8,68,135); font-family:simsun; font-size:14px; line-height:21px; background-color:rgb(235,235,235)">richardluo的比喻。



简单地说，就好象我要一座房子住，但是我不知道怎么盖（简单的砌墙。层次较低），也不知道怎么样设计（建几个房间，几个门好看，层次较高），于是我须要找一帮民工。他们会砌墙。还得找个设计师，他知道怎么设计，我还要确保民工听设计师的领导。而设计师本身也不干活，光是下命令，这里砌一堵墙，这里砌一扇门。这样民工開始建设，最后，我能够向民工要房子了。在这个过程中，设计师是什么也没有。除了他在脑子里的设计和命令，所以要房子也是跟民工要，记住了！



下面是richardluo的代码，我依据他的思路加上了对应的凝视。



1，定义工人接口，就是可以完毕建造房子任务的人的通用要求。

java 代码

 

1. // 工人接口。定义了各个工人所要进行的工所作。

   他们负责进行详细部件如窗户。地板的建造。

2. // 同一时候由于房子是民工建的，因此建设完毕后由他把房子递交回房主
3. public interface Builder {
4. public  void makeWindow();
5. public  void makeFloor();
6. public  Room  getRoom();
7. }

2，定义设计师。他的职责是指挥房主指派给他的工人依照自己的设计意图建造房子。

java 代码

 

1. // 设计师。他知道房子应该怎么设计，但他不会自己去建造，而是指挥民工去建造。

2. public class Designer {
3. // 指挥民工进行工作
4. public void order(Builder  builder) {
5. builder.makeWindow();
6. builder.makeFloor();
7. }
8. }

3，民工，他负责详细事物的实施。

java 代码

 

1. // 民工。负责进行详细部件如窗户，地板的建造。

2. //同一时候由于房子是民工建的，因此建设完毕后由他把房子递交回房主
3. public class Mingong  implements Builder {
4. private  String window="";
5. private  String floor="";
6. public  void makeWindow() {
7. window=new String("window");
8. }
9. public  void makeFloor(){
10. floor=new String("floor");
11. }
12. // 回交房子给房主
13. public  Room  getRoom() {
14. if((!window.equals(""))&&(!floor.equals(""))) {
15. System.out.println("room ready!");
16. return new Room();
17. }
18. else return null;
19. }
20. }

4，房主，就是雇人，收房。

java 代码

 

1. // 房主。房主的任务就是聘请一个民工，一个设计师，同一时候把民工给设计师指挥，督促设计师开展工作。

   最后从民工手上收房。

2. public class Client {
3. public static void main(String[] args) {
4. Builder mingong = new Mingong();
5. Designer  designer = new  Designer();
6. designer.order(mingong);
7. mingong.getRoom();
8. }
9. }

本文借鉴：http://blog.csdn.net/jiafu1115/article/details/6668563

http://luchar.iteye.com/blog/179619

http://blog.sina.com.cn/s/blog_66f2257c0100i9yi.html