Constructor: separe la construcción de un objeto complejo de su representación, para que el mismo proceso de construcción pueda crear diferentes representaciones.
Use escenarios:
Diagrama de clase general:
Por ejemplo: muchos dispositivos en nuestras vidas existen en forma de ensamblaje, como computadoras de escritorio. Algunos fabricantes lanzarán algunos hosts de computadora ensamblados con configuraciones predeterminadas (el modo de método de plantilla se puede usar aquí). Los clientes pueden comprar productos con configuraciones predeterminadas, o pueden pedir a los fabricantes que vuelvan a ensamblar un host con diferentes configuraciones y métodos de ensamblaje. En este punto, podemos usar el modelo Builder para cumplir con los requisitos de los clientes especiales.
Tenga en cuenta que en este ejemplo, el fabricante está reensamblando un host, es decir, el enfoque está en cada componente del host, que está en línea con el escenario de uso dado por el modo de constructor anterior.
La implementación del código simple es la siguiente:
// clase de producto abstracto, utilizando el modo de método de plantilla, diferentes productos tienen diferentes "parte" de componente "clase abstractsproduct {proteged abstract void parte01 (); Resumen protegido Void Parte02 (); Resumen protegido Void Parte03 (); // El método de plantilla proporciona el método de ensamblaje predeterminado, generando el producto predeterminado público final abstractproduct Defaultproduct () {Part01 (); parte02 (); parte03 (); devuelve esto; // devuelve el objeto actual, es decir, el producto con el método de ensamblaje predeterminado}} // productos específicos A y B, diferentes productos implementan diferentes clases de "Parte de componentes" ConcretUducta extiende abstractproduct {protegido void parte1 () {System.Println ("Producto A: Part01 () ...); } protegido void parte02 () {system.out.println ("producto a: parte02 () ..."); } protegido void parte03 () {system.out.println ("producto a: parte03 () ..."); }} class ConcretEpreductB extiende AbstractProduct {Protected Void Part01 () {System.out.println ("Producto B: Parte01 () ..."); } protegido void parte02 () {system.out.println ("producto b: parte02 () ..."); } protegido void parte03 () {system.out.println ("producto b: parte03 () ..."); }} // Resumen Builder, formula el método de combinación que cada producto debe implementar buildPart () y estándar para producir buildProduct () abstract clase abstractBuilder {public abstract void buildPart (); Public Abstract ResumenProduct BuildProduct (); } / * * Si el constructor específico no está satisfecho con el producto predeterminado (es decir, cuando se llama el método predeterminadoproduct () en el producto abstracto), * no puede llamarlo para obtener el producto, pero use el constructor específico para cambiar el método de producción y ensamblaje del producto para obtener diferentes productos * / class ConcreteBuilda extiende AbstractBuilder {Producto de abstracto privado = nuevo ConcretepretepretepretepretuptA () ();););););););););););););) public void buildPart () {this.producta.part03 (); this.producta.part02 (); this.producta.part01 (); } public AbstractProduct BuildProduct () {return this.productA; }} La clase ConcreteBuilderb extiende AbstractBuilder {privado abstractproduct productob = new ConcretEpRediCtb (); public void buildPart () {this.productb.part02 (); this.productb.part01 (); // se omite un componente en el producto B, por ejemplo, las funciones de esta parte no son necesarias por los clientes // this.productb.part03 (); } public AbstractProduct BuildProduct () {return this.productb; }} // La clase Director, el constructor que pre-mantiene cada producto, proporciona diferentes métodos de ensamblaje para usuarios que necesitan productos diferentes a los Director de clase de producto predeterminado {privado AbstractBuilder buildA = new ConcreteBuilda (); privado abstractBuilder buildB = new ConcreteBuilderb (); public AbstractProduct getProductA () {this.Builda.BuildPart (); devuelve this.builda.buildProduct (); } public AbstractProduct GetProductB () {this.BuilderB.BuildPart (); devolver esto.builderb.buildProduct (); }} // Test Clase Class Client Client {public static void main (string [] args) {system.out.println ("Use el modo de método de plantilla para obtener el producto predeterminado a"); AbstractProduct DefaultProductA = new ConcretepRroductA (). DefaultProduct (); System.out.println ("/clase de director de NUSE para obtener el producto A con diferentes métodos de ensamblaje"); Director director = nuevo director (); director.getProductA (); System.out.println ("/clase de director de NUSE para obtener el producto B con diferentes métodos de ensamblaje"); director.getProductB (); }} Resultados de la prueba:
Use el modo de método de plantilla para obtener el producto predeterminado a
PRODUCTO A: PART01 () ...
PRODUCTO A: PART02 () ...
Producto A: Parte03 () ...
Use la clase Director para obtener productos con diferentes métodos de ensamblaje A
Producto A: Parte03 () ...
PRODUCTO A: PART02 () ...
PRODUCTO A: PART01 () ...
Use la clase Director para obtener el producto B con diferentes métodos de ensamblaje
PRODUCTO B: PART02 () ...
PRODUCTO B: PART01 () ...
De hecho, en este ejemplo, la categoría de producto utiliza el modo de método de plantilla mencionado en el artículo anterior, es decir, defaultproduct () proporciona un método para ensamblar un componente predeterminado del producto.
Pero tengo una pregunta aquí. El llamado método de ensamblaje predeterminado proporcionado en la clase AbstractProduct basada en el patrón del método de plantilla es solo para imprimir algunas oraciones de prueba, y realmente no devuelve un producto específico. Sin embargo, no sé si el método de procesamiento para devolver un objeto actual (devuelva esto;) en el ejemplo anterior es razonable.
Además, después de escribir estos artículos sobre la implementación de patrones de diseño con código Java, descubrí que este patrón de constructor de constructor parece combinar el patrón de fábrica abstracto y el patrón de método de plantilla. El párrafo anterior ya ha mencionado mis dudas. En cuanto al modelo de fábrica abstracta, personalmente creo que la clase de director en el ejemplo de código anterior es muy similar a la clase de fábrica específica de la fábrica abstracta, pero la clase del director también tiene que construir el método de ensamblaje del producto antes de devolver un producto. Tal vez es esta "construcción" la que hace que el modelo de constructor se centre en el ensamblaje de varias partes del producto, mientras que el modelo de fábrica abstracta solo se centra en la generación de un producto final.
He leído una oración antes y dije que se dice aproximadamente: si algún problema de la computadora es difícil de resolver, se puede manejar agregando una capa intermedia. Ahora que lo pienso, parece que tanto la fábrica abstracta como el modo de constructor usan este "principio" para lograr el efecto deseado. Por ejemplo, hay una clase de fábrica abstracta en Abstract Factory, y hay una clase de director en constructor. En el análisis final, es encapsular y ocultar ciertos detalles y desacoplarlos de la implementación y uso.
Creo que primero debe comprender las preocupaciones y los escenarios aplicables de cada modelo antes de que pueda comprenderlas mejor.
Tal vez estos modos son todos modos creativos y no tengo ninguna experiencia práctica, lo que me confunde un poco ... No tengo miedo, pensar un poco en el proceso de implementarlos a todos, y aplicarlos lentamente a la realidad debería entender gradualmente.
Lo anterior se trata de este artículo, y espero que te inspire a aprender.