1 Definición
Definición Oficial: Separar la construcción de objetos complejos de sus representaciones para que un mismo proceso de construcción pueda crear diferentes representaciones.
Entiendo personalmente que al crear un objeto, se requieren muchos pasos, y estos pasos básicamente no cambian, por ejemplo, dibujar una figura, torso, extremidades, cabeza, siete orificios en la cabeza, la composición básica de una persona es fija. , nosotros abstraiga los pasos en una interfaz de constructor o clase abstracta. Para generar este objeto, entrégueselo al constructor para que lo construya, y el constructor puede obtenerlo directamente y expresarlo.
2 Estructura e Implementación
El diagrama de estructura del patrón constructor es el siguiente:
El modo constructor consta de cuatro elementos: producto, constructor abstracto, constructor concreto y conductor. El comandante a veces no puede, como se explica en la Sección 6.2 del siguiente código.
Las funciones principales del modo Constructor son las siguientes:
1. Producto: Es un objeto complejo que contiene múltiples componentes, cada uno de los cuales es creado por un constructor específico.
2. Constructor abstracto (Builder): es una interfaz que contiene métodos abstractos para crear varios subcomponentes de un producto y, por lo general, también contiene un método getProduct() que devuelve un producto complejo (Producto).
3. Concrete Builder: implemente la interfaz Builder para completar el método de creación específico de cada componente del producto complejo.
4. Director (Director): llama a los métodos de construcción y ensamblaje de componentes en el objeto constructor para completar la creación de objetos complejos, y no involucra información específica del producto en el director.
3 Ventajas y desventajas
3.1 Ventajas
1. Buena encapsulación, separación de construcción y presentación.
2. Buena escalabilidad, cada constructor específico es independiente entre sí, lo que favorece el desacoplamiento del sistema.
3. El cliente no necesita conocer los detalles de la composición interna del producto, y el constructor puede refinar gradualmente el proceso de creación sin ningún impacto en otros módulos, lo cual es conveniente para controlar el riesgo de los detalles.
3.2 Desventajas
1. Los componentes del producto deben ser los mismos, lo que limita el alcance de su uso.
2. Si los cambios internos del producto son complicados, si ocurren cambios internos del producto, el constructor también debe modificarlo simultáneamente, y el costo de mantenimiento en el período posterior es relativamente grande.
4 escenarios aplicables
1. El mismo método, diferente orden de ejecución, produce diferentes resultados.
2. Se pueden ensamblar múltiples componentes o partes en un objeto, pero los resultados no son los mismos.
3. La clase de producto es muy compleja, o diferentes secuencias de llamada en la clase de producto tienen efectos diferentes.
4. La inicialización de un objeto es particularmente complicada, con muchos parámetros y muchos parámetros tienen valores predeterminados.
5 La diferencia entre el patrón de constructor y el patrón de fábrica
La única diferencia entre el patrón de construcción y el patrón de fábrica es la creación de objetos complejos. Es decir, si crea objetos simples, generalmente usa el patrón de fábrica para crearlos, y si crea objetos complejos, puede considerar usar el patrón de construcción.
En concreto, existen las siguientes diferencias:
1. El patrón de construcción presta más atención a la secuencia de llamada de los métodos, y el patrón de fábrica se centra en la creación de objetos.
2. La fuerza de la creación de objetos es diferente. El modo constructor crea objetos complejos, que se componen de varios componentes complejos. Los objetos creados por el modo de fábrica son todos iguales.
3. El enfoque es diferente. El patrón de fábrica solo necesita crear el objeto, mientras que el patrón de construcción no solo necesita crear el objeto, sino que también sabe de qué componentes está compuesto el objeto.
4. El modo constructor es diferente según el orden en el proceso de construcción, y los componentes del objeto final también son diferentes.
6 ejemplos de código
El ejemplo de código incluye dos partes, una parte es el patrón de construcción formado por Director, Constructor y Producto, y la otra parte es la construcción de ensamblaje desordenado de partes a través de una clase interna estática.
6.1 Patrón constructor formado por Director, Constructor y Producto
Ensamblaje de computadora (producto), hay placa base, CPU, memoria, disco duro, carcasa, cinco pasos, el constructor Foxconn es responsable de ensamblar para nosotros, Lenovo es nuestro comandante, no necesitamos comprar una computadora de Foxconn, pero a Lenovo.
6.1.1 Productos Informáticos Informática
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 11:08
**/
public class Computer {
List<String> components = new ArrayList<>();
public void show(){
System.out.println("computer include: ");
for (String s: components) {
System.out.println(s);
}
}
}6.1.2 Montaje de la interfaz abstracta de la computadora ComputerBuilder
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 11:11
**/
public interface ComputerBuilder {
/**
* 组装主板
*/
void constructBoard();
/**
* 组装cpu
*/
void constructCpu();
/**
* 组装内存条
*/
void constructMemory();
/**
* 组装硬盘
*/
void constructHardDisk();
/**
* 组长机箱壳
*/
void constructCase();
/**
* 返回电脑成品
* @return 电脑
*/
Computer getComputer();
}
6.1.3 Constructor específico Foxconn Builder
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 11:20
**/
public class FoxconnBuilder implements ComputerBuilder{
private Computer computer = new Computer();
@Override
public void constructBoard() {
computer.components.add("lenovo board");
}
@Override
public void constructCpu() {
computer.components.add("lenovo cpu");
}
@Override
public void constructMemory() {
computer.components.add("lenovo memory");
}
@Override
public void constructHardDisk() {
computer.components.add("lenovo hard disk");
}
@Override
public void constructCase() {
computer.components.add("lenovo case");
}
@Override
public Computer getComputer(){
return computer;
}
}6.1.4 Director de Lenovo Director de Lenovo
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 11:31
**/
public class LenovoDirector {
private ComputerBuilder computerBuilder;
public LenovoDirector(ComputerBuilder computerBuilder){
this.computerBuilder = computerBuilder;
}
public Computer getComputer(){
computerBuilder.constructBoard();
computerBuilder.constructCpu();
computerBuilder.constructMemory();
computerBuilder.constructHardDisk();
computerBuilder.constructCase();
return computerBuilder.getComputer();
}
}6.1.5 Función principal
public class MainClass {
public static void main(String[] args) {
LenovoDirector lenovoDirector = new LenovoDirector(new FoxconnBuilder());
Computer computer = lenovoDirector.getComputer();
computer.show();
}
}6.1.6 Resultados de ejecución
6.2 El método de clase interna estática realiza la estructura de piezas fuera de orden de ensamblaje
Ensamblaje del teléfono móvil (producto), hay cuatro pasos de placa base, CPU, almacenamiento, carcasa del teléfono móvil, el constructor Quanta es responsable del ensamblaje por nosotros, Apple le pide directamente a Quanta que recoja los productos para obtener el teléfono móvil, sin comandante, Quanta ensambla el teléfono móvil en cuatro pasos Se puede intercambiar según sea necesario.
6.2.1 Productos de telefonía móvil Teléfono
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 11:08
**/
public class Telephone {
List<String> components = new ArrayList<>();
public void show(){
System.out.println("telephone include: ");
for (String s: components) {
System.out.println(s);
}
}
}6.2.2 Montaje de la interfaz abstracta del teléfono móvil TelephoneBuilder
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 12:06
**/
public interface TelephoneBuilder {
/**
* 组装主板
* @return 手机构建者
*/
TelephoneBuilder constructBoard();
/**
* 组装cpu
* @return 手机构建者
*/
TelephoneBuilder constructCpu();
/**
* 组装存储
* @return 手机构建者
*/
TelephoneBuilder constructMemory();
/**
* 组长手机壳
* @return 手机构建者
*/
TelephoneBuilder constructCase();
/**
* 返回电脑成品
* @return 电脑
*/
Telephone getTelephone();
}6.2.3 Constructor cuántico
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 12:04
**/
public class QuantaBuilder implements TelephoneBuilder{
private Telephone telephone;
public QuantaBuilder(){
this.telephone = new Telephone();
}
@Override
public TelephoneBuilder constructBoard() {
telephone.components.add("apple board");
return this;
}
@Override
public TelephoneBuilder constructCpu() {
telephone.components.add("apple cpu");
return this;
}
@Override
public TelephoneBuilder constructMemory() {
telephone.components.add("apple memory");
return this;
}
@Override
public TelephoneBuilder constructCase() {
telephone.components.add("apple case");
return this;
}
@Override
public Telephone getTelephone() {
return telephone;
}
}6.2.4 Función principal
/**
* @program: design-pattern-learning
* @author: zgr
* @create: 2021-09-26 11:08
**/
public class MainClass {
public static void main(String[] args) {
QuantaBuilder quantaBuilder = new QuantaBuilder();
Telephone telephone = quantaBuilder.
constructBoard()
.constructMemory()
.constructCpu()
.constructCase()
.getTelephone();
telephone.show();
}
}6.2.5 Resultados de ejecución
6.3 Resumen
Hay dos implementaciones de código. La primera tiene un comandante, que es adecuado para el caso en que los pasos de construcción no cambian. La segunda es una implementación flexible de clases internas estáticas, y no hay requisitos especiales para la secuencia de cada paso. .
7 citas
1. "Patrones de diseño Dahua"
2. Comprenda el patrón Builder de patrones de diseño en segundos
3. Explicación detallada del modo constructor (modo Bulider)
4. Patrones de diseño de Java - Patrón de constructor