El modo constructor (CONSTRUCTOR) también se denomina modo generador (CONSTRUCTOR). Su definición es la siguiente: (Consulte los patrones de diseño de GoF y "Java y patrones" de Yan Hong)
1. Intención:
Separar la construcción de un objeto complejo de su representación, de modo que un mismo proceso de construcción pueda crear diferentes representaciones.
2. Participantes:
• Generador abstracto (Builder): especifica interfaces abstractas para cada componente que crea un objeto de producto (Prodcut) .
• Constructor de Concreto (ConcretBuilder):
Implemente la interfaz del constructor abstracto (Builder) para construir y ensamblar los distintos componentes del producto.
Definir y aclarar la representación que crea.
Proporciona una interfaz para recuperar productos.
• Director: construye un objeto utilizando la interfaz abstracta del Constructor .
• Producto(Prodcut):
Representa un objeto complejo construido. El Concrete Builder (ConcretBuilder) crea una representación interna del producto y define su proceso de ensamblaje.
Contiene clases que definen los componentes, incluidas las interfaces que ensamblan esas piezas en el producto final.
3. Estructura:
De acuerdo con el patrón de diseño de GoF, describamos la relación de colaboración entre los distintos roles cuando utilizamos el patrón BUILDER:
1. El cliente crea un objeto Director y lo configura con un objeto ConcretBuilder del Constructor abstracto que desea.
2. Cuando sea necesario crear un determinado componente del producto (PartOne, PartTwo, ...), el Director (Director) notificará al constructor específico (ConcretBuilder) .
3. El constructor específico (ConcretBuilder) maneja la solicitud del director y agrega las partes (PartOne, PartTwo, ...) al producto (Prodcut) .
4. El cliente recupera el producto (Prodcut) del constructor de hormigón (ConcretBuilder) .
===============Interludio=================================
Al referirme a "Conceptos básicos de patrones de diseño para software orientado a objetos reutilizables" (versión china de patrones de diseño GOF), no puedo entender la segunda descripción de colaboración en el patrón Builder:
Una vez generada la parte del producto, el director notifica al generador. (Consulta la Wikipedia china, también está traducida de esta manera)
En comparación con el trabajo original en inglés, se describe de la siguiente manera:
El director notifica al constructor cada vez que se debe construir una parte del producto.
Entonces, ¿debería traducirse con el siguiente significado?
El director notifica al generador cuando es necesario (debe) crearse un componente del producto .
(En otras palabras, el director notifica al generador una vez que es necesario generar la pieza del producto ) .
Esto puede ser demasiado serio, pero personalmente creo que las dos expresiones chinas del primero y del primero deberían tener significados diferentes.
==================================================== ===
Comprenda el patrón del constructor basándose en ejemplos de la vida real . Utilicemos la producción de automóviles como ejemplo. Ejemplo 9
El cliente quiere comprar un coche FAW-Volkswagen.
Un automóvil es en realidad una familia de productos, es decir, un conjunto (una serie) de productos de autopartes (familias de productos).
La estructura de un coche es muy compleja. Tiene ruedas, volante, asientos, motor, color, etc.
¿Por qué este ejemplo parece tan familiar?
1. Parece ser muy similar al artículo anterior: Notas sobre patrones de diseño de Java para principiantes - Patrón abstracto de fábrica :
Ambos pueden crear objetos complejos (colecciones de productos o familias de productos).
Esto es lo que dicen los patrones de diseño de GoF:
Abstract Factory es similar a Builder en que también puede crear objetos complejos. La principal diferencia es que el patrón Builder se centra en construir un objeto complejo paso a paso. Abstract Factory se centra en múltiples series de objetos de productos (simples o complejos).
En otras palabras, el patrón Builder se ocupa de cómo ensamblar los diversos componentes (o productos componentes) de productos complejos;
El modelo Abstract Factory se ocupa de qué componentes (o productos componentes) se ensamblan.
2. Parece ser muy similar a otra nota anterior sobre patrones de diseño de Java para principiantes: Factory Pattern :
Revise las ventajas del patrón de fábrica y compárelo con el propósito del patrón de constructor :
El patrón de fábrica se puede utilizar para separar el proceso de creación y el uso de objetos (es decir, desacoplar).
El patrón constructor separa la construcción de un objeto complejo de su representación, permitiendo que el mismo proceso de construcción cree diferentes representaciones.
Personalmente pienso,
El patrón constructor se centra más en un proceso de creación (construcción) regular u ordenado;
El proceso de creación (construcción) del patrón de fábrica es relativamente informal.
De hecho, también puedes entender sus diferencias entre los dos nombres de fábrica y constructor :
Los constructores se parecen más al equipo de producción de una fábrica .
A la fábrica sólo le importa qué producto produce, y sólo sabe de qué está hecho el producto;
El constructor debe considerar cómo producir el producto y las reglas y métodos de composición del mismo.
En otras palabras, hasta cierto punto, el patrón de construcción es como refinar algunas de las responsabilidades del rol de fábrica en el patrón de fábrica .
El director guía la producción del producto y el constructor implementa la producción específica.
Continuando con este ejemplo para experimentar el patrón de construcción:
Constructor de resúmenes:
/*
* 建造者
*/
public interface CarBuilder {
/**
* 建造汽车的框架
*/
public void buildeCarSkeleton();
/**
* 给汽车装上发动机
*/
public void buildeCarEngine();
/**
* 给汽车装上轮子
*/
public void buildeCarWheels();
/**
* 给汽车装上导航设备
*/
public void buildeCarNavigation();
/**
* 安装车身（包含车门、车窗的安装，涂颜色）
*/
public void buildeCarBody();
}
Constructor específico: (Produce Audi A6)
Director:
Aquí, el director ordena al constructor que produzca el automóvil de una manera determinada ( con un sistema de navegación instalado ).
/*
* 导演者
*/
public class AudiDirector {
CarBuilder builder;
/**
* 为导演者配置一个建造者
*/
public AudiDirector(CarBuilder builder){
this.builder = builder;
}
/**
* 按照一定的方式或规则建造汽车
*/
public void contruct(){
builder.buildeCarSkeleton();
builder.buildeCarEngine();
builder.buildeCarNavigation();
builder.buildeCarWheels();
builder.buildeCarBody();
}
}
Coches Audi (productos):
/*
* 产品
*/
public class AudiCar {
private String carSkeleton;
private Engine carEngine;
private String carWheels;
private String carNavigation = "";
private String carDoor;
private String carWindscreen;
private String carColor;
public AudiCar(){ }
/**
* 汽车的颜色
*/
public void setCarColor(String carColor) {
this.carColor = carColor;
}
/**
* 汽车的车门
*/
public void setCarDoor(String carDoor) {
this.carDoor = carDoor;
}
/**
* 汽车发动机，发动机在这里是一个对象
*/
public void setCarEngine(Engine carEngine) {
this.carEngine = carEngine;
}
/**
* 汽车的框架
*/
public void setCarSkeleton(String carSkeleton) {
this.carSkeleton = carSkeleton;
}
/**
* 汽车轮子
*/
public void setCarWheels(String carWheels) {
this.carWheels = carWheels;
}
/**
* 汽车的挡风玻璃
*/
public void setCarWindscreen(String carWindscreen) {
this.carWindscreen = carWindscreen;
}
/**
* 汽车导航
*/
public void setNavigation(String navigation) {
this.carNavigation = navigation;
}
/**
* 一个汽车对象的描述
*/
public String toString(){
return carSkeleton+ "," + carEngine.toString() +"," + carWheels + "," +
carDoor + "," + carWindscreen + "," + carColor + "," + carNavigation;
}
}
Un objeto componente del automóvil:
/*
* 一个部件对象（汽车发动机）
*/
public class Engine {
private String name;
public Engine(String name){
this.name = name;
}
public String toString(){
return this.name;
}
}
Cliente:
/*
* 客户端
*/
public class Clients {
public static void main(String[] args) {
// 创建一个建造者对象
AudiCarBuilder builder = new AudiCarBuilder();
// 创建一个导演者，并为它配置一个建造者
AudiDirector director1 = new AudiDirector(builder);
// 导演者将通知建造者去创建产品
// 在这个过程中，建造者将会根据导演者的请求，去创建组织并创建产品对象
director1.contruct();
// 从具体建造者中检索产品（返回的是带导航的汽车产品）。
AudiCar audiCar = builder.retrieveCar();
System.out.println(audiCar);
}
}
resultado de la operación:
汽车框架,奥迪A6发动机,车轮,车门,挡风玻璃,黑色,汽车导航
Si desea producir un automóvil Audi A6 sin sistema de navegación, ¿cómo lograrlo?
Solo necesito modificar el director.
Nuevo Director: (instruye al constructor a no instalar el sistema de navegación )
/*
* 导演者
*/
public class AudiDirector {
CarBuilder builder;
/**
* 为导演者配置一个建造者
*/
public AudiDirector(CarBuilder builder){
this.builder = builder;
}
/**
* 按照一定的方式或规则建造汽车
*/
public void contruct(){
builder.buildeCarSkeleton();
builder.buildeCarEngine();
// 不安装导航系统
// builder.buildeCarNavigation();
builder.buildeCarWheels();
builder.buildeCarBody();
}
}
Resultados de ejecución: ( sin sistema de navegación )
汽车框架,奥迪A6发动机,车轮,车门,挡风玻璃,黑色,
Si desea producir un automóvil Audi A8 con sistema de navegación, ¿cómo lograrlo?
(Suponiendo que la única diferencia entre el Audi A6 y el Audi A8 es el motor)
Simplemente modifique la clase de constructor.
Constructor: ( simplemente cambie su propia implementación interna : cambie el motor Audi A6 por el motor Audi A8)
/*
* 具体建造者
*/
public class AudiCarBuilder implements CarBuilder {
private AudiCar audiCar = new AudiCar();
/**
* 安装车身（包含车门、车窗的安装，涂颜色）
*/
public void buildeCarBody() {
audiCar.setCarDoor("车门");
audiCar.setCarWindscreen("挡风玻璃");
audiCar.setCarColor("黑色");
}
/**
* 给汽车装上发动机
*/
public void buildeCarEngine() {
Engine audiEngine = new Engine("奥迪A8发动机");
audiCar.setCarEngine(audiEngine);
}
/**
* 给汽车装上导航设备
*/
public void buildeCarNavigation() {
audiCar.setNavigation("汽车导航");
}
/**
* 建造汽车的框架
*/
public void buildeCarSkeleton() {
audiCar.setCarSkeleton("汽车框架");
}
/**
* 给汽车装上轮子
*/
public void buildeCarWheels() {
audiCar.setCarWheels("车轮");
}
public AudiCar retrieveCar(){
return audiCar;
}
}
Resultados de funcionamiento: ( reemplazado con motor Audi A8 )
汽车框架,奥迪A8发动机,车轮,车门,挡风玻璃,黑色,汽车导航
En este ejemplo podemos ver las ventajas del patrón constructor:
1. El director puede especificar diferentes métodos de producción (si se instala la navegación) y el constructor puede obtener diferentes productos sin realizar ningún cambio.
2. El director no necesita cambiar el método de producción deseado, el constructor solo necesita cambiar su implementación interna (qué tipo de motor elegir), y también puede obtener diferentes productos.
Para obtener más información sobre los efectos del modo constructor, consulte el "Patrón de diseño" de GoF.
/*
* 具体建造者
*/
public class AudiCarBuilder implements CarBuilder {
private AudiCar audiCar = new AudiCar();
/**
* 安装车身（包含车门、车窗的安装，涂颜色）
*/
public void buildeCarBody() {
audiCar.setCarDoor("车门");
audiCar.setCarWindscreen("挡风玻璃");
audiCar.setCarColor("黑色");
}
/**
* 给汽车装上发动机
*/
public void buildeCarEngine() {
Engine audiEngine = new Engine("奥迪A6发动机");
audiCar.setCarEngine(audiEngine);
}
/**
* 给汽车装上导航设备
*/
public void buildeCarNavigation() {
audiCar.setNavigation("汽车导航");
}
/**
* 建造汽车的框架
*/
public void buildeCarSkeleton() {
audiCar.setCarSkeleton("汽车框架");
}
/**
* 给汽车装上轮子
*/
public void buildeCarWheels() {
audiCar.setCarWheels("车轮");
}
public AudiCar retrieveCar(){
return audiCar;
}
}