Compartir tecnología

Patrón de creación de patrones de diseño

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

El patrón constructor en los patrones de diseño es un patrón de diseño de creación de objetos de uso común, que se utiliza principalmente para resolver problemas complejos de construcción de objetos. Aquí hay una introducción detallada al modo constructor:

1. Definición

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. En otras palabras, funciona dividiendo el proceso de construcción de objetos complejos en una serie de pasos simples y permitiendo a los usuarios crear diferentes objetos especificando el orden y los parámetros de estos pasos.

2. Diagrama y estructura de clases.

Diagrama de clase

En el modo constructor, normalmente se incluyen los siguientes roles:

  1. Rol del producto (Producto): Representa un objeto complejo en construcción, que normalmente contiene varios componentes.
  2. Constructor abstracto: Defina una interfaz abstracta para crear varios componentes de objetos de producto.
  3. ConcretoConstructor: Implemente la interfaz Builder, complete los métodos de creación específicos de cada componente de un producto complejo y defina una interfaz que devuelva el producto final.
  4. Director : Responsable de llamar a los métodos de construcción y ensamblaje de componentes en el objeto constructor para completar la creación de objetos complejos. No implica información específica del producto, sino que simplemente desacopla al cliente del constructor.

3. Escenarios aplicables

El patrón Builder es adecuado para los siguientes escenarios:

  1. La estructura del objeto es compleja.: Cuando el objeto que se debe construir tiene una estructura interna compleja y contiene múltiples propiedades y métodos, el uso del patrón de construcción puede simplificar el proceso de construcción.
  2. El proceso de construcción es complejo.: Cuando el proceso de construcción de un objeto implica varios pasos y el orden y los parámetros de estos pasos pueden ser diferentes, el patrón de construcción puede proporcionar un proceso de construcción claro.
  3. Creación y uso desacoplados: Cuando desee separar los procesos de creación y uso de objetos para que los usuarios solo deban preocuparse por la representación final del objeto y no por los detalles de la creación del objeto, el patrón de creación es una buena opción.

4. Ventajas y desventajas

ventaja
  1. Buena encapsulación: Encapsula el proceso de construcción de objetos complejos dentro del constructor. El cliente solo necesita especificar el tipo y parámetros de la construcción para obtener el producto final sin conocer los detalles del proceso de construcción.
  2. Buena escalabilidad: Si necesita agregar un nuevo tipo de compilación o modificar el proceso de compilación, solo necesita agregar o modificar la clase de compilación, lo que no afectará el código del cliente.
  3. Alta flexibilidad: Flexibilidad para crear diferentes instancias de productos cambiando el orden de construcción o los parámetros del constructor.
defecto
  1. Aumentar el número de clases.: Debido a la necesidad de crear múltiples clases, como interfaces de constructor, clases de constructor específicas y clases de comandante, se puede aumentar la cantidad de clases en el sistema.
  2. Dificultad en la modificación interna.: Si la estructura interna del producto cambia, es posible que sea necesario modificar varias clases de constructores, lo que aumenta el costo de mantenimiento del sistema.

5. Ejemplo

En el siguiente ejemplo, utilizaremos el patrón Builder para diseñar un sistema de renovación de una casa.Definiremos unHouse Las clases son objetos complejos que contienen múltiples componentes de decoración (como techos, pinturas, pisos, baldosas, etc.).Entonces, definimos unHouseBuilder Interfaz que contiene métodos abstractos para crear estos componentes. A continuación, creamos clases de constructores específicas para cada estilo de decoración específico (como estilo europeo de lujo, pastoral de lujo ligero, minimalista moderno).Finalmente, pasaremos unDirectorclase para guiar el proceso de construcción, pero puede que no sea necesario en este ejemplo ya que podemos definir la lógica de construcción completa directamente en la clase de construcción.

Sin embargo, para demostrar el concepto del rol de director, conservaremos unDirectorclase, pero solo con fines ilustrativos, de hecho, el proceso de construcción se puede realizar directamente en la clase constructora.

  1. // 房屋类  
  2. public class House {  
  3.     private String ceiling; // 吊顶  
  4.     private String paint;   // 涂料  
  5.     private String floor;   // 地板  
  6.     private String tiles;   // 地砖  
  7.   
  8.     // 私有构造函数  
  9.     private House() {}  
  10.   
  11.     // Getter 方法  
  12.     public String getCeiling() {  
  13.         return ceiling;  
  14.     }  
  15.   
  16.     public String getPaint() {  
  17.         return paint;  
  18.     }  
  19.   
  20.     public String getFloor() {  
  21.         return floor;  
  22.     }  
  23.   
  24.     public String getTiles() {  
  25.         return tiles;  
  26.     }  
  27.   
  28.     // 建造者接口  
  29.     public interface HouseBuilder {  
  30.         HouseBuilder buildCeiling(String ceiling);  
  31.         HouseBuilder buildPaint(String paint);  
  32.         HouseBuilder buildFloor(String floor);  
  33.         HouseBuilder buildTiles(String tiles);  
  34.         House build();  
  35.     }  
  36.   
  37.     // 豪华欧式建造者  ,注意是静态内部类
  38.     public static class LuxuryEuropeanBuilder implements HouseBuilder {  
  39.         private House house;  
  40.   
  41.         public LuxuryEuropeanBuilder() {  
  42.             this.house = new House();  
  43.         }  
  44.   
  45.         @Override  
  46.         public HouseBuilder buildCeiling(String ceiling) {  
  47.             house.ceiling = "豪华欧式吊顶: " + ceiling;  
  48.             return this;  
  49.         }  
  50.   
  51.         @Override  
  52.         public HouseBuilder buildPaint(String paint) {  
  53.             house.paint = "豪华欧式涂料: " + paint;  
  54.             return this;  
  55.         }  
  56.   
  57.         @Override  
  58.         public HouseBuilder buildFloor(String floor) {  
  59.             house.floor = "豪华欧式地板: " + floor;  
  60.             return this;  
  61.         }  
  62.   
  63.         @Override  
  64.         public HouseBuilder buildTiles(String tiles) {  
  65.             house.tiles = "豪华欧式地砖: " + tiles;  
  66.             return this;  
  67.         }  
  68.   
  69.         @Override  
  70.         public House build() {  
  71.             return house;  
  72.         }  
  73.     }  
  74.   
  75.     // ... 可以为其他风格创建类似的建造者类  
  76.   
  77.     // 指挥者类（可选，这里主要用于展示概念）  
  78.     public static class Director {  
  79.         private HouseBuilder builder;  
  80.   
  81.         public Director(HouseBuilder builder) {  
  82.             this.builder = builder;  
  83.         }  
  84.   
  85.         // 这里可以添加方法来指导建造过程，但在这个例子中，我们直接在建造者中完成了所有工作  
  86.         public House constructHouse() {  
  87.             // 假设这是由指挥者指导的步骤，但在这里我们直接返回建造者的结果  
  88.             return builder  
  89.                 .buildCeiling("水晶吊灯")  
  90.                 .buildPaint("金色镶边涂料")  
  91.                 .buildFloor("大理石地板")  
  92.                 .buildTiles("马赛克地砖")  
  93.                 .build();  
  94.         }  
  95.     }  
  96.   
  97.     // 主函数，用于演示  
  98.     public static void main(String[] args) {  
  99.         HouseBuilder luxuryBuilder = new LuxuryEuropeanBuilder();  
  100.         // Director director = new Director(luxuryBuilder); // 如果使用指挥者  
  101.   
  102.         House house = luxuryBuilder  
  103.                 .buildCeiling("水晶吊灯")  
  104.                 .buildPaint("金色镶边涂料")  
  105.                 .buildFloor("大理石地板")  
  106.                 .buildTiles("马赛克地砖")  
  107.                 .build();  
  108.   
  109.         System.out.println("Ceiling: " + house.getCeiling());  
  110.         System.out.println("Paint: " + house.getPaint());  
  111.         System.out.println("Floor: " + house.getFloor());  
  112.         System.out.println("Tiles: " + house.getTiles());  
  113.     }  
  114. }

Tenga en cuenta que en este ejemplo,DirectorLas clases en realidad no agregan mucho valor ya que toda la lógica de compilación ya está encapsulada enHouseBuilder La interfaz está implementada. Pero en aplicaciones más complejas,DirectorLas clases se pueden utilizar para encapsular el orden y la lógica del proceso de construcción, especialmente cuando el proceso de construcción abarca varios constructores.

6. Conclusión

A través de la introducción anterior, se puede ver que el patrón de construcción tiene grandes ventajas al construir objetos complejos. Mejora la encapsulación y escalabilidad del código al separar el proceso de construcción de la representación, y también reduce la comunicación entre el cliente y lo específico. producto. grado de acoplamiento entre.

Si este artículo es útil para su estudio, recuerde darle me gusta y recopilarlo.

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo