本文主要向大家介绍了JAVA语言的建造者模式。通过具体的内容向大家展现，希望对大家学习JAVA语言有所帮助。

定义：

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

实用范围

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

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

角色

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

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

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

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

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

角色Builder：

[java] view plain copy
1. public interface PersonBuilder {  
2.      void buildHead();  
3.      void buildBody();  
4.      void buildFoot();  
5.      Person buildPerson();  
6. }

角色ConcreteBuilder：

[java] view plain copy
1. public class ManBuilder implements PersonBuilder {  
2.      Person person;  
3.      public ManBuilder() {  
4.           person = new Man();  
5.      }  
6.      public void buildbody() {  
7.           person.setBody("建造男人的身体");  
8.      }  
9.      public void buildFoot() {  
10.           person.setFoot("建造男人的脚");  
11.      }  
12.      public void buildHead() {  
13.           person.setHead("建造男人的头");  
14.      }  
15.      public Person buildPerson() {  
16.           return person;  
17.      }  
18. }

角色ConcreteBuilder：

[java] view plain copy
1. public class WomanBuilder implements PersonBuilder {  
2.      Person person;  
3.      public WomanBuilder() {  
4.           person = new Woman();  
5.      }  
6.      public void buildbody() {  
7.           person.setBody(“建造女人的身体");  
8.      }  
9.      public void buildFoot() {  
10.           person.setFoot(“建造女人的脚");  
11.      }  
12.      public void buildHead() {  
13.           person.setHead(“建造女人的头");  
14.      }  
15.      public Person buildPerson() {  
16.           return person;  
17.      }  
18. }

角色Director：

[java] view plain copy
1. public class PersonDirector {  
2.      public Person constructPerson(PersonBuilder pb) {  
3.           pb.buildHead();  
4.           pb.buildBody();  
5.           pb.buildFoot();  
6.           return pb.buildPerson();  
7.      }  
8. }

角色Product：

[java] view plain copy
1. public class Person {  
2.      private String head;  
3.      private String body;  
4.      private String foot;  
5.   
6.      public String getHead() {  
7.           return head;  
8.      }  
9.      public void setHead(String head) {  
10.           this.head = head;  
11.      }  
12.      public String getBody() {  
13.           return body;  
14.      }  
15.      public void setBody(String body) {  
16.           this.body = body;  
17.      }  
18.      public String getFoot() {  
19.           return foot;  
20.      }  
21.      public void setFoot(String foot) {  
22.           this.foot = foot;  
23.      }  
24. }  
25. public class Man extends Person {  
26.      public Man(){  
27.           System.out.println(“开始建造男人");  
28.      }  
29. }  
30. public class Woman extends Person {  
31.      public Woman(){  
32.           System.out.println(“开始建造女人");  
33.      }  
34. }

测试：

[java] view plain copy
1. public class Test{  
2.      public static void main(String[] args) {  
3.           PersonDirector pd = new PersonDirector();  
4.           Person womanPerson = pd.constructPerson(new ManBuilder());  
5.           Person manPerson = pd.constructPerson(new WomanBuilder());  
6.      }  
7. }

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

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

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

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

[java] view plain copy
1. public class Man {  
2.      private String head;  
3.      private String body;  
4.      private String foot;  
5.   
6.      public String getHead() {  
7.           return head;  
8.      }  
9.      public void setHead(String head) {  
10.           this.head = head;  
11.      }  
12.      public String getBody() {  
13.           return body;  
14.      }  
15.      public void setBody(String body) {  
16.           this.body = body;  
17.      }  
18.      public String getFoot() {  
19.           return foot;  
20.      }  
21.      public void setFoot(String foot) {  
22.           this.foot = foot;  
23.      }  
24. }

[java] view plain copy
1. public class ManBuilder{  
2.      Man man;  
3.      public ManBuilder() {  
4.           man = new Man();  
5.      }  
6.      public void buildbody() {  
7.           man.setBody("建造男人的身体");  
8.      }  
9.      public void buildFoot() {  
10.           man.setFoot("建造男人的脚");  
11.      }  
12.      public void buildHead() {  
13.           man.setHead("建造男人的头");  
14.      }  
15.      public Man builderMan() {  
16.           buildHead();  
17.           buildBody();  
18.           buildFoot();  
19.           return man;  
20.      }  
21. }

测试：

[java] view plain copy
1. public class Test{  
2.      public static void main(String[] args) {  
3.           ManBuilder builder = new ManBuilder();  
4.           Man man = builder.builderMan();  
5.      }  
6. }

希望对JAVA有兴趣的朋友有所帮助。了解更多内容，请关注职坐标编程语言JAVA频道！