設計模式：Builder模式
一、前言
今天我們討論一下Builder建造者模式，這個Builder，其實和模板模式非常的像，但是也有區別，那就是在模板模式中父類對子類中的實現進行操作，在父類之中進行一件事情的處理，但是在Builder模式之中，父類和子類都不用關心怎么處理，而是用另一個類來完成對這些方法的有機組合，這個類的職責就是‘監工’，規定了到底要怎么樣有機的組合這些方法。在監工類（Director）中，將父類組合進去，然后調用父類的操作來抽象的實現一件事情，這就是面向接口（抽象）變成的妙處了，當然這個Builder可以使接口也可以是抽象類，在這里我們使用抽象類。
二、Builder模式代碼
Builder 抽象類：
1 package zyr.dp.builder; 2 3 public abstract class Builder { 4 5 public abstract void makeString(String str); 6 public abstract void makeTitle(String title); 7 public abstract void makeItems(String[] items); 8 public abstract void close(); 9 10 }
HtmlBuilder 實現類：
1 package zyr.dp.builder; 2 3 import java.io.FileWriter; 4 import java.io.IOException; 5 import java.io.PrintWriter; 6 7 public class HtmlBuilder extends Builder { 8 9 private String filename; 10 private PrintWriter pw; 11 public void makeTitle(String title) { 12 filename="D:\\"+title+".html"; 13 try { 14 pw=new PrintWriter(new FileWriter(filename)); 15 } catch (IOException e) { 16 e.printStackTrace(); 17 } 18 pw.println("<html><head><title>"+title+"</title></head><body>"); 19 pw.println("<h1>"+title+"</h1>"); 20 } 21 22 public void makeString(String str) { 23 pw.println("<p>"+str+"</p>"); 24 } 25 26 public void makeItems(String[] items) { 27 pw.println("<ul>"); 28 for(int i=0;i<items.length;i++){ 29 pw.println("<li>"+items[i]+"</li>"); 30 } 31 pw.println("</ul>"); 32 } 33 34 public void close() { 35 pw.println("</body></html>"); 36 pw.close(); 37 } 38 public String getResult(){ 39 return filename; 40 } 41 }
TextBuilder實現類：
1 package zyr.dp.builder; 2 3 public class TextBuilder extends Builder { 4 5 StringBuffer sb=new StringBuffer(); 6 7 public void makeTitle(String title) { 8 sb.append("====================="); 9 sb.append("["+title+"]"+"\n"); 10 } 11 12 public void makeString(String str) { 13 sb.append("@"+str+"\n"); 14 } 15 16 public void makeItems(String[] items) { 17 for(int i=0;i<items.length;i++){ 18 sb.append(" ."+items[i]+"\n"); 19 } 20 } 21 22 public void close() { 23 sb.append("====================="); 24 } 25 26 public String getResult(){ 27 return sb.toString(); 28 } 29 30 }
Director監工類：
1 package zyr.dp.builder; 2 3 public class Director { 4 private Builder builder; 5 public Director(Builder builder){ 6 this.builder=builder; 7 } 8 public void construct(){ 9 String [] items1=new String[]{"奏國歌","升國旗"}; 10 String [] items2=new String[]{"觀眾鼓掌","有序撤離"}; 11 builder.makeTitle("今日頭條"); 12 builder.makeString("畢業典禮"); 13 builder.makeItems(items1); 14 builder.makeString("典禮結束"); 15 builder.makeItems(items2); 16 builder.close(); 17 } 18 }
Main類：
1 package zyr.dp.builder; 2 3 public class Main { 4 5 public static void main(String[] args) { 6 //String choice="plain"; 7 String choice="html"; 8 if(choice=="plain"){ 9 TextBuilder t=new TextBuilder(); 10 Director d=new Director(t); 11 d.construct(); 12 System.out.println(t.getResult()); 13 }else if(choice=="html"){ 14 HtmlBuilder html=new HtmlBuilder(); 15 Director d=new Director(html); 16 d.construct(); 17 System.out.println(html.getResult()); 18 }else{ 19 usage(); 20 } 21 22 } 23 24 private static void usage() { 25 System.out.println("使用 plain，編輯文本文件"); 26 System.out.println("使用 html，編輯網頁文件"); 27 } 28 29 }
運行結果：
或者：
三、總結
關於Builder模式，我們一定要分清和模板方法的區別，其實就是到底誰承擔了“監工”的責任，在模板方法中父類承擔了這個責任，而在Builder中，有另外一個專門的類來完成這樣的操作，這樣做的好處是類的隔離，比如說在Main中，用戶根本就不知道有Builder這個抽象類，同樣的Director這個監工的根本就不管到底是哪一個實現類，因為任何一個都會被轉換為父類，然后進行處理（面向抽象編程的思想），因此很好的實現了隔離，同樣的這樣設計的好處是復用了，隔離的越好復用起來就越方便，我們完全可以思考，假如還有另外一個監工，使用了不同的construct方法來組裝這些復雜的事件，那么對於原來的代碼我們不用做任何的修改，只用增加這樣的一個監工類，然后定義好相應的方法就好了，之后再Main中使用，這樣的一種思想使得我們不用修改源代碼，復用（Builder以及其子類）就很方便了，同樣的，如果想增加一個新的Builder的子類，只要照着父類的方法進行填充，再加上自己的方法就好了，完全不用修改代碼，這也是一種復用，因此這種復用（組件）的思想在設計模式中隨處可見，本質就是高內聚低耦合，組件開發，盡量不修改原來的代碼，有可擴展性，理解了這一點，我們再看看模板方法，責任全放在了父類里，如果責任需要改變，則必須要修改父類中的責任方法了，這樣就修改了原來的代碼，不利於復用，這也是兩者的本質區別。