设计模式-工厂模式(简单工厂模式、工厂模式、抽象工厂模式)

工厂模式

前提

开发者创造的实体类代码并不会提供给客户端，只是开放了一个接口，即工厂类。客户端在获取系统中的对象的时候，只能通过工厂类来获取对象(即使用者除了工厂类和一些简单条件，对其余代码一无所知。)

定义

定义一个创建产品对象的工厂接口，将产品对象的实际创建工作推迟到具体子工厂类当中。这满足创建型模式中所要求的“创建与使用相分离”的特点。

分类

1. 简单工厂模式(Simple Factory Pattern)：又叫作静态工厂方法模式(Static Factory Method Pattern)，有一个具体的工厂类，可以生成多个不同的产品，属于创建型设计模式(不在GOP设计模式之列)
2. 工厂(Factory)方法模式：对简单工厂模式的进一步抽象化。
3. 抽象工厂(Abstract Factory)模式：是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

示例开始

小白来到了一个大城市，想要生活下去。于是，他凭借自己的一技之长，开了一家餐馆。

餐馆主要卖食物

食物

package com.designpattern.factory.easyfactory.interfaces;

public abstract class Food {
   
    protected abstract void create();
}

简单工厂模式

模式说明

优点

1. 工厂类包含必要的逻辑判断，可以决定在什么时候创建哪一个产品的实例。客户端可以免除直接创建产品对象的职责，很方便的创建出相应的产品。工厂和产品的职责区分明确。
2. 客户端无需知道所创建具体产品的类名，只需知道参数即可。
3. 也可以引入配置文件，在不修改客户端代码的情况下更换和添加新的具体产品类。

缺点

1. 简单工厂模式的工厂类单一，负责所有产品的创建，职责过重，一旦异常，整个系统将受影响。且工厂类代码会非常臃肿，违背高聚合原则。
2. 使用简单工厂模式会增加系统中类的个数(引入新的工厂类)，增加系统的复杂度和理解难度
3. 系统扩展困难，一旦增加新产品不得不修改工厂逻辑，在产品类型较多时，可能造成逻辑过于复杂
4. 简单工厂模式使用了 static 工厂方法，造成工厂角色无法形成基于继承的等级结构。

模式结构

1. 简单工厂(Simple Factory)：是简单工厂模式的核心，负责实现创建所有实例的内部逻辑。工厂类的创建产品类的方法可以被外界直接调用，创建所需的产品对象。
2. 抽象产品(Product)：是简单工厂创建的所有对象的父类，负责描述所有实例共有的公共接口。
3. 具体产品(Concrete Product)：是简单工厂模式的创建目标。

应用场景

对于产品种类相对较少的情况，考虑使用简单工厂模式。使用简单工厂模式的客户端只需要传入工厂类的参数，不需要关心如何创建对象的逻辑，可以很方便地创建所需产品。

示例继续

最开始的小白没有资金，只能卖面条和米饭两种食物。

开店准备

Noodle

package com.designpattern.factory.easyfactory.objects;

import com.designpattern.factory.easyfactory.interfaces.Food;

public class Noodle extends Food {
   
    public Noodle() {
   
        create();
    }

    @Override
    protected void create() {
   
        System.out.println("Noodle is cooked.");
    }

    @Override
    public String toString() {
   
        return "This is a Noodle.";
    }
}

Rice

package com.designpattern.factory.easyfactory.objects;

import com.designpattern.factory.easyfactory.interfaces.Food;

public class Rice extends Food {
   

    public Rice() {
   
        create();
    }

    protected void create() {
   
        System.out.println("Rice is cooked.");
    }

    @Override
    public String toString() {
   
        return "This is a Rice.";
    }
}

厨房

然后在餐馆中有一间厨房，用来做这两种食物。

package com.designpattern.factory.easyfactory;

import com.designpattern.factory.easyfactory.interfaces.Food;
import com.designpattern.factory.easyfactory.objects.Noodle;
import com.designpattern.factory.easyfactory.objects.Rice;

public class KitchenFactory {
   

    public static final String NOODLE = "Noodle";

    public static final String RICE = "Rice";

    public Food cook(String menu) {
   
        if (NOODLE.equals(menu)) {
   
            return new Noodle();
        } else if (RICE.equals(menu)) {
   
            return new Rice();
        }
        return null;
    }
}

当一个顾客进来的时候，只要按照菜单点餐通知厨房就可以了。

顾客点单

package com.designpattern.factory;

import com.designpattern.factory.easyfactory.KitchenFactory;
import com.designpattern.factory.easyfactory.interfaces.Food;

public class Application {
   

    public static void main(String[] args) {
   
        KitchenFactory kitchen = new KitchenFactory();
        Food rice = kitchen.cook(KitchenFactory.RICE);
        Food noodle = kitchen.cook(KitchenFactory.NOODLE);
        System.out.println("noddle = " + noodle);
        System.out.println("rice = " + rice);
    }
}

输出：

Rice is cooked.
Noodle is cooked.
noddle = This is a Rice.
rice = This is a Noodle.

工厂模式

模式说明

优点

1. 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
2. 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
3. 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。

缺点

1. 类的个数容易过多，增加复杂度
2. 增加了系统的抽象性和理解难度
3. 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决。

模式结构

1. 抽象工厂(Abstract Factory)：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法 newProduct() 来创建产品。
2. 具体工厂(Concrete Factory)：主要是实现抽象工厂中的抽象方法，完成具体产品的创建。
3. 抽象产品(Product)：定义了产品的规范，描述了产品的主要特性和功能。
4. 具体产品(Concrete Product)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间一一对应。

应用场景

随着产品种类的增多，简单工厂模式会存在越来越多的判断分支，此时，可以考虑使用工厂方法模式。

但是，当需要生成的产品不多且不会增加，一个具体工厂类就可以完成任务时，可删除抽象工厂类。这时工厂方法模式将退化到简单工厂模式。

示例继续

随着小白的生意越来越好，小白又开始增加了新的食物种类，饺子和馒头。但是这时候厨房已经太小了，不能支撑这么多食物的生产了。于是，决定改造厨房，每种食物单独使用一个厨房。

店面改造

改造厨房

package com.designpattern.factory.factory.interfaces;

public abstract class KitchenFactory {
   
    protected abstract Food cook(