I. Introducción

Hoy discutiremos el patrón de construcción Builder. Este Builder en realidad es muy similar al patrón de plantilla (Template), pero también tiene diferencias. En el patrón de plantilla, la clase padre opera sobre las implementaciones de las subclases, y el procesamiento de una tarea se realiza dentro de la clase padre. Sin embargo, en el patrón Builder, ni la clase padre ni la subclase necesitan preocuparse por cómo procesar; en cambio, se utiliza otra clase para completar la combinación orgánica de estos métodos. La responsabilidad de esta clase es:supervisorque estipula exactamente cómo combinar orgánicamente estos métodos. En la clase supervisora (Director), se incorpora la clase padre y luego se invocan las operaciones de la clase padre para implementar abstractamente una tarea. Esta es la maravilla de la programación orientada a interfaces (abstracción). Por supuesto, este Builder puede ser una interfaz o una clase abstracta; aquí usamos una clase abstracta.

II. Código del patrón Builder

Clase abstracta Builder:

Builder.java

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(); }

Clase de implementación HtmlBuilder:

HtmlBuilder.java

import java.io.FileWriter; import java.io.IOException; import java.io.PrintWriter; public class HtmlBuilder extends Builder { private String filename; private PrintWriter pw; 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>"); } public void makeString(String str) { pw.println("<p>"+str+"</p>"); } 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>"); } public void close() { pw.println("</body></html>"); pw.close(); } public String getResult(){ return filename; } }

Clase de implementación TextBuilder:

TextBuilder.java

public class TextBuilder extends Builder { StringBuffer sb=new StringBuffer(); public void makeTitle(String title) { sb.append("====================="); sb.append("["+title+"]"+"\n"); } public void makeString(String str) { sb.append("@"+str+"\n"); } public void makeItems(String[] items) { for(int i=0;i<items.length;i++){ sb.append(" ."+items[i]+"\n"); } } public void close() { sb.append("====================="); } public String getResult(){ return sb.toString(); } }

Clase supervisora Director:

Director.java

public class Director { private Builder builder; public Director(Builder builder){ this.builder=builder; } public void construct(){ String [] items1=new String[]{"Tocar el himno nacional","Izar la bandera nacional"}; String [] items2=new String[]{"El público aplaude","Evacuación ordenada"}; builder.makeTitle("Titulares de hoy"); builder.makeString("Ceremonia de graduación"); builder.makeItems(items1); builder.makeString("Fin de la ceremonia"); builder.makeItems(items2); builder.close(); } }

Clase Main:

Director.java

public class Main { public static void main(String[] args) { //String choice="plain"; String choice="html"; if(choice=="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()); }else{ usage(); } } private static void usage() { System.out.println("Usar plain para editar archivos de texto"); System.out.println("Usar html para editar archivos web"); } }

Resultado de ejecución

O bien:

III. Resumen

En cuanto al patrón Builder, debemos distinguir claramente la diferencia con el método de plantilla (Template Method). En realidad, se trata de quién asume la responsabilidad de "supervisor". En el método de plantilla, la clase padre asume esta responsabilidad, mientras que en Builder hay otra clase especializada para realizar esta operación. La ventaja de esto es el aislamiento de clases. Por ejemplo, en Main, el usuario no sabe en absoluto que existe la clase abstracta Builder. De igual manera, el supervisor Director no se preocupa en absoluto por cuál es la clase de implementación, porque cualquiera será convertida a la clase padre y luego procesada (la idea de programación orientada a la abstracción). Por lo tanto, se logra un buen aislamiento. De igual manera, la ventaja de este diseño es la reutilización: cuanto mejor sea el aislamiento, más conveniente será la reutilización. Podemos pensar completamente: si hubiera otro supervisor que use un método construct diferente para ensamblar estos eventos complejos, entonces no necesitaríamos modificar el código original; solo habría que añadir una clase supervisora de este tipo, definir los métodos correspondientes y luego usarla en Main. Esta idea hace que no necesitemos modificar el código fuente, por lo que la reutilización (de Builder y sus subclases) es muy conveniente. Del mismo modo, si se desea añadir una nueva subclase de Builder, solo hay que completar los métodos siguiendo la clase padre y agregar los propios, sin modificar código en absoluto. Esto también es una forma de reutilización. Por lo tanto, esta idea de reutilización (componentes) es común en los patrones de diseño; su esencia es el alto acoplamiento interno y el bajo acoplamiento externo, desarrollo de componentes, tratar de no modificar el código original y tener extensibilidad. Entendiendo esto, veamos de nuevo el método de plantilla: la responsabilidad recae toda en la clase padre; si la responsabilidad necesita cambiar, entonces hay que modificar el método de responsabilidad en la clase padre, lo que modifica el código original y no favorece la reutilización. Esta es también la diferencia esencial entre ambos.

Dirección original: https://www.cnblogs.com/zyrblog/p/9230630.html