El "modelo de fábrica" de patrones de diseño escritos para mí

1. Modelo de fábrica simple

También conocido como modo de método de fábrica estática (Static Factory Method), pertenece al modo de creación, que define específicamente una clase para ser responsable de crear instancias de otras clases. Las instancias creadas suelen tener una clase padre común.

1.1 escena

• La clase de fábrica es responsable de crear menos objetos y no hará que la lógica empresarial sea demasiado complicada.
• El cliente solo conoce los parámetros pasados ​​a la clase de fábrica y no le importa cómo crear la clase

1.2 Ventajas

• Se realiza la división de responsabilidades, la clase de fábrica es responsable de crear los objetos del producto y el cliente es responsable del "consumo", y no es necesario recordar el nombre de la clase de la clase de producto.

1.3 Desventajas

• La clase de fábrica es responsable de la creación de todos los productos, una vez que no funcione, afectará a todo el sistema.
• Violación del principio de apertura y cierre. Una vez que necesite agregar productos, debe modificar la lógica de implementación de la clase de fábrica. Demasiados productos pueden hacer que la lógica de la clase de fábrica sea complicada.
• Debido a que el modelo de fábrica simple utiliza métodos de fábrica estáticos, los métodos estáticos no se pueden heredar ni reescribir, lo que provocará que el rol de fábrica no forme una jerarquía basada en la herencia.

1. 创建teacher接口
/**
 * teacher接口，定义方法
 *
 * @author dkangle
 */
public interface Teacher {
    
    
    void teach();
}

2. 实现teacher接口
/**
 * 数学老师
 *
 * @author dkangel
 */
public class MathTeacher implements Teacher {
    
    
    @Override
    public void teach() {
    
    
        System.out.println("I teach math.");
    }
}

/**
 * 英语老师
 *
 * @author dkangel
 */
public class EnglishTeacher implements Teacher {
    
    
    @Override
    public void teach() {
    
    
        System.out.println("I teach english.");
    }
}

3. 创建teacher工厂类，并创建静态方法获取teacher实例
/**
 * teacher工厂类
 * <p>
 * 定义一个工厂类专门实例化teacher实例，这些实例具有相同的父类
 *
 * @author dkangel
 */
public static class TeacherFactory {
    
    
    public Teacher getTeacher(String type) {
    
    
        if ("math".equals(type)) {
    
    
            return new MathTeacher();
        } else if ("english".equals(type)) {
    
    
            return new EnglishTeacher();
        }
        return null;
    }
}

4. 使用
/**
 * 简单工厂使用类
 *
 * @author dkangel
 */
public class Main {
    
    
    public static void main(String[] args) {
    
    
        // 数学老师
        Teacher teacher = TeacherFactory.getTeacher("math");
        teacher.teach();

        // 英语老师
        teacher = TeacherFactory.getTeacher("english");
        teacher.teach();
    }
}

---

2. Patrón de método de fábrica

También conocida como modo de fábrica, modo de fábrica polimórfica y modo de constructor virtual, la clase padre de la fábrica es responsable de definir la interfaz pública para crear objetos y la subclase es responsable de generar objetos específicos.

2.1 Escena

• Cuando una clase no conoce la clase del objeto que necesita
• Cuando una clase quiere especificar la creación de objetos a través de sus subclases.

2.2 Ventajas

• Cumplir con el principio de apertura y cierre, al agregar nuevos productos, solo es necesario agregar categorías de productos específicas y subcategorías de fábrica
• De acuerdo con el principio de responsabilidad única, una subcategoría de fábrica solo es responsable de crear los productos correspondientes.
• No utilice métodos de fábrica estáticos, puede formar una jerarquía basada en la herencia.

2.3 Desventajas

• Al agregar un nuevo producto, además de agregar una nueva categoría de producto, también es necesario proporcionar la categoría de fábrica específica correspondiente. El número de categorías de sistema aumentará en pares, lo que aumenta la complejidad del sistema en cierta medida; en al mismo tiempo, hay más categorías. La necesidad de compilar y ejecutar, traerá algunos gastos generales adicionales al sistema
• Teniendo en cuenta la escalabilidad del sistema, es necesario introducir una capa de abstracción, que se define en el código del cliente, lo que aumenta la abstracción y dificultad de entender el sistema.
• Una fábrica específica solo puede crear un producto específico

1. 创建抽象工厂类
/**
 * teacher接口
 *
 * @author dkangel
 */
public interface Teacher {
    
    
    /**
     * 教学
     */
    void teach();
}

2. 创建抽象teacher类
/**
 * teacher类
 *
 * @author dkangel
 */
public abstract class Teacher {
    
    
    /**
     * 教学
     */
    public abstract void teach();
}

3. 创建具体的teacher类
/**
 * math teacher类
 *
 * @author dkangel
 */
public class MathTeacher implements Teacher {
    
    
    @Override
    public void teach() {
    
    
        System.out.println("I am math teacher.");
    }
}

4. 创建具体工厂类
/**
 * 具体工厂类 math teacher factory
 * 
 * @author dkangel
 */
public class MathFactory extends Factory {
    
    
    @Override
    public Teacher getTeacher() {
    
    
        return new MathTeacher();
    }
}

5. 使用
/**
 * 工厂方法使用类
 *
 * @author dkangel
 */
public class Main {
    
    
    public static void main(String[] args) {
    
    
        // 数学老师
        AbstractFactory factory = new MathFactory();
        Teacher teacher = factory.getTeacher();

        // 英语老师
        factory = new EnglishFactory();
        teacher = factory.getTeacher();
    }
}

---

3. Patrón de fábrica abstracto

Proporcione una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases específicas. Crea otras fábricas alrededor de la súper fábrica.

3.1 Escena

• Un sistema no necesita depender de la expresión de cómo se crean, combinan y expresan las instancias de clases de productos, que también es un requisito previo para la aplicación de todos los patrones de fábrica.
• Este sistema tiene múltiples series de productos, y solo una cierta serie de productos se consumen en el sistema.
• El sistema requiere una biblioteca similar a un producto, todos los productos aparecen con la misma interfaz y el cliente no necesita depender de implementaciones específicas.

3.2 Ventajas

• Reducir el acoplamiento. El
  modelo de fábrica abstracta retrasa la creación de productos específicos a las subclases de fábricas específicas. Esto encapsula la creación de objetos, lo que puede reducir la dependencia entre el cliente y la clase de producto específica, por lo que el acoplamiento del sistema es bajo, lo que es más propicio para el mantenimiento y la expansión posteriores;
• Más en línea con el principio de abrir-cerrar Al
  agregar una nueva categoría de 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.
• Sin utilizar métodos de fábrica estáticos, se puede formar una jerarquía basada en la herencia.

3.3 Desventajas

• El modelo de fábrica abstracto es difícil de soportar cambios en nuevos tipos de productos.
  Esto se debe a que la interfaz de la fábrica abstracta ha determinado el conjunto de productos que se pueden crear. Si necesita agregar nuevos productos, debe modificar la interfaz de la fábrica abstracta en este momento. Esto implica el cambio de la clase de fábrica abstracta y todo subclases, por lo que también viola el principio de "desarrollo cerrado"

1. 创建电脑接口
/**
 * 电脑接口
 *
 * @author dkangel
 */
public interface Computer {
    
    
    /**
     * 写代码
     */
    void code();
}

2. 创建电脑实现类
public class HuaweiComputer implements Computer {
    
    
    @Override
    public void code() {
    
    
        System.out.println("Huawei Computer code.");
    }
}
public class AppleComputer implements Computer {
    
    
    @Override
    public void code() {
    
    
        System.out.println("Apple Computer code.");
    }
}

3. 创建手机接口
/**
 * 手机接口
 *
 * @author dkangel
 */
public interface Phone {
    
    
    /**
     * 打电话
     */
    void call();
}

4. 创建手机实现类
public class HuaweiPhone implements Phone {
    
    
    @Override
    public void call() {
    
    
        System.out.println("Huawei Phone call.");
    }
}
public class ApplePhone implements Phone {
    
    
    @Override
    public void call() {
    
    
        System.out.println("Apple Phone call.");
    }
}

5. 创建抽象工厂类
/**
 * 工厂类
 *
 * @author dkangel
 */
public abstract class AbstractFactory {
    
    
    /**
     * 生产手机
     *
     * @return Phone
     */
    public abstract Phone manufacturePhone(String company);

    /**
     * 生产电脑
     *
     * @return Computer
     */
    public abstract Computer manufactureComputer(String company);
}

6. 创建电脑、手机工厂类
/**
 * Computer工厂类
 *
 * @author dkangel
 */
public class ComputerFactory extends AbstractFactory {
    
    
    @Override
    public Phone manufacturePhone(String company) {
    
    
        return null;
    }

    @Override
    public Computer manufactureComputer(String company) {
    
    
        if ("Huawei".equalsIgnoreCase(company)) {
    
    
            return new HuaweiComputer();
        } else if ("Apple".equalsIgnoreCase(company)) {
    
    
            return new AppleComputer();
        }
        return null;
    }
}
/**
 * Phone工厂类
 *
 * @author dkangel
 */
public class PhoneFactory extends AbstractFactory {
    
    
    @Override
    public Phone manufacturePhone(String company) {
    
    
        if ("Huawei".equalsIgnoreCase(company)) {
    
    
            return new HuaweiPhone();
        } else if ("Apple".equalsIgnoreCase(company)) {
    
    
            return new ApplePhone();
        }
        return null;
    }

    @Override
    public Computer manufactureComputer(String company) {
    
    
        return null;
    }
}

7. 创建超级工厂类
/**
 * 超级工厂类，用于创建其具体的工厂类
 *
 * @author dkangel
 */
public class FactoryProducer {
    
    
    /**
     * 根据type获取具体的工厂
     *
     * @param type 工厂类型
     * @return AbstractFactory
     */
    public static AbstractFactory getFactory(String type) {
    
    
        if ("Phone".equalsIgnoreCase(type)) {
    
    
            return new PhoneFactory();
        } else if ("Computer".equalsIgnoreCase(type)) {
    
    
            return new ComputerFactory();
        }
        return null;
    }
}

8. 使用
/**
 * 抽象工厂使用类
 *
 * @author dkangel
 */
public class Main {
    
    
    public static void main(String[] args) {
    
    
        // 获取Phone工厂
        AbstractFactory phoneFactory = FactoryProducer.getFactory("phone");
        // 获取Huawei手机
        Phone phone = phoneFactory.manufacturePhone("Huawei");
        phone.call();
        // 获取Apple手机
        phone = phoneFactory.manufacturePhone("Apple");
        phone.call();

        AbstractFactory computerFactory = FactoryProducer.getFactory("computer");
        // 获取Huawei电脑
        Computer computer = computerFactory.manufactureComputer("Huawei");
        computer.code();
        // 获取Apple电脑
        computer = computerFactory.manufactureComputer("Apple");
        computer.code();
    }
}