设计模式：创建型模式--工厂方法模式（Factory Method Pattern）

原创 已于 2022-03-04 12:42:03 修改 · 503 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #设计模式 #软件架构
于 2022-02-26 16:11:20 首次发布
本文深入探讨了工厂模式，包括简单工厂模式和工厂方法模式。介绍了这两种模式的概念、组成结构、优缺点及实现细节，并通过咖啡店点餐系统举例说明。简单工厂模式虽然能解耦，但违背了开闭原则；而工厂方法模式则通过多态完美解决了这一问题，实现了创建对象的灵活性。

设计模式：创建型模式–工厂方法模式（Factory Method Pattern）

文章目录

本文章中将介绍两种工厂模式：

  • 简单工厂模式（Simple Factory Pattern）（不属于GOF的23种经典设计模式）。
  • 工厂方法模式（Factory Method Pattern）。

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。


1. 引入

假设我们需要实现以下的需求：设计一个咖啡店点餐系统。

  • 设计一个咖啡类（Coffee）。
  • 定义其两个子类美式咖啡（AmericanCoffee）和拿铁咖啡（LatteCoffee）。
  • 再设计一个咖啡店类（CoffeeStore），咖啡店具有点咖啡的功能。

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

在 Java 中，万物皆对象，这些对象都需要创建。如果创建的时候直接new该对象，就会造成该对象耦合严重。假如我们要更换对象，所有new对象的地方都需要修改一遍，这显然违背了软件设计的开闭原则。

然而，如果我们使用工厂来生产对象，我们就只和工厂打交道就可以了，彻底和对象解耦，如果要更换对象，直接在工厂里更换该对象即可，达到了与对象解耦的目的。因此，工厂模式最大的优点就是：解耦。

  • 初版CoffeeStore类代码如下：

    /**
 * @author zzay
 * @className CoffeeStore
 * @description Coffee store class
 * @create 2022/02/26 14:59
 */
public class CoffeeStore {

    /**
     * 1.未将对象创建过程和业务逻辑层分开。
     * 2.Coffee和CoffeeStore耦合性强。
     * 3.未封装对象创建过程，需要了解获取对象的细节。
     */
    public Coffee orderCoffee(String type) {
        Coffee coffee = null;
        // Make coffee（创建对象）
        if ("American".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("Latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        // Do things（业务逻辑）
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }

}

2. 简单工厂模式

注意，简单工厂不是一种设计模式，而更像是一种编程习惯。

2.1 组成结构

简单工厂模式包含如下角色：

  • **抽象产品：**定义了产品的规范，描述了产品的主要特性和功能。
  • **具体产品：**实现或者继承抽象产品的子类。
  • **具体工厂：**提供了创建产品的方法，调用者通过该方法来获取产品。

2.2 实现细节

现在使用简单工厂模式对上面案例进行改进，类图设计如下：

在这里插入图片描述

工厂（Factory）处理创建对象的细节，一旦有了SimpleCoffeeFactory，CoffeeStore类中的orderCoffee()就变成此对象的客户，后期如果需要Coffee对象，则直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合。工厂类的客户端可能有很多，比如创建美团外卖等，这样只需要修改工厂类的代码，省去其他的修改操作。

然而，此时又产生了新的耦合：CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合，以及SimpleCoffeeFactory工厂对象和Coffee商品对象的耦合。因此，后期如果再加新品种的咖啡，我们需要修改SimpleCoffeeFactory的代码，而这违反了开闭原则。

  • SimpleCoffeeFactory代码如下：

    /**
 * @author zzay
 * @className SimpleCoffeeFactory
 * @description 简单工厂思想
 * @create 2022/02/26 15:21
 */
public class SimpleCoffeeFactory {

    /**
     * 1.解除了CoffeeStore和Coffee的耦合。
     * 2.产生了新的耦合：自身和CoffeeStore以及和Coffee。
     * 3.增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。
     */
    public Coffee createCoffee(String type) {
        Coffee coffee = null;
        // Make coffee（创建对象）
        if ("American".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("Latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffee;
    }

}

  • CoffeeStore类代码如下：

    /**
 * @author zzay
 * @className CoffeeStore
 * @description Coffee store class
 * @create 2022/02/26 14:59
 */
public class CoffeeStore {

    /**
     * 1.解除了和Coffee实现类的耦合。
     * 2.封装了创建对象的过程（分类讨论及判断等）。
     * 3.把对象的创建和业务逻辑层分开。
     */
    public Coffee orderCoffee(String type) {
        // Make coffee（创建对象）
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        Coffee coffee = factory.createCoffee(type);
//        Coffee coffee = StaticSimpleCoffeeFactory.createCoffee(type);
        // Do things（业务逻辑）
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }

}

  • Client类：

    /**
 * @author zzay
 * @className Client
 * @description Client
 * @create 2022/02/26 15:29
 */
public class Client {

    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee coffee = coffeeStore.orderCoffee("Latte");
    }

}

2.3 优缺点

  • 优点：

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

  • 缺点：

    • 增加新产品时还是需要修改工厂类的代码，违背了“开闭原则”。

2.4 扩展实现

  • 静态工厂模式：

    在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的，这个就是静态工厂模式，它也不是23种设计模式中的。代码如下：

    /**
 * @author zzay
 * @className StaticSimpleCoffeeFactory
 * @description 静态简单工厂思想
 * @create 2022/02/26 15:37
 */
public class StaticSimpleCoffeeFactory {

    public static Coffee createCoffee(String type) {
        Coffee coffee = null;
        if ("American".equals(type)) {
            coffee = new AmericanCoffee();
        } else if ("Latte".equals(type)) {
            coffee = new LatteCoffee();
        }
        return coffee;
    }

}

3. 工厂模式

针对上例中的缺点，使用工厂方法模式就可以完美的解决，完全遵循开闭原则。

3.1 概念

定义一个用于创建对象的接口，让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

3.2 组成结构

工厂方法模式的主要角色：

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

3.3 实现细节

使用工厂方法模式对上例进行改进，类图设计如下：(工厂间的连线有误)
在这里插入图片描述

具体代码如下：

  • 抽象工厂CoffeeFactory：

    /**
 * @author zzay
 * @interfaceName CoffeeFactory
 * @description 创建型模式-工厂模式：CoffeeFactory
 * @create 2022/02/26 15:46
 */
public interface CoffeeFactory {

    /**
     * 要增加产品类时也要相应地增加工厂类，不需要修改工厂类的代码了，这样就解决了简单工厂模式的缺点。
     */
    Coffee createCoffee();

}

  • 具体工厂AmericanCoffeeFactory和LatteCoffeeFactory：

    /**
 * @author zzay
 * @className LatteCoffeeFactory
 * @description 创建型模式-工厂模式：LatteCoffeeFactory
 * @create 2022/02/26 15:49
 */
public class LatteCoffeeFactory implements CoffeeFactory {

    public Coffee createCoffee() {
        return new LatteCoffee();
    }

}

/**
 * @author zzay
 * @className AmericanCoffeeFactory
 * @description 创建型模式-工厂模式：AmericanCoffeeFactory
 * @create 2022/02/26 15:47
 */
public class AmericanCoffeeFactory implements CoffeeFactory {

    public Coffee createCoffee() {
        return new AmericanCoffee();
    }

}

  • CoffeeStore类：

    /**
 * @author zzay
 * @className CoffeeStore
 * @description Coffee store class
 * @create 2022/02/26 15:46
 */
public class CoffeeStore {

    // 提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品。
    private CoffeeFactory factory;

    public CoffeeStore(CoffeeFactory factory) {
        this.factory = factory;
    }

    /**
     * 无需再传入种类参数，在调用时即可访问具体的工厂来创建对应产品。
     */
    public Coffee orderCoffee() {
        Coffee coffee = factory.createCoffee();
        coffee.addMilk();
        coffee.addSugar();
        return coffee;
    }

}

  • Client类：

    /**
 * @author zzay
 * @className Client
 * @description Client
 * @create 2022/02/26 15:56
 */
public class Client {

    public static void main(String[] args) {
        // CoffeeStore调用相应的具体工厂，来制造相应的具体产品。
        CoffeeStore americanCoffeeStore = new CoffeeStore(new AmericanCoffeeFactory());
        CoffeeStore latteCoffeeStore = new CoffeeStore(new LatteCoffeeFactory());
        // 通过调用CoffeeStore来获取Coffee。
        Coffee coffee = americanCoffeeStore.orderCoffee();
        Coffee coffee2 = latteCoffeeStore.orderCoffee();
    }

}

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

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

3.4 优缺点

  • 优点：

    • 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。

    • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类，无须对原工厂进行任何修改，满足开闭原则。

  • 缺点：

    • 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类，这增加了系统的复杂度。
【愚公系列】二十三种设计模式(一)-工厂方法模式(Factory Method Pattern)
热门推荐
愚公智库
08-13 51万+
设计模式（Design Pattern）是软件开发领域的宝贵经验，是多人反复借鉴和广泛应用的代码设计指导。它们是一系列经过分类和归纳的代码组织方法，旨在实现可重用性、可维护性和可理解性。使用设计模式，我们能够编写高质量的代码，使其更易于他人理解，并提供了代码可靠性的保证。毫无疑问，设计模式对个人、团队和整个系统都带来了显著的益处。它们将代码开发提升到工程化水平，为软件工程构建提供了坚实的基础，就如同大厦的一块块精巧的砖石一样。在项目中明智地应用设计模式可以完美地解决各种复杂问题。
3.工厂方法模式（Factory Method Pattern）
写些小文章
05-06 409
目录1.前言2.介绍2.1.定义2.2.解决的问题2.3.结构与模式2.4.代码实现3.应用场景3.1. 优缺点3.2.应用场景4.源码分享 1.前言 在上文提到的最易懂的设计模式系列解析：简单工厂模式，发现简单工厂模式存在一系列问题： 工厂类集中了所有实例（产品）的创建逻辑，一旦这个工厂不能正常工作，整个系统都会受到影响； 违背“开放——关闭原则”，一旦添加新产品就不得不修改工厂类的逻辑，这样就会造成工厂逻辑过于复杂； 简单工厂模式由于使用了静态工厂方法，静态方法不能被继承和重写，会造成工厂角色无法形成
您的设计模式——工厂方法模式【Factory Method Pattern 】
03-17 440
女娲补天的故事大家都听说过吧，今天不说这个，说女娲创造人的故事，可不是“造人”的工作，这 个词被现代人滥用了。这个故事是说，女娲在补了天后，下到凡间一看，哇塞，风景太优美了，天空是湛 蓝的，水是清澈的，空气是清新的，太美丽了，然后就待时间长了就有点寂寞了，没有动物，这些看的到 都是静态的东西呀，怎么办？ 别忘了是神仙呀，没有办不到的事情，于是女娲就架起了八卦炉（技术术语：建立工厂）开始创建人
设计模式之( Factory Method Pattern－－工厂方法模式）
Delegate的专栏
08-31 900
定义：工厂方法又称工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，属于类的创建型模式。在工厂方法模式中，父类负责定义创建对象的公共接口，而子类则负责生成具体的对象，这样做的目的是将类的实例化延迟到子类中完成，即由子类来决定究竟应该实例化（创建）哪一个类。简单的说：想象一种模型，假设有一种工具是由零件组合而成的，当
设计模式总结之Factory Method Pattern（工厂方法模式）
cooldragon的专栏
08-11 6316
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。
D3：C#设计模式之二工厂方法模式（Factory Method Pattern）【创建型】
.
03-15 483
一、引言 在上一篇文章中我们讲解了过渡的一种模式叫做【简单工厂】，也有叫【静态工厂】的，通过对简单工厂模式得了解，我们也发现了它的缺点，就是随着需求的变化我们要不停地修改工厂里面的方法的代码，需求变化越多，里面的If--Else--也越多，这样就会造成简单工厂的实现逻辑过于复杂。设计模式是遵循一定原则而得来的，比如，我们要怎么增加代码，怎么修改代码，不是想怎么来就怎么来的，其中一个原...
创建型设计模式: 工厂方法模式(Factory Method Pattern)
智能多媒体
09-15 816
设计模式；结构型模式；创建型设计模式；工厂方法模式(Factory Method Pattern)又名虚构造器（Virtual Constructor），主要是为创建对象提供了接口，是代替new操作的一种模式。工厂方法模式属于创建型模式，创建型模式包括FactoryMethod模式，AbstractFactory模式，Singleton模式，ProtoType模式和Builder模式。
Java GoF 23种设计模式-创建型模式-工厂方法模式（Factory Method Pattern）
WU4566285的博客
05-16 425
文章目录一、模式定义二、模式动机三、模式结构四、代码实现五、缺点 一、模式定义 工厂方法模式(Factory Method Pattern)又称为工厂模式，也叫虚拟构造器(Virtual Constructor)模式或者多态工厂(Polymorphic Factory)模式，它属于创建型模式。 在工厂方法模式中，工厂父类负责定义创建产品对象的公共接口，而工厂子类则负责生成具体的产品对象，这样做的目的是将产品类的实例化操作延迟到工厂子类中完成，即通过工厂子类来确定究竟应该实例化哪一个具体产品类。 工厂方法模式
秒懂设计模式之工厂方法模式（Factory Method Pattern）
ShuSheng007的程序人生
01-25 5198
The essence of the Abstract Factory Pattern is to “Provide an interface for creating families of related or dependent objects without specifying their concrete classes.”.[5] abstract factory
【C#设计模式】4.工厂方法模式（Factory Method Pattern）【创建型】
星Yeah 的博客
07-18 4159
随着需求的变化我们要不停地修改工厂里面的方法的代码，需求变化越多，里面的If–Else–也越多，这样就会造成简单工厂的实现逻辑过于复杂。设计模式是遵循一定原则而得来的，比如，我们要怎么增加代码，怎么修改代码，不是想怎么来就怎么来的，其中一个原则就是OCP原则，中文是【开放关闭原则】，对增加代码开发，对修改代码关闭，所以我们就不能总是这样修改简单工厂里面的方法。......
23种设计模式之工厂方法模式（Factory Method Pattern）
小威的博客
05-09 2万+
本篇文章将23种设计模式中的工厂方法模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
设计模式精讲 Day 2：工厂方法模式（Factory Method Pattern）
在未来等你的专栏
06-15 1200
工厂方法模式是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定实例化哪一个类。工厂方法让类的实例化延迟到子类中进行，从而避免了直接在客户端代码中硬编码具体的类名。核心思想：将对象的创建职责交给子类，而不是在父类中硬编码。该模式通过封装对象的创建逻辑，实现了对变化的隔离，使系统更加灵活、可扩展。Log/*** 日志记录器接口*/LogFactory工厂方法：关注单一产品的创建，每个工厂只负责一种产品。抽象工厂：关注一组相关产品的创建，适合创建多个相关对象。
设计模式：工厂方法模式（Factory Method Pattern）
TechNomad的博客
08-24 984
工厂方法模式是一种创建型设计模式，主要解决对象创建的问题。它的核心思想是：把对象的创建和使用分离，让使用者不直接依赖具体类，而是通过工厂来获得对象。
23种设计模式——工厂方法模式（Factory Method Pattern）详解
最新发布
Meteors.的博客
09-04 1359
本文介绍了23种经典设计模式之——工厂方法模式（Factory Method Pattern）的说明及使用
23种设计模式之工厂方法模式（Factory Method Pattern）【设计模式】
李赛赛的专栏
03-03 1316
📒工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它通过定义一个创建对象的接口来让子类决定实例化哪一个类，使得一个类的实例化延迟到其子类。这种模式的核心思想是将对象的创建过程推迟到子类，从而实现更灵活、更可扩展的代码。// 抽象产品 - 文档。
创建型设计模式（3）—— 工厂方法模式（Factory Method Pattern）
Doublelv 的博客专栏。
03-01 1719
1.概述使用设计模式可以提高代码的可复用性、可扩充性和可维护性。工厂方法模式（Factory Method Pattern）属于创建型模式，定义一个创建对象的接口，但由子类决定实例化某一个类，让工厂类把实例化推迟到子类。在前面的设计模式（四)——简单工厂模式中我们介绍了简单工厂模式，接下来将介绍下工厂方法模式，它同样是创建型设计模式，有相似之处，但又有些不同，文章的末尾会介绍他们之间的不同。这里借用...
设计模式-工厂方法模式（Factory Method Pattern）
weixin_45226668的博客
05-10 1069
设计模式-工厂方法模式（Factory Method Pattern）
设计模式——工厂方法模式（Factory Method Pattern）
ddm
01-08 1648
说工厂方法模式之前，先说下简单工厂模式，简单工厂模式并不属于GoF 23个经典设计模式，但通常将它作为学习其他工厂模式的基础，它的设计思想很简单，其基本流程如下：首先将需要创建的各种不同对象（例如各种不同的Chart对象）的相关代码封装到不同的类中，这些类称为具体产品类，而将它们公共的代码进行抽象和提取后封装在一个抽象产品类中，每一个具体产品类都是抽象产品类的子类；然后提供一个工厂类用于创建各种产品，在工厂类中提供一个创建产品的工厂方法，该方法可以根据所传入的参数不同创建不同的具体产品对象；
设计模式之工厂方法模式(Factory Method Pattern)
giser@2011的博客
06-16 1417
工厂方法模式（Factory Method Pattern）是一种创建型设计模式，它提供了一种创建对象的接口，但实际创建对象的工作由子类完成。这种模式的主要目的是降低类之间的耦合度，增强类的独立性，并提高系统的可维护性和可扩展性。工厂方法模式的主要特点（1）分离了算法和对象创建：通过工厂方法，我们可以将对象的创建和使用分离，使得代码更加清晰和易于维护。（2）实现多态：工厂方法允许子类实现自己的行为，从而支持不同的创建策略。（3）避免使用new关键字：工厂方法模式通过工厂方法代替new关键字，可以减少错误。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值