设计模式之【工厂模式】详解

原创已于 2025-10-22 10:26:58 修改 · 1.1k 阅读

30 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#设计模式 #java #开发语言 #工厂模式

于 2025-04-07 08:36:30 首次发布

设计模式专栏收录该内容

11 篇文章

订阅专栏

文章目录

设计模式—工厂模式

设计模式—工厂模式

一、概述

工厂模式提供了一种创建对象的方式，而无需指定要创建的具体类。
通过使用工厂模式，可以将对象的创建逻辑封装在一个工厂类中，而不是在客户端代码中直接实例化对象，这样可以提高代码的可维护性和可扩展性。
在java中，万物皆对象，这些对象都需要创建，如果创建的时候直接new该对象，就会对该对象耦合严重，假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的；所以说，工厂模式最大的优点就是：解耦，工厂模式是一种创建型的模式。

二、工厂模式的类型

（1）简单工厂模式（Simple Factory Pattern）：

简单工厂模式不是一个正式的设计模式，但它是工厂模式的基础。它使用一个单独的工厂类来创建不同的对象，根据传入的参数决定创建哪种类型的对象。

（2）静态工厂模式：

和简单工厂模式类似，但是通过调用静态方法来创建对象。

（3）工厂方法模式（Factory Method Pattern）：

定义创建对象的接口，由子类决定实例化哪个类，支持扩展。

（4）抽象工厂模式（Abstract Factory Pattern）：

提供一个接口，用于创建相关或依赖的对象家族，无需指定具体类。

三、简单工厂模式

例子：

需求：设计一个咖啡店点餐系统。
设计一个咖啡类（Coffee），并定义其两个子类（美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】）；再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。

具体类的设计如下：
在这里插入图片描述

3.0 类图实现

Coffee抽象类

/**
 * TODO 添加描述
 *
 * @date 2024/6/15 22:43
 * 咖啡抽象类
 */
public abstract class Coffee {
    public abstract String getName();
    public void addsugar(){
        System.out.println("加糖");
    }

    public void addMilk(){
        System.out.println("加奶");
    }
}

AmericanCoffee

/**
 * TODO 添加描述
 *
 * @date 2024/6/15 22:44
 * 美式咖啡
 */
public class AmericanCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

LatteCoffee

/**
 * TODO 添加描述
 *
 * @date 2024/6/15 22:44
 * 拿铁咖啡
 */
public class LatterCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

CoffeeStore

/**
 * TODO 添加描述
 *
 * @date 2024/6/15 22:46
 *  咖啡店
 */
public class CoffeeStore {
    public Coffee orderCoffer(String type) {

        Coffee coffee = null;
        if("american".equals(type)) {
            coffee = new AmericanCoffee();
        } else if("latte".equals(type)) {
            coffee = new LatterCoffee();
        }
        return coffee;
    }
}

说明
CoffeeStore 违反了开闭原则。当有新的咖啡种类出现的时候，我们需要更改CoffeeStore 类。

User

/**
 * TODO 添加描述
 *
 * @date 2024/6/15 22:50
 * 用户
 */
public class User {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee american = coffeeStore.orderCoffer("american");
        System.out.println(american.getName());
        Coffee latte = coffeeStore.orderCoffer("latte");
        System.out.println(latte.getName());
    }
}

3.1 结构

工厂模式包含以下几个主要角色：

1.抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
2.具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
3.具体工厂：提供了创建产品的方法，调用者通过该方法来获取产品。

3.2 实现

public class SimpleCoffeeFactory {
    public Coffee createCoffee(String type){
        //声明Coffee类型的变量，根据不同的类型创建不同的coffee子类对象
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        }else if("latte".equals(type)){
            coffee = new LatteCoffee();
        }else{
            throw new RuntimeException("对不起，您点的咖啡没有");
        }
        return coffee;
    }
}

分析

工厂（factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合，同时又产生了新的耦合，CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，工厂对象和商品对象的耦合。
后期如果再加新品种的咖啡，我们势必要需求修改SimpleCoffeeFactory的代码，违反了开闭原则。 工厂类的客户端可能有很多，比如创建其他咖啡类等，这样只需要修改工厂类的代码，省去其他的修改操作。

优缺点
优点：
封装了创建对象的过程，可以通过参数直接获取对象。把对象的创建和业务逻辑层分开，这样以后就避免了修改客户代码，如果要实现新产品直接修改工厂类，而不需要在原代码中修改，这样就降低了客户代码修改的可能性，更加容易扩展。
缺点：
增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

3.3 扩展

静态工厂模式：通过调用工厂类直接调用方法。

/**
 * 静态工厂方法模式
 */
public class SimpleCoffeeFactory {

    public static Coffee createCoffee(String type){
        //声明Coffee类型的变量，根据不同的类型创建不同的coffee子类对象
        Coffee coffee = null;
        if("american".equals(type)){
            coffee = new AmericanCoffee();
        }else if("latte".equals(type)){
            coffee = new LatteCoffee();
        }else{
            throw new RuntimeException("对不起，您点的咖啡没有");
        }

        return coffee;
    }
}

四、工厂方法模式

类图：
在这里插入图片描述

4.1 结构

1.抽象产品（Abstract Product）：定义了产品的共同接口或抽象类。它可以是具体产品类的父类或接口，规定了产品对象的共同方法。
2.具体产品（Concrete Product）：实现了抽象产品接口，定义了具体产品的特定行为和属性。
3.抽象工厂（Abstract Factory）：声明了创建产品的抽象方法，可以是接口或抽象类。它可以有多个方法用于创建不同类型的产品。
4.具体工厂（Concrete Factory）：实现了抽象工厂接口，负责实际创建具体产品的对象。

4.2 实现（参照之前例子）

抽象工厂

public interface CoffeeFactory {
    //创建咖啡对象的方法
    Coffee createCoffee();
}

具体工厂

/**
 * 美式咖啡工厂对象，专门用来生产美式咖啡
 */
public class AmericanCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
}
/**
 * 拿铁咖啡工厂，专门用来生产拿铁咖啡
 */
public class LatteCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

咖啡店(实现每个工厂创建一种产品）：

public class CoffeeStore {
    private CoffeeFactory factory;
    public void setFactory(CoffeeFactory factory){
        this.factory = factory;
    }
    public Coffee orderCoffee(){
        Coffee coffee = factory.createCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }
}

分析

从以上的编写的代码可以看到，要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。

工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。

优缺点
优点：

用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程；
在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则；

缺点：

每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。

五、抽象工厂模式

5.1 概述

前面介绍的工厂方法模式中考虑的是一类产品的生产，如畜牧场只养动物、电视机厂只生产电视机、手机店只卖手机等

这些工厂只生产同种类产品，同种类产品称为同等级产品，也就是说：工厂方法模式只考虑生产同等级的产品，但是在现实生活中许多工厂是综合型的工厂，能生产多等级（种类）的产品，如电器厂既生产电视机又生产洗衣机或空调，手机店既可以卖手机也可以卖平板、音响等。

如何理解产品族。
例如有一个工厂可以生产以下产品

裤子有：短裤、牛仔裤、工装裤、西装裤（同种类产品/同等级产品）
上衣有：短袖、牛仔褂、工装褂、西装褂子（同种类产品/同等级产品）
鞋子有：拖鞋、平板鞋、运动鞋、皮鞋（同种类产品/同等级产品）
裤子、上衣和鞋子他们三个就是同一个产品族。属于是同一个工厂的产品。

概念
是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。
抽象工厂模式是工厂方法模式的升级版本，工厂方法模式只生产一个等级的产品，而抽象工厂模式可生产多个等级的产品。

5.2 结构

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

5.3 实现

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。

类图
在这里插入图片描述
抽象工厂

public interface DessertFactory{
    //创建咖啡对象的方法
    Coffee createCoffee();
	//生产甜品的功能
    Dessert createDessert();
}

具体工厂

/**
 * 美式风味的甜品工厂，可以生产美式咖啡和抹茶慕斯
 */
public class AmericanCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new AmericanCoffee();
    }
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}
/**
 * 意大利风味的甜品工厂，能生产拿铁和提拉米苏
 */
public class LatteCoffeeFactory implements CoffeeFactory{
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
    public Dessert createDessert() {
        return new Tiramisu();
    }
}

分析