设计模式：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

程序代码