java设计模式之建造者模式

最新推荐文章于 2024-02-05 07:00:00 发布

编程初丁

最新推荐文章于 2024-02-05 07:00:00 发布

阅读量270

点赞数

分类专栏： Java设计模式学习文章标签：设计模式

Java设计模式学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

定义：

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

实用范围

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

2、当构造过程必须允许被构造的对象有不同表示时。

角色

在这样的设计模式中，有以下几个角色：

1、Builder：为创建一个产品对象的各个部件指定抽象接口。

2、ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示，并提供一个检索产品的接口。

3、Director：构造一个使用Builder接口的对象，指导构建过程。

4、Product：表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程，包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

角色Builder：

[java]view plaincopy 
    
print?
 public interface PersonBuilder {  
      void buildHead();  
      void buildBody();  
      void buildFoot();  
      Person buildPerson();  
 }  

角色ConcreteBuilder：

[java]view plaincopy 
    
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;  
      }  
 }  

角色ConcreteBuilder：

[java]view plaincopy 
    
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 plaincopy 
    
print?
 public class PersonDirector {  
      public Person constructPerson(PersonBuilder pb) {  
           pb.buildHead();  
           pb.buildBody();  
           pb.buildFoot();  
           return pb.buildPerson();  
      }  
 }  

角色Product：

[java]view plaincopy 
    
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(“开始建造女人");  
      }  
 }  

测试：

[java]view plaincopy 
    
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 plaincopy 
    
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 plaincopy 
    
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 plaincopy 
     
print?
 public class Test{  
      public static void main(String[] args) {  
           ManBuilder builder = new ManBuilder();  
           Man man = builder.builderMan();  
      }  
 }  

转自：

作者：jason0539

博客：http://blog.csdn.net/jason0539

编程初丁

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java设计模式之建造者模式

定义：建造者模式：将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。实用范围1、当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。2、当构造过程必须允许被构造的对象有不同表示时。角色在这样的设计模式中，有以下几个角色：1、Builder：为创建一个产品对象的各个部件指定抽象接
复制链接

扫一扫