Modo constructor
definición
El modo de constructor es un modo de creación de objetos, que puede separar la apariencia interna de un producto del proceso de producción del producto, de modo que un proceso de producción puede generar objetos de producto con diferentes apariencias internas.
El modo de constructor oculta al cliente la estructura del producto y el proceso de construcción de la pieza del producto, y separa la responsabilidad de dirigir el proceso de construcción de la responsabilidad de las piezas específicas del constructor para lograr el propósito de la división de responsabilidad y el empaque.
intención
Separar una construcción compleja de su representación para que el mismo proceso de construcción pueda crear diferentes representaciones.
Principalmente resuelve el problema
La principal solución es que en los sistemas de software, a veces se enfrentan a la creación de "un objeto complejo", que generalmente está compuesto por subobjetos de varias partes con un algoritmo determinado; debido a cambios en los requisitos, varias partes de este objeto complejo a menudo enfrentar cambios severos, pero el algoritmo que los combina es relativamente estable
Cuándo usar
Algunos componentes básicos no cambiarán y cuando su combinación cambie a menudo
Pros y contras
ventaja:
- Constructor independiente, fácil de expandir
- Riesgos detallados fáciles de controlar
Desventajas:
- Los productos deben tener algo en común y tener un alcance limitado
- Si los cambios internos son complicados, habrá muchos tipos de construcción.
estructura
Roles involucrados:
- Rol de constructor abstracto (Builder): se proporciona una interfaz abstracta para estandarizar la construcción de los diversos componentes del objeto del producto. En términos generales, el número de piezas y el número de métodos de construcción contenidos en el producto son iguales, en otras palabras, cómo muchos Hay tantos métodos de construcción correspondientes como cada pieza
- El rol del constructor de concreto (ConcreteBuilder): implementa la interfaz declarada por el constructor abstracto y proporciona una operación paso a paso para completar la creación de instancias de producto; una vez completado el proceso de construcción, proporcione instancias de producto
- Rol de director: la clase que asume este rol llama al rol de constructor específico para crear objetos de producto. El rol de director no tiene conocimiento específico de la categoría de producto. El conocimiento específico de la categoría de producto es el rol de constructor específico.
- Función del producto: un producto es un objeto complejo en construcción. En términos generales, habrá más de una categoría de producto en un sistema, y estas categorías de productos no necesariamente tienen una interfaz común, pero pueden no estar relacionadas en absoluto.
En términos generales, para cada categoría de producto, existe una categoría de constructor específica correspondiente. Estos productos deben tener el mismo número de partes, y para cada parte, hay un método de construcción correspondiente en todos los roles de constructor.
El código fuente es el siguiente:
public interface Builder {
/** 产品零件构造方法 */
void buildPart1();
/** 产品零件构造方法 */
void buildPart2();
/** 产品返还方法 */
Product retrieveResult();
}
public class ConcreteBuilder implements Builder {
private Product product = new Product();
/** 产品零件构造方法 */
@Override
public void buildPart1() {
//建造产品的第一个零件
}
/** 产品零件构造方法 */
@Override
public void buildPart2() {
//建造产品的第二个零件
}
/** 产品返还方法 */
@Override
public Product retrieveResult() {
return product;
}
}
public class Director {
private Builder builder;
/**
* 产品构造方法，负责调用各个零件构造方法
*/
public void construct() {
builder = new ConcreteBuilder();
builder.buildPart1();
builder.buildPart2();
builder.retrieveResult();
}
}
public class Product {
}
Ejemplo de montaje de una computadora
La computadora se ensambla con memoria, placa base, cpu, chasis, etc., que se pueden ensamblar de acuerdo con diferentes pasos
Categoría de computadora:
public class Compute {
/** cpu */
private String cpu;
/** 主板 */
private String board;
/** 内存 */
private String memory;
/** 机箱 */
private String crate;
public String getCpu() {
return cpu;
}
public void setCpu(String cpu) {
this.cpu = cpu;
}
public String getBoard() {
return board;
}
public void setBoard(String board) {
this.board = board;
}
public String getMemory() {
return memory;
}
public void setMemory(String memory) {
this.memory = memory;
}
public String getCrate() {
return crate;
}
public void setCrate(String crate) {
this.crate = crate;
}
@Override
public String toString() {
return "Compute{" +
"cpu='" + cpu + '\'' +
", board='" + board + '\'' +
", memory='" + memory + '\'' +
", crate='" + crate + '\'' +
'}';
}
}
Resuma el papel del constructor y abstraiga los pasos para ensamblar una computadora:
public interface ComputeBuilder {
/** 组装CPU */
void buildCpu();
/** 组装主板 */
void buildBoard();
/** 组装内存 */
void buildMemory();
/** 组装机箱 */
void buildCrate();
/** 组装完成，返回一台电脑 */
Compute getCompute();
}
El rol específico del constructor, la operación de ensamblar cada pieza:
public class ConcreteComputeBuilder implements ComputeBuilder {
private Compute compute = new Compute();
@Override
public void buildCpu() {
System.out.println("组装cpu");
compute.setCpu("组装cpu");
}
@Override
public void buildBoard() {
System.out.println("组装主板");
compute.setBoard("组装主板");
}
@Override
public void buildMemory() {
System.out.println("安装内存条");
compute.setMemory("安装内存条");
}
@Override
public void buildCrate() {
System.out.println("安装机箱");
compute.setCrate("安装机箱");
}
@Override
public Compute getCompute() {
return compute;
}
}
Iniciar montaje:
public class ComputeDirector {
private ComputeBuilder builder;
public void assemblyCompute() {
builder = new ConcreteComputeBuilder();
builder.buildCpu();
builder.buildBoard();
builder.buildMemory();
builder.buildCrate();
System.out.println(builder.getCompute());
}
}
Categoría de prueba:
public class Client {
public static void main(String[] args) {
ComputeDirector director = new ComputeDirector();
director.assemblyCompute();
}
}
