零基础设计模式——创建型模式 - 工厂方法模式-EW帮帮网

第二部分：创建型模式 - 工厂方法模式 (Factory Method Pattern)

上一节我们学习了单例模式，它关注如何保证一个类只有一个实例。现在，我们来看另一个重要的创建型模式——工厂方法模式。它关注的是如何创建对象，但将创建的决定权推迟到子类。

核心思想：定义一个创建对象的接口，但让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。

工厂方法模式 (Factory Method Pattern)

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

想象一下，你有一家饮料工厂。这家工厂（父类）知道如何生产饮料（定义了生产饮料的流程/接口），但具体生产什么类型的饮料（可乐、雪碧、橙汁等）则由各个专门的生产线（子类工厂）来决定。

1. 目的 (Intent)

工厂方法模式的主要目的：

封装对象创建：将对象的创建过程封装起来，客户端不需要知道具体的产品类名，只需要知道它所需要的产品的抽象类型和对应的工厂。
解耦：将产品的创建和使用分离开。客户端代码仅依赖于抽象产品和抽象工厂，而不依赖于具体产品和具体工厂。这使得系统更加灵活，更容易扩展。
符合开闭原则：当需要增加新的产品时，只需要增加对应的具体产品类和具体工厂类，而不需要修改已有的工厂或客户端代码。

2. 生活中的例子 (Real-world Analogy)

餐厅点餐：
- 抽象工厂 (Abstract Factory)：菜单（定义了可以点什么菜，比如“主食”、“汤”）。
- 具体工厂 (Concrete Factory)：中餐厅菜单、西餐厅菜单。它们都提供“主食”，但中餐厅提供米饭、面条，西餐厅提供牛排、意面。
- 抽象产品 (Abstract Product)：菜品（比如“主食”这个概念）。
- 具体产品 (Concrete Product)：米饭、面条、牛排、意面。
  你（客户端）只需要告诉服务员（通过菜单这个工厂接口）你要一份“主食”，具体是米饭还是牛排，则由你选择的餐厅（具体工厂）决定。
汽车制造厂：
- 一个大型汽车集团（比如大众集团）可以看作是一个抽象工厂的框架。它定义了制造汽车的标准流程。
- 旗下的不同品牌工厂（大众工厂、奥迪工厂、保时捷工厂）就是具体工厂。它们都遵循集团的制造标准，但各自生产不同型号和品牌的汽车。
- 客户想要一辆“轿车”（抽象产品），可以选择去大众工厂买帕萨特（具体产品），也可以去奥迪工厂买A4（具体产品）。
各种笔的制造：
- 抽象工厂：PenFactory (定义一个 createPen() 方法)。
- 具体工厂：PencilFactory (实现 createPen() 返回铅笔)，BallpointPenFactory (实现 createPen() 返回圆珠笔)。
- 抽象产品：Pen (定义 write() 方法)。
- 具体产品：Pencil (实现 write() 写出石墨痕迹)，BallpointPen (实现 write() 写出油墨痕迹)。

3. 结构 (Structure)

工厂方法模式通常包含以下角色：

Product (抽象产品)：定义工厂方法所创建的对象的接口。所有具体产品都必须实现这个接口。
ConcreteProduct (具体产品)：实现 Product 接口的具体类。这些是工厂方法实际创建的对象。
Creator (抽象创建者/抽象工厂)：声明工厂方法 factoryMethod()，该方法返回一个 Product 类型的对象。Creator 也可以定义一个默认的工厂方法实现，返回一个默认的 ConcreteProduct 对象。
ConcreteCreator (具体创建者/具体工厂)：重写（实现）工厂方法 factoryMethod()，以返回一个具体的 ConcreteProduct 实例。

4. 适用场景 (When to Use)

当一个类不知道它所必须创建的对象的类的时候。即，你希望由子类来指定创建哪个对象。
当一个类希望通过其子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
需要解耦框架和具体实现：例如，一个UI框架可能定义了创建按钮的工厂方法，但具体的按钮样式（Windows按钮、Mac按钮）由框架的使用者（子类）来实现。
日志记录器：可以有文件日志记录器工厂、数据库日志记录器工厂等，它们都创建符合日志记录器接口的对象。
数据库访问：可以有 MySQLConnectionFactory、OracleConnectionFactory 等，它们都创建符合 Connection 接口的对象。

5. 优缺点 (Pros and Cons)

优点：

良好的封装性，代码结构清晰：创建过程在具体工厂中实现，客户端代码只关心抽象接口。
扩展性好：增加新的产品时，只需要增加对应的具体产品类和具体工厂类，无需修改现有代码，符合开闭原则。
解耦：将产品创建和产品使用分离，降低了模块间的耦合度。
更灵活：父类只需要关心产品接口，具体创建哪个产品由子类决定，增加了系统的灵活性。

缺点：

类的个数增多：每增加一个产品，就需要增加一个具体产品类和一个对应的具体工厂类，这会使得系统中的类的个数成倍增加，增加了系统的复杂度。
增加了系统的抽象性和理解难度：对于初学者来说，引入了更多的抽象层，可能需要更多时间来理解。

6. 实现方式 (Implementations)

让我们通过一个支付的例子来看看工厂方法模式的实现。
假设我们有一个电商系统，支持多种支付方式，如支付宝支付、微信支付。

抽象产品 (Payment)

// payment.go
package payment

import "fmt"

// Payment 支付接口 (抽象产品)
type Payment interface {
	Pay(amount float64) string
}

// Payment.java
package com.example.payment;

// 支付接口 (抽象产品)
public interface Payment {
    String pay(double amount);
}

具体产品 (Alipay, WechatPay)

// alipay.go
package payment

import "fmt"

// Alipay 支付宝支付 (具体产品)
type Alipay struct{}

func (a *Alipay) Pay(amount float64) string {
	return fmt.Sprintf("使用支付宝支付了 %.2f 元", amount)
}

// wechatpay.go
package payment

import "fmt"

// WechatPay 微信支付 (具体产品)
type WechatPay struct{}

func (w *WechatPay) Pay(amount float64) string {
	return fmt.Sprintf("使用微信支付了 %.2f 元", amount)
}

// Alipay.java
package com.example.payment;

// 支付宝支付 (具体产品)
public class Alipay implements Payment {
    @Override
    public String pay(double amount) {
        return String.format("使用支付宝支付了 %.2f 元", amount);
    }
}

// WechatPay.java
package com.example.payment;

// 微信支付 (具体产品)
public class WechatPay implements Payment {
    @Override
    public String pay(double amount) {
        return String.format("使用微信支付了 %.2f 元", amount);
    }
}

抽象工厂 (PaymentFactory)

// payment_factory.go
package payment

// PaymentFactory 支付工厂接口 (抽象创建者)
type PaymentFactory interface {
	CreatePayment() Payment
}

// PaymentFactory.java
package com.example.payment;

// 支付工厂接口 (抽象创建者)
public interface PaymentFactory {
    Payment createPayment();
}

具体工厂 (AlipayFactory, WechatPayFactory)

// alipay_factory.go
package payment

// AlipayFactory 支付宝工厂 (具体创建者)
type AlipayFactory struct{}

func (af *AlipayFactory) CreatePayment() Payment {
	return &Alipay{}
}

// wechatpay_factory.go
package payment

// WechatPayFactory 微信支付工厂 (具体创建者)
type WechatPayFactory struct{}

func (wf *WechatPayFactory) CreatePayment() Payment {
	return &WechatPay{}
}

// AlipayFactory.java
package com.example.payment;

// 支付宝工厂 (具体创建者)
public class AlipayFactory implements PaymentFactory {
    @Override
    public Payment createPayment() {
        System.out.println("支付宝工厂: 创建支付宝支付对象");
        return new Alipay();
    }
}

// WechatPayFactory.java
package com.example.payment;

// 微信支付工厂 (具体创建者)
public class WechatPayFactory implements PaymentFactory {
    @Override
    public Payment createPayment() {
        System.out.println("微信支付工厂: 创建微信支付对象");
        return new WechatPay();
    }
}

客户端使用

// main.go (示例用法)
/*
package main

import (
	"fmt"
	"./payment" // 假设 payment 包在当前目录下
)

func main() {
	var factory payment.PaymentFactory

	// 用户选择支付宝支付
	factory = &payment.AlipayFactory{}
	alipay := factory.CreatePayment()
	fmt.Println(alipay.Pay(100.50))

	// 用户选择微信支付
	factory = &payment.WechatPayFactory{}
	wechatPay := factory.CreatePayment()
	fmt.Println(wechatPay.Pay(88.88))

    // 如果要增加一种新的支付方式，比如银联支付 UnionPay
    // 1. 创建 UnionPay struct 实现 Payment 接口
    // 2. 创建 UnionPayFactory struct 实现 PaymentFactory 接口
    // 3. 客户端就可以使用: factory = &payment.UnionPayFactory{}
}
*/

// Main.java (示例用法)
/*
package com.example;

import com.example.payment.*;

public class Main {
    public static void main(String[] args) {
        PaymentFactory factory;

        // 用户选择支付宝支付
        factory = new AlipayFactory();
        Payment alipay = factory.createPayment();
        System.out.println(alipay.pay(100.50));

        // 用户选择微信支付
        factory = new WechatPayFactory();
        Payment wechatPay = factory.createPayment();
        System.out.println(wechatPay.pay(88.88));

        // 如果要增加一种新的支付方式，比如银联支付 UnionPay
        // 1. 创建 UnionPay class 实现 Payment 接口
        // 2. 创建 UnionPayFactory class 实现 PaymentFactory 接口
        // 3. 客户端就可以使用: factory = new UnionPayFactory();
    }
}
*/

7. 与简单工厂模式的区别

你可能听说过“简单工厂模式”（Simple Factory Pattern），它不是23种经典GoF设计模式之一，但经常被提及。

简单工厂模式：有一个专门的工厂类，根据传入的参数来决定创建哪种产品类的实例。这个工厂类通常包含一个静态方法或一个实例方法，里面用 if/else 或 switch 来判断。
- 优点：简单直观。
- 缺点：当需要增加新产品时，必须修改工厂类的判断逻辑，违反了开闭原则。工厂类职责过重。
工厂方法模式：定义一个创建对象的接口，但将实际创建工作推迟到子类。每个具体工厂负责创建一个具体产品。
- 优点：符合开闭原则，扩展性好。
- 缺点：类的数量会增加。

核心区别：简单工厂只有一个工厂类，而工厂方法模式有一组工厂类（一个抽象工厂和多个具体工厂）。工厂方法模式将简单工厂的内部判断逻辑转移到了客户端（客户端选择使用哪个具体工厂），或者说，将判断的职责分散到了各个具体工厂子类中。

8. 总结

工厂方法模式通过引入抽象工厂和具体工厂，将对象的创建过程延迟到子类中进行，从而实现了更好的解耦和扩展性。当你的系统中需要创建一系列相关的或相互依赖的对象，并且希望将这些对象的创建与使用分离时，工厂方法模式是一个非常好的选择。

记住它的核心：定义创建接口，子类实现创建。

零基础设计模式——创建型模式 - 工厂方法模式