设计模式-工厂模式(简单工厂模式、工厂模式、抽象工厂模式)_简单工厂设计模式和抽象工厂设计模式-优快云博客

本文链接：https://blog.youkuaiyun.com/hfx_fmxd/article/details/111875098

本文详细介绍了工厂模式，包括简单工厂模式、工厂方法模式和抽象工厂模式。简单工厂模式适用于产品种类较少的情况，而工厂方法模式和抽象工厂模式则适用于产品族的创建。文章通过餐饮业的例子，展示了三种模式的应用，强调了它们在解耦和扩展性方面的优势。通过这些模式，开发者可以更灵活地创建和管理产品对象，而无需关注具体实现细节。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

工厂模式

前提

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

定义

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

示例开始

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

餐馆主要卖食物

食物

package com.designpattern.factory.easyfactory.interfaces;

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

简单工厂模式

模式说明

优点

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

缺点

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

模式结构

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

工厂模式

模式说明

优点

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

缺点

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

模式结构

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

应用场景

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

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

示例继续

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

店面改造

改造厨房

package com.designpattern.factory.factory.interfaces;

public abstract class KitchenFactory {
    protected abstract Food cook();
}

新厨房·面条厨房

package com.designpattern.factory.factory.foodfactory;

import com.designpattern.factory.factory.food.Noodle;
import com.designpattern.factory.factory.interfaces.Food;
import com.designpattern.factory.factory.interfaces.KitchenFactory;

public class NoodleKitchenFactory extends KitchenFactory {
    @Override
    protected Food cook() {
        return new Noodle();
    }
}

新厨房·米饭厨房

package com.designpattern.factory.factory.foodfactory;

import com.designpattern.factory.factory.food.Rice;
import com.designpattern.factory.factory.interfaces.Food;
import com.designpattern.factory.factory.interfaces.KitchenFactory;

public class RiceKitchenFactory extends KitchenFactory {
    protected Food cook() {
        return new Rice();
    }
}

在这个基础上，再增加新的食物和对应的厨房

新增品种

Dumpling

package com.designpattern.factory.factory.food;

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

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

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

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

新厨房·饺子厨房

package com.designpattern.factory.factory.foodfactory;

import com.designpattern.factory.factory.food.Dumpling;
import com.designpattern.factory.factory.interfaces.Food;
import com.designpattern.factory.factory.interfaces.KitchenFactory;

public class DumplingKitchenFactory extends KitchenFactory {
    protected Food cook() {
        return new Dumpling();
    }
}

Bun

package com.designpattern.factory.factory.food;

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

public class Bun extends Food {

    public Bun() {
        create();
    }

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

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

新厨房·包子厨房

package com.designpattern.factory.factory.foodfactory;

import com.designpattern.factory.factory.food.Bun;
import com.designpattern.factory.factory.interfaces.Food;
import com.designpattern.factory.factory.interfaces.KitchenFactory;

public class BunKitchenFactory extends KitchenFactory {
    protected Food cook() {
        return new Bun();
    }
}

这时，顾客点菜的时候直接通知对应的厨房就可以了

顾客点单

package com.designpattern.factory;

import com.designpattern.factory.factory.foodfactory.BunKitchenFactory;
import com.designpattern.factory.factory.foodfactory.DumplingKitchenFactory;
import com.designpattern.factory.factory.foodfactory.NoodleKitchenFactory;
import com.designpattern.factory.factory.foodfactory.RiceKitchenFactory;
import com.designpattern.factory.factory.interfaces.Food;
import com.designpattern.factory.factory.interfaces.KitchenFactory;

public class Application {

    public static void main(String[] args) {
        //Noodle
        KitchenFactory kitchen = new NoodleKitchenFactory();
        Food food = kitchen.cook();
        System.out.println(food);
        //Rice
        kitchen = new RiceKitchenFactory();
        food = kitchen.cook();
        System.out.println(food);
        //Dumpling
        kitchen = new DumplingKitchenFactory();
        food = kitchen.cook();
        System.out.println(food);
        //Bun
        kitchen = new BunKitchenFactory();
        food = kitchen.cook();
        System.out.println(food);
    }
}

抽象工厂模式

模式说明

使用要求

系统中有多个产品族，每个具体工厂创建同一族但属于不同等级结构的产品。
系统一次只可能消费其中某一族产品，即同族的产品一起使用。

优点

可以在类的内部对产品族中相关联的多等级产品共同管理，而不必专门引入多个新的类来进行管理。
当需要产品族时，抽象工厂可以保证客户端始终只使用同一个产品的产品组。
抽象工厂增强了程序的可扩展性，当增加一个新的产品族时，不需要修改原代码，满足开闭原则。

缺点

当产品族中需要增加一个新的产品时，所有的工厂类都需要进行修改。增加了系统的抽象性和理解难度。

模式结构

抽象工厂(Abstract Factory)：提供了创建产品的接口，它包含多个创建产品的方法 newProduct()，可以创建多个不同等级的产品。
具体工厂(Concrete Factory)：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品(Product)：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品(Concrete Product)：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

应用场景

工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级(种类) 的产品。对于这样的需求，就可以引入抽象工厂模式。

示例继续

随着小白的点进一步扩大，小白开始卖饮料

新增饮料

饮料

package com.designpattern.factory.abstractfactory.interfaces;

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

Juice

package com.designpattern.factory.abstractfactory.drink;

import com.designpattern.factory.abstractfactory.interfaces.Drink;

public class Juice extends Drink {
    public Juice() {
        create();
    }

    protected void create() {
        System.out.println("Juice is finished.");
    }

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

Cola

package com.designpattern.factory.abstractfactory.drink;

import com.designpattern.factory.abstractfactory.interfaces.Drink;

public class Cola extends Drink {
    public Cola() {
        create();
    }

    protected void create() {
        System.out.println("Cola is finished.");
    }

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

小白计划将食物和饮料搭配着卖，这样可以增加收益。这样，客户只需要点单一次，就可以获得两种食物。因此，小白创建了套餐模式。

店面改造

改造厨房

package com.designpattern.factory.abstractfactory.interfaces;

public abstract class KitchenFactory {
    public abstract Food cook();
    public abstract Drink make();
}

四种食物和两种饮料都可以随意搭配，一共八种套餐

八种套餐

//Rice-Juice
public class RiceJuiceKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Rice();
    }

    public Drink make() {
        return new Juice();
    }
}

//Rice-Cola
public class RiceColaKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Rice();
    }

    public Drink make() {
        return new Cola();
    }
}

//Noodle-Juice
public class NoodleJuiceKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Noodle();
    }

    public Drink make() {
        return new Juice();
    }
}

//Noodle-Cola
public class NoodleColaKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Noodle();
    }

    public Drink make() {
        return new Cola();
    }
}

//Dumpling-Juice
public class DumplingJuiceKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Dumpling();
    }

    public Drink make() {
        return new Juice();
    }
}

//Dumpling-Cola
public class DumplingColaKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Dumpling();
    }

    public Drink make() {
        return new Cola();
    }
}

//Bun-Juice
public class BunJuiceKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Bun();
    }

    public Drink make() {
        return new Juice();
    }
}

//Bun-Cola
public class BunColaKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Bun();
    }

    public Drink make() {
        return new Cola();
    }
}

顾客需要点餐的时候，直接通知对应的厨房就行了，不再需要单独点饮料和食物。

顾客点单

package com.designpattern.factory;

import com.designpattern.factory.abstractfactory.foodfactory.*;
import com.designpattern.factory.abstractfactory.interfaces.Drink;
import com.designpattern.factory.abstractfactory.interfaces.Food;
import com.designpattern.factory.abstractfactory.interfaces.KitchenFactory;

public class Application {

    public static void main(String[] args) {
        KitchenFactory kitchen = null;
        Food food = null;
        Drink drink = null;
        //Rice-Juice
        kitchen = new RiceJuiceKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Rice-Cola
        kitchen = new RiceColaKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Noodle-Juice
        kitchen = new NoodleJuiceKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Noodle-Cola
        kitchen = new NoodleColaKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Dumpling-Juice
        kitchen = new DumplingJuiceKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Dumpling-Cola
        kitchen = new DumplingColaKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Bun-Juice
        kitchen = new BunJuiceKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
        //Bun-Cola
        kitchen = new BunColaKitchenFactory();
        food = kitchen.cook();
        drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
    }
}

输出：

Rice is cooked.
Juice is finished.
food = This is a Rice.
drink = This is Juice.
Rice is cooked.
Cola is finished.
food = This is a Rice.
drink = This is Cola.
Noodle is cooked.
Juice is finished.
food = This is a Noodle.
drink = This is Juice.
Noodle is cooked.
Cola is finished.
food = This is a Noodle.
drink = This is Cola.
Dumpling is cooked.
Juice is finished.
food = This is a Dumpling.
drink = This is Juice.
Dumpling is cooked.
Cola is finished.
food = This is a Dumpling.
drink = This is Cola.
Bun is cooked.
Juice is finished.
food = This is a Bun.
drink = This is Juice.
Bun is cooked.
Cola is finished.
food = This is a Bun.
drink = This is Cola.

新增套餐

如果小白需要新增一个套餐：汉堡Hamburg + 豆浆SoyBeanMilk，只需要实现对应的接口就可以了，不再需要修改之前的代码。

新增食物 Hamburg

package com.designpattern.factory.abstractfactory.food;

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

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

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

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

新增饮料 SoyBeanMilk

package com.designpattern.factory.abstractfactory.drink;

import com.designpattern.factory.abstractfactory.interfaces.Drink;

public class SoyBeanMilk extends Drink {
    public SoyBeanMilk() {
        create();
    }

    protected void create() {
        System.out.println("SoyBeanMilk is finished.");
    }

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

新增套餐 NewKitchenFactory

package com.designpattern.factory.abstractfactory.foodfactory;

import com.designpattern.factory.abstractfactory.drink.SoyBeanMilk;
import com.designpattern.factory.abstractfactory.food.Hamburg;
import com.designpattern.factory.abstractfactory.interfaces.Drink;
import com.designpattern.factory.abstractfactory.interfaces.Food;
import com.designpattern.factory.abstractfactory.interfaces.KitchenFactory;

public class NewKitchenFactory extends KitchenFactory {
    public Food cook() {
        return new Hamburg();
    }

    public Drink make() {
        return new SoyBeanMilk();
    }
}

顾客点单

    public static void main(String[] args) {
        KitchenFactory kitchen = new NewKitchenFactory();
        Food food = kitchen.cook();
        Drink drink = kitchen.make();
        System.out.println("food = " + food);
        System.out.println("drink = " + drink);
    }

输出

Hamburg is cooked.
SoyBeanMilk is finished.
food = This is a Hamburg.
drink = This is SoyBeanMilk.

总结

简单工厂模式生产所有东西，每多一种东西就需要在工厂中添加对应的分支。每次增加新的产品时，都需要对工厂类进行二次修改。

工厂模式每一个工厂只生产一种东西，每多一种产品就需要增加一个新的产品实现和新的产品工厂实现。但是所有的产品都是基于同一个父类Food的，使用的产品工厂也是基于同一个工厂父类实现的。一旦有了新的产品类别Drink，就需要新的父类和新的产品工厂DrinkFactory。

抽象工厂模式是工厂模式的升级，一个抽象工厂生产一系列的产品。单独增加一个产品时，需要修改所有的已将实现的工厂(比如，新增一个小菜vegetable，则每个可能包含这个小菜的套餐都需要增加相应的实现)。但是，如果多了一种Food，比如说馒头Hamburg ，需要和Drink搭配的时候，只需要新增加对应的工厂就可以了，不需要修改其他已经实现的具体工厂类。

PS：不管是哪一种模式，Food和Drink的具体实现类顾客Application是无法感知的，只能通过相应的工厂来获取，只有拿到之后，顾客才知道拿到的是什么(顾客main方法中从头到尾不会出现具体的Food和Drink信息(包括import和反射使用的class信息)，只有在获取信息**toString()**的时候才知道具体的内容)。