El patrón de construcción (Patrón de construcción) también se llama patrón generador: una construcción compleja se separa de su representación, de modo que el mismo proceso de construcción puede crear diferentes representaciones.
Este generador es en realidad muy similar al modo de plantilla, pero también hay diferencias, es decir, en el modo de plantilla, la clase principal opera en la implementación en la subclase y maneja una cosa en la clase principal, pero en el modo generador La clase de padres y la clase de niños no se preocupan por cómo manejarla, pero usan otra clase para completar la combinación orgánica de estos métodos. La responsabilidad de esta clase es supervisar y estipular cómo combinar estos métodos orgánicamente. En la clase Supervisor (Director), combine la clase padre y luego llame a la operación de la clase padre para lograr algo abstracto. Esta es la belleza de la interfaz orientada (abstracción). Por supuesto, este generador también puede hacer la interfaz. Es una clase abstracta, aquí usamos una clase abstracta.
Tres roles: constructor , constructor específico , supervisor , usuario (no estrictamente hablando)
- Rol del constructor : defina todos los métodos necesarios para generar una instancia;
- El rol de constructor específico : implementar todos los métodos necesarios para generar la instancia y definir el método para obtener la instancia final generada;
- Rol de supervisor : defina el método de utilizar el rol de generador para generar instancias;
- Usuario : usa el modo de generador.
Nota : La definición " separar un proceso de construcción complejo de su representación " significa que el constructor no es responsable de todo, pero el supervisor es responsable de controlar (definir) un proceso de construcción complejo, que es implementado por diferentes constructores. Todos los pasos de construcción utilizados en el proceso de construcción. De lo contrario, no se puede lograr el objetivo de "hacer que el mismo proceso de creación pueda crear representaciones diferentes".
El primer paso es crear una interfaz de constructor o una clase abstracta
package builder.demo.build;
/**
* 建造者抽象类也可以是接口
*/
public abstract class Builder {
StringBuffer buffer = new StringBuffer();//假设 buffer.toString() 就是最终生成的产品
public abstract void buildPart1();
public abstract void buildPart2();
public abstract void buildPart3();
public String getResult() {//定义获取最终生成实例的方法
return buffer.toString();
}
}La segunda parte, crea un constructor específico
package builder.demo.build;
/**
* 具体建造者1
*/
public class ConcreteBuilder1 extends Builder {
@Override
public void buildPart1() {//实现构建最终实例需要的所有方法
buffer.append("Builder1 : Part1\n");
}
@Override
public void buildPart2() {
buffer.append("Builder1 : Part2\n");
}
@Override
public void buildPart3() {
buffer.append("Builder1 : Part3\n");
}
}package builder.demo.build;
/**
* 具体建造者2
*/
public class ConcreteBuilder2 extends Builder{
@Override
public void buildPart1() {//实现构建最终实例需要的所有方法
buffer.append("Builder2 : Part1\n");
}
@Override
public void buildPart2() {
buffer.append("Builder2 : Part2\n");
}
@Override
public void buildPart3() {
buffer.append("Builder2 : Part3\n");
}
}El tercer paso es crear un trabajador de la construcción, que contiene el constructor y controla el proceso de construcción.
package builder.demo.director;
import builder.demo.build.Builder;
/**
* 监工
* 将一个复杂的构建过程与其表示相分离
*/
public class Director {
private Builder builder; // 针对接口编程，而不是针对实现编程
public Director(Builder builder) {
this.builder = builder;
}
/**
* 监工开始定义和控制构建的具体过程
*/
public void construct() {
builder.buildPart1();
for (int i = 0; i < 5; i++) {
builder.buildPart2();
}
builder.buildPart3();
}
}El cuarto paso, la prueba
package builder.demo;
import builder.demo.build.Builder;
import builder.demo.build.ConcreteBuilder1;
import builder.demo.build.ConcreteBuilder2;
import builder.demo.director.Director;
public class Client {
public static void main(String[] args) {
Builder b1 = new ConcreteBuilder1();//建造者1
Director director = new Director(b1);//监工
director.construct();//建造实例(监工负责过程的控制，建造者实际建造)
System.out.printf("the result is :%n%s", b1.getResult());//获取最终生成结果
Builder b2 = new ConcreteBuilder2();//建造者2
director = new Director(b2);//监工
director.construct();//建造实例(监工负责过程的控制，建造者实际建造)
System.out.printf("\nthe result is :%n%s", b2.getResult());//获取最终生成结果
}
}the result is :
Builder1 : Part1
Builder1 : Part2
Builder1 : Part2
Builder1 : Part2
Builder1 : Part2
Builder1 : Part2
Builder1 : Part3
the result is :
Builder2 : Part1
Builder2 : Part2
Builder2 : Part2
Builder2 : Part2
Builder2 : Part2
Builder2 : Part2
Builder2 : Part3
