contenido
Patrón de fábrica simple (Patrón de fábrica estático) Fábrica simple
Método de fábrica Patrón Método de fábrica
patrón de fábrica
Función : se da cuenta de la separación del creador y la persona que llama y nos ayuda a crear instancias de objetos.
Esencia central : crear instancias de objetos con fábricas en lugar de nuevas operaciones
Seleccionaremos la clase de implementación y crearemos objetos para la administración y el control unificados, desvinculando así a la persona que llama de nuestra clase de implementación.
El patrón de fábrica es un patrón de desacoplamiento típico
Satisfacer los siete principios de OOP:
principio abierto-cerrado
Principio de inversión de dependencia
Ley de Deméter (pésalo bien)
Clasificación:
Patrón de fábrica simple: se utiliza para generar cualquier producto en la misma estructura jerárquica (para agregar nuevos productos, se debe ampliar el código existente).
Patrón de método de fábrica: se utiliza para generar productos fijos en la misma estructura jerárquica (admite agregar cualquier producto).
Patrón de fábrica abstracta: crea otras fábricas alrededor de una súper fábrica.
Escenarios aplicables : como patrón de creación de clase, el patrón de método de fábrica se puede usar en cualquier lugar donde se necesite generar objetos complejos. Una cosa a tener en cuenta es que los objetos complejos son adecuados para usar el patrón de fábrica, mientras que los objetos simples, especialmente los objetos que solo pueden ser creados por new , no necesitan usar el patrón de fábrica. Cuando el sistema necesita tener una mejor escalabilidad, se puede considerar el modo de fábrica y se ensamblan diferentes productos con diferentes fábricas de implementación.
De hecho, el Patrón Creacional abstrae el proceso de creación de instancias de una clase y puede separar la creación y el uso de objetos en módulos de software .
El patrón de creación proporciona al diseñador de software la mayor flexibilidad posible en términos de qué crear (Qué) , quién lo crea (Quién) y cuándo crearlo (Cuándo) .
Patrón de fábrica simple (Patrón de fábrica estático) Fábrica simple
Es crear una clase de fábrica para crear instancias de algunas clases que implementen la misma interfaz.
Los roles en el patrón de fábrica simple son: fábrica, producto, cliente. Vea el siguiente ejemplo:
Primero podemos mirar el diagrama de clases.
El código de implementación específico es el siguiente:
Crear una interfaz de coche
public interface Car {
public void name();
}
Escribir dos clases de implementación
public class WuLing implements Car{
@Override
public void name() {
System.out.println("五菱宏光");
}
}
public class Tesla implements Car{
@Override
public void name() {
System.out.println("特斯拉");
}
}
Crear una clase de fábrica
public class CarFactory{
public static Car getCar(String car) {
if(car.equals("五菱")) {
return new WuLing();
}else if(car.equals("特斯拉")) {
return new Tesla();
}else {
return null;
}
}
}tener una prueba
public class Comsumer {
public static void main(String[] args){
Car car1 = CarFactory.getCar("五菱");
Car car2 = CarFactory.getCar("特斯拉");
car1.name();
car2.name();
}
}El resultado de la salida:
No necesito preocuparme por cómo se hizo el auto, solo necesito proporcionar un nombre y retirarlo de la fábrica.
Podemos sentir claramente los inconvenientes de este modo. Si ahora queremos agregar una clase de implementación de la interfaz Car y agregar un automóvil Volkswagen, debemos modificar el método getCar() en la fábrica, lo que viola el principio abierto-cerrado. .
Por supuesto, podemos modificar los métodos en la clase de fábrica y obtener lo que necesitamos sin tener que ingresar parámetros.
public class CarFactory{
public static Car getWuLing(){
return new WuLing();
}
public static Car getTesla(){
return new Tesla();
}
}De hecho, esto no satisface nuestras necesidades, todavía necesitamos modificar el código, pero no se modificará en la lógica del código como el método anterior.
Problemas con el patrón de fábrica simple:
viola el principio abierto-cerrado
Violando el principio de distribución de responsabilidad de alta cohesión, toda la lógica de creación se centraliza en una clase de fábrica.
Método de fábrica Patrón Método de fábrica
El patrón de método de fábrica es un desacoplamiento adicional del patrón de fábrica simple, que es equivalente a dividir la clase de fábrica simple que habría sido enorme debido al código comercial en clases de fábrica individuales, de modo que el código no se acople a la misma clase. en.
Aunque el patrón de método de fábrica y el patrón de fábrica simple crean objetos a través de fábricas, la mayor diferencia entre ellos es que el patrón de método de fábrica se ajusta completamente al " principio abierto-cerrado " en el diseño.
Solo mira el ejemplo:
El código específico se implementa de la siguiente manera:
La interfaz del automóvil, la clase Tesla y la clase WuLing permanecen sin cambios
Crear interfaz de fábrica de automóviles
public interface CarFactory{
public Car getCar();
}Cree la clase de implementación TeslaFactory factory class y WuLingFactory class de la interfaz de fábrica de automóviles
public class TeslaFactory implements CarFactory{
@Override
public Car getCar(){
return new Tesla();
}
}
public class WuLingFactory implements CarFactory{
@Override
public Car getCar(){
return new WuLing();
}
}examen final
public class Comsumer {
public static void main(String[] args){
Car car1 = new WuLingFactory.getCar();
Car car2 = new TeslaFactory.getCar();
car1.name();
car2.name();
}
}Dado que el ejemplo dado aquí no involucra el problema de los parámetros, nuestro sentimiento no es muy obvio. Imagínese, ¿qué pasa si hay muchos parámetros en la clase Tesla o la clase WuLing? Este método es amigable para los consumidores, no es necesario que nos importe cómo se fabrica el automóvil, su método de fábrica correspondiente lo instanciará, solo necesitamos llamar al método en la fábrica.
Aquí creo que el diagrama de flujo del dios loco puede ser más claro (agregar capa)
El patrón del método de fábrica se puede utilizar en las siguientes situaciones:
Una clase no conoce la clase de los objetos que necesita.
Una clase especifica qué objeto crear a través de sus subclases
ventaja:
Una persona que llama y quiere crear un objeto solo necesita saber su nombre.
Alta escalabilidad, si desea agregar un producto, solo necesita extender una clase de fábrica.
La implementación específica del producto está protegida y la persona que llama solo se preocupa por la interfaz del producto.
defecto:
Cada vez que se agrega un producto, se debe agregar una fábrica de implementación de clases y objetos concretos, lo que duplica el número de clases en el sistema, aumenta la complejidad del sistema hasta cierto punto y también aumenta la dependencia de las clases concretas del sistema. . Esto no es bueno.
Patrón de fábrica abstracto
El patrón de fábrica abstracto es relativo al patrón de método de fábrica, es decir, el patrón de método de fábrica es para una serie de productos, mientras que el patrón de fábrica abstracto es para varias series de productos.
Definición : el patrón de fábrica abstracto proporciona una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases concretas. El patrón de fábrica abstracto es una fábrica de fábricas.
Personalmente, creo que significa agregar otra capa, por supuesto, esta es solo mi opinión personal.
Antes de contar el caso, necesitamos conocer los dos conceptos de familia de producto y nivel de producto:
Ahora veamos un caso específico:
Primero cree la interfaz del teléfono y la interfaz del enrutador
//手机产品接口
public interface IPhoneProduct {
void start();
void shutdown();
void callup();
void sendSMS();
}
//路由器产品接口
public interface IRouterProduct {
void start();
void shutdown();
void openWifi();
void setting();
}Luego cree dos clases de implementación de interfaces de teléfonos móviles: teléfono móvil Xiaomi y teléfono móvil Huawei
//小米手机
public class XiaoMiPhone implements IPhoneProduct{
@Override
public void start() {
System.out.println("开启小米手机");
}
@Override
public void shutdown() {
System.out.println("关闭小米手机");
}
@Override
public void callup() {
System.out.println("小米手机打电话");
}
@Override
public void sendSMS() {
System.out.println("小米手机发短信");
}
}
//华为手机
public class HuaWeiPhone implements IPhoneProduct{
@Override
public void start() {
System.out.println("开启华为手机");
}
@Override
public void shutdown() {
System.out.println("关闭华为手机");
}
@Override
public void callup() {
System.out.println("华为手机打电话");
}
@Override
public void sendSMS() {
System.out.println("华为手机发短信");
}
}Cree clases de implementación para dos interfaces de enrutador: enrutador Xiaomi y enrutador Huawei
//小米路由器
public class XiaoMiRouter implements IRouterProduct {
@Override
public void start() {
System.out.println("启动小米路由器");
}
@Override
public void shutdown() {
System.out.println("关闭小米路由器");
}
@Override
public void openWifi() {
System.out.println("小米路由器打开WiFi");
}
@Override
public void setting() {
System.out.println("小米路由器设置");
}
}//华为路由器
public class HuaWeiRouter implements IRouterProduct {
@Override
public void start() {
System.out.println("启动华为路由器");
}
@Override
public void shutdown() {
System.out.println("关闭华为路由器");
}
@Override
public void openWifi() {
System.out.println("华为路由器打开WiFi");
}
@Override
public void setting() {
System.out.println("华为路由器设置");
}
}Escribir una fábrica de productos abstractos para fabricar.
//抽象产品工厂
public interface IProductFactory {
//生产手机
IPhoneProduct iphoneProduct();
//生产路由器
IRouterProduct irouterProduct();
}Crear una clase de implementación para una fábrica de productos abstractos
//小米工厂
public class XiaoMiFactory implements IProductFactory {
@Override
public IPhoneProduct iphoneProduct() {
return new XiaoMiPhone();
}
@Override
public IRouterProduct irouterProduct() {
return new XiaoMiRouter();
}
}
//华为工厂
public class HuaWeiFactory implements IProductFactory {
@Override
public IPhoneProduct iphoneProduct() {
return new HuaWeiPhone();
}
@Override
public IRouterProduct irouterProduct() {
return new HuaWeiRouter();
}
}Escriba una prueba de cliente:
public class Client {
public static void main(String[] args) {
System.out.println("**********华为系列***********");
//华为工厂
HuaWeiFactory huaweiFactory = new HuaWeiFactory();
IPhoneProduct huaweiPhone = huaweiFactory.iphoneProduct();
huaweiPhone.start();
huaweiPhone.callup();
}
}resultado de la operación:
Escenarios aplicables: el cliente (capa de aplicación) no depende de los detalles de cómo se crea e implementa la instancia de clase de producto. Enfatiza que una serie de objetos de productos relacionados (que pertenecen a la misma familia de productos) se usan juntos para crear objetos que requieren una gran cantidad de código repetitivo para proporcionar una biblioteca de clases de productos, todos los productos aparecen con la misma interfaz, de modo que el cliente no no depende de la implementación específica
ventaja:
Aislamiento de código de productos específicos en la capa de aplicación, sin necesidad de preocuparse por los detalles de la creación
Crear una familia de productos juntos
defecto:
Especifica todos los conjuntos de productos posibles que se pueden crear y la dificultad de expandir nuevos productos en la familia de productos;
Aumenta la abstracción y la dificultad de comprensión del sistema.
resumen
Patrón de fábrica simple: aunque no se ajusta a los principios de diseño hasta cierto punto, en realidad se usa más
Patrón de método de fábrica: extienda agregando nuevas clases de fábrica sin modificar las clases existentes
Patrón de fábrica abstracto: no puede agregar productos, puede agregar familias de productos
(Broma: No hay nada que no se pueda solucionar añadiendo una capa)
Al final del estudio, debemos tener una cosa clara, es decir, no pongas el carro delante del caballo. Aprendemos patrones de diseño para diseñar mejor el software, no para usar un patrón de diseño determinado.