建造型——建造者模式

来源：互联网发布：北京上游网络编辑：程序博客网时间：2024/04/30 13:12

抽象工厂的缺点：

功能太简单，只能创建简单的对象。

定义：

将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，使用简单的对象一步一步构建一个复杂

的对象。

目的：

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

特点：

①一个复杂的对象的创建，通常由各个部分的子对象用一定的算法构成；

②由于需求的变化，这个复杂的各个部分经常面临这剧烈的变化，但是他们组合在一起的算法却相对稳定。

③构建时将变与不变分离开。

通用类图：

产品类：

一般是一个较为复杂的对象。可以是一个具体类，也可以是有一个抽象类和与他不同实现组成。

抽象建造者：

为创建一个产品对象的各个部件指定抽象接口。一般有两类抽象方法，一个用来返回建造产品，一个用来返回产品。

建造者：

实现建造各个部件的具体过程，并将返回组建好的产品。

导演类：

负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类，一般来说

导演类被用来封装程序中易变的部分。

客户端：

只需关系具体的建造者，无需关系产品内部构建流程，如果需要其他复杂的产品对象，只需选择其他的建造者，如果需要扩展

，则只需写一个新的Builder就行了。

角色Product：

[java] view plain copy
 print?

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 {
public Man(){
System.out.println(“开始建造男人");
}
}
public class Woman extends Person {
public Woman(){
System.out.println(“开始建造女人");
}
}

角色Builder：

[java] view plain copy
 print?
public interface PersonBuilder {  
    abstract void buildHead();  
    abstract void buildBody();  
    abstract void buildFoot();  
    //返回产品函数
abstract  Person buildPerson();  
}  

建造者AConcreteBuilder：

[java] view plain copy
 print?
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;  
     }  
}  

建造者BConcreteBuilder：

[java] view plain copy
 print?
public class WomanBuilder implements PersonBuilder {  
     Person person;  
     public WomanBuilder() {  
          person = new Woman();  
     }  
     public void buildbody() {  
          person.setBody(“建造女人的身体");  
     }  
     public void buildFoot() {  
          person.setFoot(“建造女人的脚");  
     }  
     public void buildHead() {  
          person.setHead(“建造女人的头");  
     }  
    
//返回组建后的产品
 public Person buildPerson() {  
          return person;  
     }  
}  

导演类Director：

[java] view plain copy
 print?
public class PersonDirector {  
     public Person constructPerson(PersonBuilder pb) {  
          pb.buildHead();  
          pb.buildBody();  
          pb.buildFoot();  
          return pb.buildPerson();  
     }  
}  

客户端：

[java] view plain copy
 print?
public class Test{  
     public static void main(String[] args) {  
          PersonDirector pd = new PersonDirector();  
          Person womanPerson = pd.constructPerson(new ManBuilder());  
          Person manPerson = pd.constructPerson(new WomanBuilder());  
     }  
}  

建造者模式在使用过程中可以演化出多种形式：

如果具体的被建造对象只有一个的话，可以省略抽象的Builder和Director，让ConcreteBuilder自己扮演指导者和建造者双重角色，甚至ConcreteBuilder也可以放到Product里面实现。

在《Effective Java》书中第二条，就提到“遇到多个构造器参数时要考虑用构建器”，其实这里的构建器就属于建造者模式，只是里面把四个角色都放到具体产品里面了。

上面例子如果只制造男人，演化后如下：

[java] view plain copy
 print?
public class Man {  
     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;  
     }  
}  

[java] view plain copy
 print?
public class ManBuilder{  
     Man man;  
     public ManBuilder() {  
          man = new Man();  
     }  
     public void buildbody() {  
          man.setBody("建造男人的身体");  
     }  
     public void buildFoot() {  
          man.setFoot("建造男人的脚");  
     }  
     public void buildHead() {  
          man.setHead("建造男人的头");  
     }  
     public Man builderMan() {  
          buildHead();  
          buildBody();  
          buildFoot();  
          return man;  
     }  
}  

测试：

[java] view plain copy
 print?
public class Test{  
     public static void main(String[] args) {  
          ManBuilder builder = new ManBuilder();  
          Man man = builder.builderMan();  
     }  
}  

建造者模式是的优点：

①使用建造者模式可以是客户端不必知道产品内部组成的细节

②具体的建造者类之间是相互独立的，对于系统的扩展非常有利。

③由于具体的建造者是独立的，因此可以建造过程逐步细化，而不对其他模块产生任何影响。

阅读全文

0 0