設計模式：Builder模式

時間 2019-11-18

標籤設計模式 builder 简体版

原文原文鏈接

設計模式：Builder模式

1、前言html

今天咱們討論一下Builder建造者模式，這個Builder，其實和模板模式很是的像，可是也有區別，那就是在模板模式中父類對子類中的實現進行操做，在父類之中進行一件事情的處理，可是在Builder模式之中，父類和子類都不用關心怎麼處理，而是用另外一個類來完成對這些方法的有機組合，這個類的職責就是‘監工’，規定了到底要怎麼樣有機的組合這些方法。在監工類（Director）中，將父類組合進去，而後調用父類的操做來抽象的實現一件事情，這就是面向接口（抽象）變成的妙處了，固然這個Builder可使接口也能夠是抽象類，在這裏咱們使用抽象類。java

2、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監工類：app

 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類：ui

 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 }

運行結果：this

或者：spa

3、總結設計

關於Builder模式，咱們必定要分清和模板方法的區別，其實就是到底誰承擔了「監工」的責任，在模板方法中父類承擔了這個責任，而在Builder中，有另一個專門的類來完成這樣的操做，這樣作的好處是類的隔離，好比說在Main中，用戶根本就不知道有Builder這個抽象類，一樣的Director這個監工的根本就無論究竟是哪個實現類，由於任何一個都會被轉換爲父類，而後進行處理（面向抽象編程的思想），所以很好的實現了隔離，一樣的這樣設計的好處是複用了，隔離的越好複用起來就越方便，咱們徹底能夠思考，假如還有另一個監工，使用了不一樣的construct方法來組裝這些複雜的事件，那麼對於原來的代碼咱們不用作任何的修改，只用增長這樣的一個監工類，而後定義好相應的方法就行了，以後再Main中使用，這樣的一種思想使得咱們不用修改源代碼，複用（Builder以及其子類）就很方便了，一樣的，若是想增長一個新的Builder的子類，只要照着父類的方法進行填充，再加上本身的方法就行了，徹底不用修改代碼，這也是一種複用，所以這種複用（組件）的思想在設計模式中隨處可見，本質就是高內聚低耦合，組件開發，儘可能不修改原來的代碼，有可擴展性，理解了這一點，咱們再看看模板方法，責任全放在了父類裏，若是責任須要改變，則必需要修改父類中的責任方法了，這樣就修改了原來的代碼，不利於複用，這也是二者的本質區別。code

程序代碼