Patrón de método de fábrica, también llamado patrón de constructor virtual o patrón de fábrica polimórfico.
1. Propósito: Definir una interfaz para crear objetos y dejar que las subclases decidan qué clase crear una instancia. El método Factory difiere la creación de instancias de una clase a sus subclases.
(Defina una interfaz para crear un objeto , pero deje que las subclases decidan qué clase crear una instancia. El método Factory permite que una clase difiera la creación de instancias a las subclases).
2. Participantes:
• Producto abstracto (Product): define la interfaz del objeto creado por el método factory.
• Producto Concreto: implementa la interfaz de un producto abstracto .
• Abstract Factory (Creator): declara un método de fábrica que devuelve un objeto de tipo de producto abstracto . Una fábrica abstracta también puede definir una implementación predeterminada de un método de fábrica que devuelve un objeto de producto concreto predeterminado . Se pueden llamar métodos de fábrica para crear un objeto de producto abstracto .
• Concrete Creator: redefina el método de fábrica para devolver una instancia de producto concreta .
3. Estructura:
Utilice ejemplos del mundo real para mapear la definición del patrón del método de fábrica, de la siguiente manera:
FAW-Volkswagen ( fábrica abstracta ) produce muchos modelos de automóviles ( productos abstractos ), y uno de ellos, el Audi A6 ( producto concreto ), es producido por el taller de producción Audi A6 ( fábrica de concreto ).
Si utiliza el patrón del método de fábrica para cumplir con los requisitos del Ejemplo 6 del artículo anterior: Notas sobre los patrones de diseño de Java para principiantes: patrón de fábrica simple :
FAW-Volkswagen (categoría de fábrica) produjo dos automóviles (productos abstractos), uno llamado Audi A6 (producto de hormigón) y el otro llamado Audi A8 (producto de hormigón).
Luego, la descripción de requisitos anterior debe modificarse ligeramente de la siguiente manera:
FAW-Volkswagen (fábrica abstracta) produjo dos automóviles (productos abstractos), uno se llama Audi A6 (producto de hormigón), producido por la fábrica Audi A6 (fábrica de hormigón) ; el otro se llama Audi A8 (producto de hormigón), producido por Audi Producido por la fábrica A8 (fábrica específica) .
Implementación del código Java, el Ejemplo 7 es el siguiente:
Coche (rol de producto abstracto):
/*
* 无论哪个工厂生产的汽车，都是汽车 （抽象产品类）
*/
public abstract class Car {
public String name;
}
Audi A6 (función de producto específica):
/*
* 奥迪A6，是一汽大众生产的一款汽车 （具体产品类）
*/
public class AudiA6Car extends Car {
public AudiA6Car(){
this.name = "奥迪A6";
}
public String toString(){
return "一辆"+ this.name;
}
}
Audi A8 (rol específico del producto):
/*
* 奥迪A8，是一汽大众生产的一款汽车 （具体产品类）
*/
public class AudiA8Car extends Car {
public AudiA8Car(){
this.name = "奥迪A8";
}
public String toString(){
return "一辆"+ this.name;
}
}
FAW-Volkswagen (rol abstracto de fábrica):
FAW-Volkswagen cambia su papel de fábrica a fábrica abstracta
/*
* 抽象工厂角色，使用接口来定义
*/
public interface CarFactory {
/*
* 生产汽车的工厂方法
*/
public Car manufactureCar();
}
Planta de producción de Audi A6 (función específica de fábrica):
Creó un nuevo rol de fábrica específico
/*
* 具体工厂(Concrete Factory)角色
*
* 生产奥迪A6的工厂
*/
public class AudiA6CarsFactory implements CarFactory {
/*
* 生产汽车的工厂方法
*/
public Car manufactureCar() {
// 奥迪A6
return new AudiA6Car();
}
}
Planta de producción de Audi A8 (función específica de fábrica):
Creó un nuevo rol de fábrica específico
/*
* 具体工厂(Concrete Factory)角色
*
* 生产奥迪A8的工厂
*/
public class AudiA8CarsFactory implements CarFactory {
/*
* 生产汽车的工厂方法
*/
public Car manufactureCar() {
// 奥迪A8
return new AudiA8Car();
}
}
La estructura de clases del código es la siguiente:
Llamada del cliente:
El cliente A (cliente) quiere comprar un Audi A6 y el cliente B (cliente) quiere comprar un Audi A8:
El método de llamada en el lado del cliente también ha cambiado y primero es necesario crear un objeto de fábrica específico.
public class Customers {
public static void main(String[] args){
// 实例化生产奥迪A6的工厂
CarFactory audiA6CarFactory = new AudiA6CarsFactory();
// 实例化生产奥迪A８的工厂
CarFactory audiA8CarFactory = new AudiA8CarsFactory();
System.out.println("===========顾客A买奥迪A6===========");
// 顾客A想买一辆奥迪A6,那么工厂需要生产奥迪A6
Car myCarA6 = audiA6CarFactory.manufactureCar();
System.out.println("奥迪A6被造好，并且出厂了。");
// 顾客A得到了他想要的汽车
System.out.println("我终于买了"+myCarA6+"。真是太好了！");
System.out.println("===========顾客B买奥迪A8===========");
// 顾客B想买一辆奥迪A8,那么工厂需要生产奥迪A8
Car myCarA8 = audiA8CarFactory.manufactureCar();
System.out.println("奥迪A8被造好，并且出厂了。");
// 顾客B得到了他想要的汽车
System.out.println("我终于买了"+myCarA8+"。真是太好了！");
}
}
resultado de la operación:
===========顾客A买奥迪A6===========
奥迪A6被造好，并且出厂了。
我终于买了一辆奥迪A6。真是太好了！
===========顾客B买奥迪A8===========
奥迪A8被造好，并且出厂了。
我终于买了一辆奥迪A8。真是太好了！
Comparando el patrón de fábrica simple en el Ejemplo 6 , se puede ver que la clase de fábrica original CarFactory se cambió a una clase abstracta (interfaz) y se agregaron dos nuevas clases de fábrica concretas (que implementan la interfaz de fábrica) para crear dos productos diferentes respectivamente.
¿Cuáles son los beneficios de hacer esto?
1. Satisfacer el principio de "abierto-cerrado":
1) Imaginemos que FAW-Volkswagen planea producir un tercer modelo de coche, el Audi A10.
Si usamos el patrón de fábrica simple en el Ejemplo 6 , necesitamos modificar la clase de fábrica CarFactory para agregar la lógica de creación de nuevos modelos de automóviles. Esta modificación del código existente probablemente traerá mucha incertidumbre al sistema estable existente. Errores y Riesgos .
Si usamos el patrón del método de fábrica , no necesitamos modificar las clases existentes, solo necesitamos agregar una clase de producto específica y una clase de fábrica específica. Es fácil de ampliar sin cambiar la estabilidad del sistema existente.
2) Además, los métodos de fábrica estáticos ya no se utilizan en el patrón de métodos de fábrica (cambiados a métodos ordinarios), lo que facilita la expansión de las clases de fábrica basadas en la estructura jerárquica de herencia.
Por ejemplo: el Audi A6 también se divide en diferentes categorías de modelos, incluidos el rojo y el negro. Si los procesos de producción de estos dos colores del Audi A6 también son muy diferentes, se necesitarán diferentes fábricas para producirlos. Luego, puede crear dos subclases de AudiA6CarsFactory, AudiA6RedCarsFactory y AudiA6BlackCarsFactory , para realizar una expansión conveniente y de bajo riesgo de la producción de diferentes niveles de productos automotrices.
2. Cumple con el principio de "alta cohesión y bajo acoplamiento":
Combinando 1) y 2) de 1 anterior, se puede encontrar que con la expansión horizontal de productos del mismo nivel y la expansión vertical de la jerarquía de productos. Todo ello aumenta la complejidad de la creación de productos en las fábricas.
Si se adopta el patrón de fábrica simple , una clase de fábrica se convierte en una clase universal, integrando los complejos procesos de creación de varios productos en uno, lo que viola el principio de "alta cohesión y bajo acoplamiento" en los sistemas de software . En términos de mantenimiento y expansión, Durante el proceso, se sentirá muy difícil y peligroso.
Si se utiliza el patrón del método de fábrica , las responsabilidades de crear diferentes productos se desacoplarán, de modo que cada fábrica pueda centrarse en la creación de un producto, satisfaciendo el principio de "alta cohesión y bajo acoplamiento" , haciendo que el mantenimiento y la expansión del sistema más eficiente, fácil y seguro.