浅谈Builder建造者模式

时间 2019-11-11

标签浅谈 builder 建造者模式繁體版

原文原文链接

1、前言html

Builder建造者模式和模板模式很是像，可是也有区别，模板模式中父类对子类中的实现进行操做，在父类之中进行一件事情的处理，可是在Builder模式之中，父类和子类都不用关心怎么处理，而是用另外一个类来完成对这些方法的有机组合，这个类的职责就是‘监工’，规定了到底要怎么样有机的组合这些方法。在监工类（Director）中，将父类组合进去，而后调用父类的操做来抽象的实现一些事情，这就是面向接口（抽象）的妙处，固然这个Builder能够是接口也能够是抽象类，在这里咱们使用抽象类。java

2、Builder模式代码编程

Builder抽象类：设计模式

package designMode.builder;

public abstract class Builder {
    public abstract void makeString(String str);
    public abstract void makeTitle(String title);
    public abstract void makeItems(String[] items);
    public abstract void close();
}

HtmlBuilder实现类：app

package designMode.builder;

import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class HtmlBuilder extends Builder {
    private String filename;
    private PrintWriter pw;
    @Override
    public void makeString(String str) {
        pw.println("<p>"+str+"</p>");
    }

    @Override
    public void makeTitle(String title) {
        filename = "D:\\"+title+".html";
        try {
            pw = new PrintWriter(new FileWriter(filename));
        } catch (IOException e) {
            e.printStackTrace();
        }
        pw.println("<html><head><title>"+title+"</title></head><body>");
        pw.println("<h1>"+title+"</h1>");
    }

    @Override
    public void makeItems(String[] items) {
        pw.println("<ul>");
        for(int i=0;i<items.length;i++){
            pw.println("<li>"+items[i]+"</li>");
        }
        pw.println("</ul>");
    }

    @Override
    public void close() {
        pw.println("</body></html>");
        pw.close();
    }

    public String getResult() {
        return filename;
    }
}

TextBuilder实现类： ide

package designMode.builder;

public class TextBuilder extends Builder{
    StringBuffer sb=new StringBuffer();
    @Override
    public void makeString(String str) {
        sb.append("@"+str+"\n");
    }

    @Override
    public void makeTitle(String title) {
        sb.append("=====================");
        sb.append("["+title+"]"+"\n");
    }

    @Override
    public void makeItems(String[] items) {
        for(int i=0;i<items.length;i++){
            sb.append("   ."+items[i]+"\n");
        }
    }

    @Override
    public void close() {
        sb.append("=====================");
    }

    public String getResult(){
        return sb.toString();
    }
}

Director监工类： ui

package designMode.builder;

public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void construct(){
        String[] items = new String[]{"奏国歌","升国旗"};
        String [] items2=new String[]{"观众鼓掌","有序撤离"};
        builder.makeTitle("今日头条");
        builder.makeString("毕业典礼");
        builder.makeItems(items);
        builder.makeString("典礼结束");
        builder.makeItems(items2);
        builder.close();
    }
}

Main类：this

package designMode.builder;

public class BuilderMain {
    public static void main(String[] args) {
        //String choice="plain";
        String choice="html";
        if(choice.equals("plain")){
            TextBuilder t = new TextBuilder();
            Director d = new Director(t);
            d.construct();
            System.out.println(t.getResult());
        }else if(choice=="html"){
            HtmlBuilder html = new HtmlBuilder();
            Director d = new Director(html);
            d.construct();
            System.out.println(html.getResult());
        }
    }
}

3、运行结果spa

4、总结.net

关于Builder模式，咱们必定要分清和模板模式的区别，其实就是到底谁承担了“监工”的责任，在模板模式中父类承担了这个责任，在builder模式中，有另一个专门的类来完成这样的操做，这样的好处是类的隔离，好比说在main中，用户根本就不知道builder这个抽象类，一样的Director这个监工根本就无论是哪个实现类，由于任何一个都会被转换为父类，而后进行处理（面向抽象编程的思想），所以很好的实现了隔离，一样的这样设计的好处是复用，隔离的越好复用起来越方便，咱们彻底能够思考，假如还有另一个监工，使用了不一样的construct方法来组装这些复杂的事件，那么对于原来的代码不用作任何的修改，只需增长这样一个监工类便可，而后定义好相应的方法就行了，以后再main中使用，这样的一种思想使得咱们不用修改源代码，复用（builder及其子类）就很方便了，一样的，若是想增长一个builder子类，只要照着父类的方法进行填充，再加上本身的方法就行了，彻底不用修改代码，这也是一种复用，所以这种复用的思想在设计模式中随处可见，本质就是高内聚低耦合，组件开发，尽可能不修改原来的代码，有扩展性，理解了这一点，咱们再看看模板方法，责任全放在父类里，若是责任须要改变，则必需要修改父类中的责任方法了，这样就修改了原来的代码，不利于复用，这也是二者的本质区别。

浅谈设计模式<最通俗易懂的讲解>