设计模式之建造者模式
1 概述
建造者模式(Builder Pattern)主要用于“分步骤构建一个复杂的对象”，在这其中“分步骤”是一个稳定的算法，而复杂对象的各个部分则经常变化。因此， 建造者模式主要用来解决“对象部分”的需求变化。 这样可以对对象构造的过程进行更加精细的控制。
2 示例
还是以生产手机为例，每个手机分为屏幕Screen、CPU、Battery。现在要生产两种手机，苹果机和三星。
苹果：
1 package org.scott.builder.before.use; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 /** 7 * @author Scott 8 * @version 2013-11-20 9 * @description 10 */ 11 public class ApplePhone { 12 List<String> parts = new ArrayList<String>(); 13 14 public void createCPU() { 15 parts.add("CUP: Qualcomm"); 16 } 17 18 public void createScreen() { 19 parts.add("SCREEN: JDI"); 20 } 21 22 public void createBattery() { 23 parts.add("BATTERY: DeSai"); 24 } 25 26 public void show(){ 27 System.out.print("产品部件信息："); 28 for(String part : parts){ 29 System.out.print(part + "\t"); 30 } 31 } 32 }
三星：
1 package org.scott.builder.before.use; 2 3 import java.util.ArrayList; 4 import java.util.List; 5 6 /** 7 * @author Scott 8 * @version 2013-11-20 9 * @description 10 */ 11 public class SamsungPhone { 12 List<String> parts = new ArrayList<String>(); 13 14 public void createCPU() { 15 parts.add("CUP: MTK"); 16 } 17 18 public void createScreen() { 19 parts.add("SCREEN: Samsung"); 20 } 21 22 public void createBattery() { 23 parts.add("BATTERY: DeSai"); 24 } 25 26 public void show(){ 27 System.out.print("产品部件信息："); 28 for(String part : parts){ 29 System.out.print(part + "\t"); 30 } 31 } 32 }
测试客户端：
1 package org.scott.builder.before.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class BuilerTest { 8 private static ApplePhone iphone = new ApplePhone(); 9 private static SamsungPhone samPhone = new SamsungPhone(); 10 11 public static void main(String args[]){ 12 iphone.createCPU(); 13 iphone.createScreen(); 14 iphone.createBattery(); 15 iphone.show(); 16 17 samPhone.createCPU(); 18 samPhone.createScreen(); 19 samPhone.createBattery(); 20 samPhone.show(); 21 } 22 }
是不是发现个问题？那就是生产手机的每一道工序都是一样的，确切的说是工序名称一样，只是具体的每个工序的处理不同，工序是不变的，就这么几步，每道工序的具体处理是变化的，由此，我们可以把不变的抽取出来，以“不变应万变”，将变化的，交给具体的产品来做。
具体怎么做？这回的Builder模式派上用场了。
首先来个Phone的接口：
package org.scott.builder.after.use; import java.util.ArrayList; import java.util.List; /** * @author Scott * @version 2013-11-20 * @description */ public abstract class Phone { protected List<String> parts = new ArrayList<String>(); public void add(String part){ parts.add(part); } public void show(){ System.out.print("产品部件信息："); for(String part : parts){ System.out.print(part + "\t"); } } }
苹果手机类：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class ApplePhone extends Phone{ 8 9 }
三星手机类：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class SamsungPhone extends Phone{ 8 9 }
再定义个生产步骤的接口Builder：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public interface Builder { 8 public void buildCPU(); 9 10 public void buildScreen(); 11 12 public void buildBattery(); 13 14 public Phone getPhone(); 15 }
苹果手机的Builder：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class ApplePhoneBuilder implements Builder{ 8 private Phone phone = new ApplePhone(); 9 10 @Override 11 public void buildCPU() { 12 phone.add("CUP: Qualcomm"); 13 } 14 15 @Override 16 public void buildScreen() { 17 phone.add("SCREEN: JDI"); 18 } 19 20 @Override 21 public void buildBattery() { 22 phone.add("BATTERY: DeSai"); 23 } 24 25 @Override 26 public Phone getPhone() { 27 return phone; 28 } 29 30 }
三星手机的Builder：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class SamsungPhoneBuilder implements Builder{ 8 9 private Phone phone = new SamsungPhone(); 10 11 @Override 12 public void buildCPU() { 13 phone.add("CUP: MTK"); 14 } 15 16 @Override 17 public void buildScreen() { 18 phone.add("SCREEN: Samsung"); 19 } 20 21 @Override 22 public void buildBattery() { 23 phone.add("BATTERY: DeSai"); 24 } 25 26 @Override 27 public Phone getPhone() { 28 return phone; 29 } 30 31 }
指导具体生产手机的Director：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class Director { 8 private Builder builder; 9 10 public Director(Builder builder){ 11 this.builder = builder; 12 } 13 14 public void construct(){ 15 builder.buildCPU(); 16 builder.buildScreen(); 17 builder.buildBattery(); 18 } 19 }
最后写个测试类：
1 package org.scott.builder.after.use; 2 /** 3 * @author Scott 4 * @version 2013-11-20 5 * @description 6 */ 7 public class BuilderTest { 8 9 private static Builder iPhoneBuilder = new ApplePhoneBuilder(); 10 private static Builder samPhoneBuilder = new SamsungPhoneBuilder(); 11 12 public static void main(String[] args) { 13 Director director = new Director(iPhoneBuilder); 14 director.construct(); 15 Phone phone = iPhoneBuilder.getPhone(); 16 System.out.println("iphone"); 17 phone.show(); 18 19 director = new Director(samPhoneBuilder); 20 director.construct(); 21 phone = samPhoneBuilder.getPhone(); 22 System.out.println("\nsamSung"); 23 phone.show(); 24 } 25 26 }
运行结果：
iphone
产品部件信息：CUP: Qualcomm SCREEN: JDI BATTERY: DeSai
samSung
产品部件信息：CUP: MTK SCREEN: Samsung BATTERY: DeSai
这里的两个Phone实体类是空的，如果是这种情况，那么它们可以省略掉，如果 Phone接口也可以被省略掉，最终剩下的就只有 Director、Builder、和具体的 Bulider 实现类。并且，ApplePhone类和 SamsungPhone类是有关系的两个类，它们不同的手机品牌，如果遇到两个或多个没有太多关系的类，公共的接口Phone就没有存在的必要，但是这时候，那么 Builder 接口的规定的 getPhone() 方法的返回值怎么确定呢？
无论返回值类型是 ApplePhone还是SamsungPhone，都会产生问题，因为返回结果的类型不统一。此时，可以将 Phone定义成一个空接口（不包含任何方法的接口），再让这些没有相互关系的具体产品类都去实现这个接口，那么 Builder 接口里面规定的 getPhone() 方法的返回值类型依然是 Phone 类型，就解决问题了。不过这种情况下，也就没有使用Builder模式的必要了。
是不是看着和工厂模式也有点那么类似？工厂模式是对象之间的，是以对象为处理单位，而建造模式是深入到了对象的内部，以对象生产的步骤作为处理单位。这是我的理解，若是不准确，可以一起讨论讨论~
最后来个经典的建造模式的UML图吧：
