设计模式之建造者模式

1、使用场景：

如果你需要将一个复杂对象的构建与他的表示分离，使得相同的构建过程可以创建不同的表示的意图时，我们需要你应用一个设计模式，‘建造者模式’，又叫生成器模式。建造者模式可以将一个产品的内部表象与产品的生成过程分隔开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。如果我们用了建造者模式，那么用户就只需要制定需要建造的类型就可以得到他们，而具体建造的过程和细节就不需要知道了。

 

2、定义：

建造者模式，将一个复杂对象的构建与它表示分离，使得同样的构建过程可以创建不同的表示。

3、UML

类解析：

Director,指挥者，是构建一个使用Builder接口的对象

Builder是为创建一个Product对象的各个部件指定的抽象接口

ConcreteBuilder，具体建造者，实现Bulider接口，构造和装配各个部件

Product，具体产品。

4、建造者模式的好处

使得建造代码与表示代码分离，由于建造者隐藏了该产品是如何组装的，所以若需要改变一个产品的内部表示，只需要再定义一个具体的建造者就可以了。

5、建造者基本代码

product类----产品类，有多个组件组成。

Class product
{
 IList<String> parts = new IList<String>();

//添加产品部件
public void add(String part)
{
 parts.Add(part);s
}

public void show()
{
 ConsoleWriteLine("
产品创建------------");

 //列举所有的产品部件
foreach(String part in parts)
{
  Console.WriteLine(part);
}
}
}

Builder类--------抽象建造者类，确定产品由两个部件partA,partB组成，并声明一个得到产品构造后结果的方法GetResult。

abstract class Builder
{
 public abstract void BuilderPartA();
 public abstract void BuilderPartB();
 public abstract Product GetResult();
}

ConcreteBulider1类----------具体建造者类

public ConcreteBulider1 : Builder
{
 private Product product = New Product();

 public override void BuilderPartA()
{
 //建造具体的两个部件是部件A和部件B
product.Add("部件A")；
}

 public override void BuilderPartB()
{
 //建造具体的两个部件是部件A和部件B
product.Add("部件B")；
}

 public override Product GetResult()
{
 return product;
}

}

ConcreteBulider2类----------具体建造者类.

public ConcreteBulider2 : Builder
{
 private Product product = New Product();

 public override void BuilderPartA()
{
 //建造具体的部件是部件X
product.Add("部件X")；
}

 public override void BuilderPartB()
{
 //建造具体的部件Y
product.Add("部件Y")；
}

 public override Product GetResult()
{
 return product;
}

}

Director类------指挥者类、

class Director
{
 public void Construct(Builder builder)
{
//用来只会建造过程
 builder.BuilderPartA();
builder.BuilderPartB();
}
}

客户端代码，客户不需要知道具体的建造过程。

static void Mian(String[] args)
{
 Director director = new Driector();
 Builder b1 = new ConcreteBuilder1();
 Builder b2 = new ConcreteBuilder2();

//指挥者用ConcreteBuilder1的方法来建造产品
 director.Construct(b1);
Product p1= b1.GetResult();
p1.show();

 director.Construct(b2);
Product p2= b1.GetResult();
p2.show();

Console。Read（）；
}

建造者模式是当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式、

 6、实践篇

　　构造人

Builder

public interface PersonBuilder {
void buildHead();
void buildBody();
void buildFoot();
Person buildPerson();
}

//具体建造工具

ConcreteBuilder

public class ManBuilder implements PersonBuilder {
Person person;
public ManBuilder() {
person = new Man();
}
public void buildbody() {
person.setBody("建造男人的身体");
}
public void buildFoot() {
person.setFoot("建造男人的脚");
}
public void buildHead() {
person.setHead("建造男人的头");
}
public Person buildPerson() {
return person;
}
}

//建造者

Director

public class PersonDirector {
public Person constructPerson(PersonBuilder pb) {
pb.buildHead();
pb.buildBody();
pb.buildFoot();
return pb.buildPerson();
}
}

Product

public class Person {
private String head;
private String body;
private String foot;
public String getHead() {
return head;
}
public void setHead(String head) {
this.head = head;
}
public String getBody() {
return body;
}
public void setBody(String body) {
this.body = body;
}
public String getFoot() {
return foot;
}
public void setFoot(String foot) {
this.foot = foot;
}
}
public class Man extends Person {
}

Test

public class Test{
public static void main(String[] args) {
PersonDirector pd = new PersonDirector();
Person person = pd.constructPerson(new ManBuilder());
System.out.println(person.getBody());
System.out.println(person.getFoot());
System.out.println(person.getHead());
}
}

结果

建造男人的身体

建造男人的脚

建造男人的头