Enlaces relacionados:

[Patrón de diseño] Columna: [Patrón de diseño] Columna

Se pueden descargar códigos de muestra relevantes: Ejemplos de patrones de diseño comunes en Java

Introducción

En la actualidad, el modo de fábrica se divide aproximadamente en tres tipos, a saber:

Patrón de fábrica simple
patrón de método de fábrica
patrón de fábrica abstracto

Patrón de fábrica simple

El patrón de fábrica simple (Simple Factory Pattern) es un patrón de creación , también conocido como patrón Static Factory Method (Patrón de método de fábrica estática) , pero no pertenece a uno de los 23 patrones de diseño GOF. El patrón de fábrica simple es determinar qué instancia de una clase de producto creará un objeto de fábrica. El patrón de fábrica simple es el patrón más simple y práctico de la familia de patrones de fábrica, que puede entenderse como una implementación especial de diferentes patrones de fábrica.

efecto:

Separe la operación de "creación de instancias de clase" de la operación de "uso de objeto", de modo que los usuarios puedan instanciar la clase de "producto" requerida sin conocer los parámetros específicos, evitando así la especificación explícita en el código del cliente y realizando el desacoplamiento.

protagonista

Rol de fábrica específico (Creador)

El núcleo del patrón de fábrica simple, que es responsable de implementar la lógica interna de crear todas las instancias. El mundo exterior puede llamar directamente al método de creación de una clase de producto en la clase de fábrica para crear el objeto de producto requerido.

Rol de producto abstracto

La clase principal de todos los objetos creados por el patrón de fábrica simple, que es responsable de describir la interfaz pública compartida por todas las instancias.

Papel del producto concreto

El objetivo de creación del patrón de fábrica simple, todos los objetos creados son instancias de una clase específica que desempeña este papel.

Toma una castaña:

Supongamos que hay una máquina de bebidas (fábrica) que puede llamar bebidas de varios sabores (productos abstractos), y hay tres botones (parámetros) correspondientes a estas tres bebidas (productos concretos). En este momento, puede elegir su bebida favorita haciendo clic en el botón.

Producto abstracto : Product.java

/**
 * 简单工厂模式——抽象产品
 * 说明：
 * 描述产品的公共接口
 *
 */
public abstract class Product {
    /**
     * 产品介绍
     */
    public abstract void introduce();
}

Productos específicos : CocoProduct.java, MilkProduct.java, CofficeProduct.java

/**
 * 简单工厂模式——具体产品 A
 *
 * （可以看成是一种饮料：可乐）
 *
 */
public class CocoProduct extends Product{

    @Override
    public void introduce() {
        System.out.println("可乐");
    }
}


/**
 * 简单工厂模式——具体产品 B
 *
 *（可以看成是一种饮料：奶茶）
 *
 */
public class MilkProduct extends Product{

    @Override
    public void introduce() {
        System.out.println("奶茶");
    }
}


/**
 * 简单工厂模式——具体产品 C
 *
 * （可以看成是一种饮料：咖啡）
 *
 */
public class CofficeProduct extends Product{

    @Override
    public void introduce() {
        System.out.println("咖啡");
    }
}

Fábrica de hormigón : SimpleFactory.java

/**
 * 简单工厂模式——具体工厂
 * 
 * 负责实现创建所有实例的内部逻辑，并提供一个外接调用的方法，创建所需的产品对象
 *
 */
public class SimpleFactory {

    /**
     * 提供给外接调用的方法
     * （可以看成是对外提供的三个小按钮）
     *
     * @param type 产品类型
     * @return FactoryPattern.SimpleFactoryPattern.Product
     */
    public static Product getProduct(String type) {
        switch (type) {
            case "coco":
                return new CocoProduct();
            case "milk":
                return new MilkProduct();
            case "coffice":
                return new CofficeProduct();
            default:
                return null;
        }
    }

}

Prueba: SimpleFactoryDemo.java

/**
 * 简单工厂模式
 *
 */
public class SimpleFactoryDemo {

    public static void main(String[] args) {
        // 创建具体的工厂
        SimpleFactory factory = new SimpleFactory();
        // 根据传入的参数生产不同的产品实例
        // （按下不同的按钮，获取饮料）
        Product coco = SimpleFactory.getProduct("coco");
        coco.introduce();
        Product milk = SimpleFactory.getProduct("milk");
        milk.introduce();
        Product coffice = SimpleFactory.getProduct("coffice");
        coffice.introduce();
    }

}

Según las castañas se puede describir como:

Una clase de producto abstracto puede derivar múltiples clases de productos concretos
Una clase de fábrica específica, al staticpasar diferentes parámetros al método de esta fábrica, se producen diferentes instancias de clases de productos específicos

Ventajas y desventajas

ventaja

Separe el trabajo de creación y uso, no se preocupe por cómo se crea el objeto de clase y logre el desacoplamiento
Poner el trabajo de inicializar la instancia en la fábrica hace que el código sea más fácil de mantener. Más en línea con los principios orientados a objetos y la programación orientada a la interfaz, en lugar de la programación orientada a la implementación

defecto

La clase de fábrica concentra la lógica de creación de todas las instancias (productos), una vez que la fábrica no funcione correctamente, todo el sistema se verá afectado.
Violando el principio de "abrir-cerrar", una vez que se agrega un nuevo producto, la lógica de la clase de fábrica debe modificarse, lo que hará que la lógica de fábrica sea demasiado complicada.
El patrón de fábrica simple utiliza métodos de fábrica estáticos, y los métodos estáticos no se pueden heredar ni reescribir, lo que hará que los roles de fábrica no se formen.

patrón de método de fábrica

El patrón de método de fábrica, también conocido como patrón de fábrica (Factory Pattern) , patrón de fábrica polimórfico y patrón de constructor virtual, es responsable de definir la interfaz pública para crear objetos mediante la definición de la clase padre de fábrica, mientras que la subclase es responsable de generar objetos específicos. . (¡comúnmente utilizado!)

efecto:

La instanciación de la clase (creación de productos específicos) se retrasa a la subclase de la clase fábrica (fábrica de hormigón), es decir, la subclase decide qué clase se debe instanciar (crear).

protagonista

Función de fábrica abstracta

Describe la interfaz pública de una fábrica de hormigón.

Papel de la fábrica de hormigón

Describa la fábrica específica, cree una instancia del producto para llamadas externas, realice principalmente el método abstracto en la fábrica abstracta y complete la creación del producto específico.

Rol de producto abstracto

Responsable de describir la interfaz pública del producto, definir la especificación del producto y describir las características y funciones principales del producto.

Papel del producto concreto

Describe los productos específicos producidos, implementa la interfaz definida por el rol de producto abstracto y es creado por la fábrica específica, que corresponde a la fábrica específica uno por uno.

Toma una castaña:

Suponiendo que hay varias máquinas de bebidas (fábricas abstractas), se pueden llamar varias bebidas (productos abstractos). Sin embargo, un tipo de máquina de bebidas (fábrica específica) solo puede producir un tipo de bebida (producto específico). Si necesita beber Coca-Cola, debe comprar una máquina de bebidas Coca-Cola.

Producto abstracto : Product.java

/**
 * 工厂方法模式——抽象产品
 *
 */
public abstract class Product {
    /**
     * 产品介绍
     */
    public abstract void introduce();
}

Productos específicos : ProductA.java, ProductB.java

/**
 * 工厂方法模式——具体产品A
 *
 */
public class ProductA extends Product{
    @Override
    public void introduce() {
        System.out.println("饮料A");
    }
}


/**
 * 工厂方法模式——具体产品B
 *
 */
public class ProductB extends Product{
    @Override
    public void introduce() {
        System.out.println("饮料B");
    }
}

Fábrica abstracta : Factory.java

/**
 * 工厂方法模式——抽象工厂
 *
 */
public abstract class Factory {
    /**
     * 生产产品
     *
     * @return FactoryPattern.FactoryPattern.Product
     */
    public abstract Product getProduct();
}

Fábricas específicas : FactoryA.java, FactoryB.java

/**
 * 工厂方法模式——具体工厂A
 *
 * （负责具体的产品A生产）
 *
 */
public class FactoryA extends Factory{
    @Override
    public Product getProduct() {
        return new ProductA();
    }
}


/**
 * 工厂方法模式——具体工厂B
 *
 * （负责具体的产品B生产）
 *
 */
public class FactoryB extends Factory{
    @Override
    public Product getProduct() {
        return new ProductB();
    }
}

Prueba : FactoryDemo.java

/**
 * 工厂方法模式
 *
 */
public class FactoryDemo {

    public static void main(String[] args) {
        // 创建具体的工厂
        FactoryA factoryA = new FactoryA();
        // 生产相对应的产品
        factoryA.getProduct().introduce();
        FactoryB factoryB = new FactoryB();
        factoryB.getProduct().introduce();
    }

}

Según las castañas se pueden describir como

Una clase de producto abstracto puede derivar múltiples clases de productos concretos
Una clase de fábrica abstracta que puede derivar múltiples clases de fábrica concretas
Cada clase de fábrica concreta solo puede crear una instancia de una clase de producto concreta

Ventajas y desventajas

ventaja

Cumplir con el "principio de abrir-cerrar" y tener una alta escalabilidad: al agregar un nuevo producto, solo necesita agregar la categoría de producto específica correspondiente y la subcategoría de fábrica correspondiente
Cumplir con el principio de responsabilidad única: cada clase de fábrica específica solo es responsable de crear los productos correspondientes

defecto

Mayor complejidad del sistema: el número de clases aumentará en pares
Mayor abstracción y dificultad de comprensión del sistema.
Una fábrica específica solo puede crear un producto específico

patrón de fábrica abstracto

Abstract Factory Pattern (Patrón de fábrica abstracta) es crear otras fábricas alrededor de una súper fábrica. La súper fábrica también es conocida como la fábrica de otras fábricas. Este tipo de patrón de diseño es un patrón de creación, que proporciona una forma óptima de crear objetos.

En el patrón Abstract Factory, las interfaces son fábricas responsables de crear un objeto relacionado sin especificar su clase explícitamente. Cada fábrica generada puede proporcionar objetos según el patrón de fábrica.

La mayor diferencia entre el patrón de fábrica abstracto y el patrón de método de fábrica :

En una fábrica abstracta, cada fábrica puede crear múltiples tipos de productos.

En el método de fábrica, cada fábrica solo puede crear un tipo de producto

efecto

Permite el uso de interfaces abstractas para crear un conjunto de productos relacionados sin saber ni importar cuál es el producto concreto real, de modo que pueda desacoplarse del producto concreto.

protagonista

Función de fábrica abstracta

Describe la interfaz pública de una fábrica de hormigón.

Papel de la fábrica de hormigón

Describir la fábrica específica y crear una instancia del producto para llamadas externas

Rol de familia de productos abstractos (producto abstracto)

Describe la interfaz pública del producto abstracto.

Rol de producto abstracto

Describir la interfaz pública de un producto específico

Papel del producto concreto

Describa el producto específico producido.

Toma una castaña:

Supongamos que hay varios tipos de máquinas expendedoras (fábricas abstractas) que pueden vender varios tipos de alimentos (familias de productos abstractos).

Hay bebidas y snacks (productos abstractos), como máquinas expendedoras comunes al por menor (fábricas de hormigón), venta de agua mineral y pan (productos de hormigón).

Familia de productos abstractos : Product.java

/**
 * 抽象工厂模式——抽象产品族（食品）
 *
 */
public abstract class Product {
    /**
     * 产品介绍
     */
    public abstract void introduce();
}

Producto abstracto : ProductA.java, ProductB.java

/**
 * 抽象工厂模式——抽象产品（饮料）
 *
 */
public abstract class ProductA extends Product{
}


/**
 * 抽象工厂模式——抽象产品（零食）
 *
 */
public abstract class ProductB extends Product{
}

Productos específicos : ProductAa.java, ProductBb.java

/**
 * 抽象工厂模式——具体产品
 *
 */
public class ProductAa extends ProductA{
    @Override
    public void introduce() {
        System.out.println("矿泉水");
    }
}


/**
 * 抽象工厂模式——具体产品
 *
 */
public class ProductBb extends ProductB{
    @Override
    public void introduce() {
        System.out.println("面包");
    }
}

Fábrica abstracta : AbstractFactory.java

/**
 * 抽象工厂模式——抽象工厂
 *
 */
public abstract class AbstractFactory {
    /**
     * 生产饮料
     */
    public abstract Product getProductA();
    /**
     * 生产零食
     */
    public abstract Product getProductB();
}

Fábrica específica : AbstractFactoryA.java

/**
 * 抽象工厂模式——具体工厂
 *
 * 负责具体的A类产品生产
 *
 */
public class AbstractFactoryA extends AbstractFactory{
    @Override
    public Product getProductA() {
        // 生产矿泉水
        return new ProductAa();
    }

    @Override
    public Product getProductB() {
        // 生产面包
        return new ProductBb();
    }
}

Prueba : AbstractFactoryDemo.java

/**
 * 抽象工厂模式
 *
 */
public class AbstractFactoryDemo {

    public static void main(String[] args) {
        // 创建零食售卖机（具体工厂）
        AbstractFactoryA abstractFactoryA = new AbstractFactoryA();
        // 获取矿泉水与面包（具体产品）
        abstractFactoryA.getProductA().introduce();
        abstractFactoryA.getProductB().introduce();
    }

}

Según los ejemplos, se puede describir como:

Múltiples clases de productos abstractos, cada producto abstracto puede derivar múltiples clases de productos concretos
Una clase de fábrica abstracta que puede derivar múltiples clases de fábrica concretas
Cada clase de fábrica específica puede crear múltiples instancias de clases de productos específicos

Ventajas y desventajas

ventaja

reducir el acoplamiento
Cumple con el "principio abierto-cerrado"
Cumple con el Principio de Responsabilidad Única
En lugar de usar métodos de fábrica estáticos, se puede formar una estructura jerárquica basada en herencia
Cuando se diseñan varios objetos en una familia de productos para trabajar juntos, se garantiza que los clientes siempre usen solo objetos de la misma familia de productos.

defecto

Es difícil expandir nuevos tipos de productos, para agregar un determinado producto en una serie, es necesario agregar código al producto abstracto y agregar código al específico.

conclusión

1. Para obtener más patrones de diseño, consulte la columna [Patrones de diseño]

2. Se pueden descargar códigos de muestra relevantes: Ejemplos de patrones de diseño comunes en Java

PD: [ Ejemplo de patrones de diseño comunes en Java] ha incluido el código involucrado en la columna [Patrón de diseño] . Si lo ha descargado antes, no necesita descargarlo de nuevo ~

Si el contenido anterior es incorrecto o debe complementarse, solicite más consejos y se actualizará y corregirá a tiempo ~

Los comentarios son bienvenidos ~ Gracias por sus elogios ~

Patrón de diseño: patrón de fábrica (incluido: patrón de fábrica simple, patrón de método de fábrica, patrón de fábrica abstracto)

Introducción

Patrón de fábrica simple

efecto:

protagonista

Ventajas y desventajas

patrón de método de fábrica

efecto:

protagonista

Ventajas y desventajas

patrón de fábrica abstracto

efecto

protagonista

Ventajas y desventajas

conclusión

Supongo que te gusta