工厂模式

工厂模式分为简单工厂模式、工厂模式和抽象工厂模式。

目的:让使用者只需要关注自己需要的，而不需要关注这个东西是怎么创建的，能用就行。让实例创建和实例使用。

简单工厂模式

一个工厂类 + 多个产品类别，工厂类根据传入的 “标识” 创建对应产品实例。

下面以 “支付方式” 为例（微信支付、支付宝支付、银联支付）讲解

1. 定义产品接口（统一所有产品的行为）

// 支付接口：定义所有支付方式的统一行为
public interface Payment {
    // 支付方法
    void pay(double amount);
}

2. 实现具体产品类（不同的支付方式）

// 微信支付实现
public class WechatPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount + "元");
    }
}

// 支付宝支付实现
public class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}

3. 创建简单工厂类（统一创建产品）

// 支付工厂：根据标识创建对应支付实例
public class PaymentFactory {
    // 静态方法：无需创建工厂实例，直接调用
    public static Payment createPayment(String type) {
        switch (type) {
            case "wechat":
                return new WechatPay();
            case "alipay":
                return new Alipay();
            default:
                throw new IllegalArgumentException("不支持的支付方式：" + type);
        }
    }
}

4. 使用工厂（使用者无需关心创建细节）

public class Client {
    public static void main(String[] args) {
        // 需求1：微信支付
        Payment wechatPay = PaymentFactory.createPayment("wechat");
        wechatPay.pay(100.0); // 输出：使用微信支付：100.0元
        
        // 需求2：支付宝支付
        Payment alipay = PaymentFactory.createPayment("alipay");
        alipay.pay(50.0); // 输出：使用支付宝支付：50.0元
    }
}

• 优点：使用者只需传 “类型”，无需知道WechatPay/Alipay的创建细节；
• 缺点：新增支付方式（如银联支付）需要修改工厂类的switch逻辑，违反 “开闭原则”（对扩展开放，对修改关闭）。

工厂方法模式

解决简单工厂的 “修改问题”

核心思路：为每个产品创建一个对应的 “工厂子类”，工厂父类定义创建产品的抽象方法，子类实现具体创建逻辑。新增产品时，只需新增 “产品类 + 工厂子类”，无需修改原有代码。

1. 复用上面的Payment接口和具体产品类（WechatPay/Alipay）

// 支付接口：定义所有支付方式的统一行为
public interface Payment {
    // 支付方法
    void pay(double amount);
}

// 微信支付实现
public class WechatPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用微信支付：" + amount + "元");
    }
}

// 支付宝支付实现
public class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}

2. 定义工厂接口（抽象工厂）

// 支付工厂接口：定义创建支付实例的抽象方法
public interface PaymentFactory {
    Payment createPayment();
}

3. 实现具体工厂子类（每个产品对应一个工厂）

// 微信支付工厂
public class WechatPayFactory implements PaymentFactory {
    @Override
    public Payment createPayment() {
        // 可以在这里添加微信支付的初始化逻辑（如配置appId、密钥）
        return new WechatPay();
    }
}

// 支付宝支付工厂
public class AlipayFactory implements PaymentFactory {
    @Override
    public Payment createPayment() {
        // 支付宝的初始化逻辑（如配置appId、私钥）
        return new Alipay();
    }
}

4. 使用工厂（按需选择工厂）

public class Client {
    public static void main(String[] args) {
        // 需求1：微信支付 → 使用微信工厂
        PaymentFactory wechatFactory = new WechatPayFactory();
        Payment wechatPay = wechatFactory.createPayment();
        wechatPay.pay(100.0);
        
        // 需求2：支付宝支付 → 使用支付宝工厂
        PaymentFactory alipayFactory = new AlipayFactory();
        Payment alipay = alipayFactory.createPayment();
        alipay.pay(50.0);
        
        // 新增银联支付：只需加UnionPay类 + UnionPayFactory类，无需修改原有代码
        // PaymentFactory unionPayFactory = new UnionPayFactory();
        // Payment unionPay = unionPayFactory.createPayment();
    }
}

• 优点：符合开闭原则，新增产品只需新增工厂子类，无需修改原有工厂；
• 缺点：产品和工厂一一对应，产品多了会导致类数量爆炸（比如 10 个支付方式需要 10 个工厂类）。

抽象工厂模式

适用于 “产品族” 场景 -产品族：微信 PC 支付 + 微信移动端支付，这两个功能构成了一个产品族。

1. 为什么抽象工厂是创建产品族的？ “同一品牌 / 体系下的、相互兼容的多个产品等级的组合，是产品族”。工厂只会创建 “同一品牌 / 体系” 的产品等级（比如微信工厂只造微信的 PC/Mobile/ 退款）；

抽象工厂是 “生产整套品牌产品的工厂”，不是 “生产单个功能产品的工厂” —— 这就是它被定义为 “产品族模式” 的根本原因。

• 「产品等级」是抽象工厂的“零件”（比如 PC 支付、Mobile 支付）；
• 「产品族」是抽象工厂的“成品”（比如微信的 PC+Mobile 支付、支付宝的 PC+Mobile 支付）；

核心思路：工厂不仅创建 “单个产品”，而是同一品牌下的多个产品。比如：“微信支付” 包含 “手机端支付” 和 “PC 端支付”，“支付宝” 也包含这两类 —— 这组相关产品就是一个 “产品族”，抽象工厂负责创建同一品牌下的整个产品族。

1.定义多个产品接口（产品族的不同维度）

// 手机端支付接口
public interface MobilePayment {
    void mobilePay(double amount);
}

// PC端支付接口
public interface PcPayment {
    void pcPay(double amount);
}

2. 实现具体产品（产品族的具体实现）

// 微信-手机端支付
public class WechatMobilePayment implements MobilePayment {
    @Override
    public void mobilePay(double amount) {
        System.out.println("微信手机端支付：" + amount + "元");
    }
}

// 微信-PC端支付
public class WechatPcPayment implements PcPayment {
    @Override
    public void pcPay(double amount) {
        System.out.println("微信PC端支付：" + amount + "元");
    }
}

// 支付宝-手机端支付
public class AlipayMobilePayment implements MobilePayment {
    @Override
    public void mobilePay(double amount) {
        System.out.println("支付宝手机端支付：" + amount + "元");
    }
}

// 支付宝-PC端支付
public class AlipayPcPayment implements PcPayment {
    @Override
    public void pcPay(double amount) {
        System.out.println("支付宝PC端支付：" + amount + "元");
    }
}

3. 定义抽象工厂（创建产品族的接口）

// 支付产品族工厂接口：能创建手机端+PC端支付
public interface PaymentFamilyFactory {
    MobilePayment createMobilePayment();
    PcPayment createPcPayment();
}

4. 实现具体抽象工厂（每个产品族对应一个工厂）

// 微信产品族工厂：创建微信的手机端+PC端支付
public class WechatPaymentFactory implements PaymentFamilyFactory {
    @Override
    public MobilePayment createMobilePayment() {
        return new WechatMobilePayment();
    }

    @Override
    public PcPayment createPcPayment() {
        return new WechatPcPayment();
    }
}

// 支付宝产品族工厂：创建支付宝的手机端+PC端支付
public class AlipayPaymentFactory implements PaymentFamilyFactory {
    @Override
    public MobilePayment createMobilePayment() {
        return new AlipayMobilePayment();
    }

    @Override
    public PcPayment createPcPayment() {
        return new AlipayPcPayment();
    }
}

5. 使用抽象工厂（创建整个产品族）

public class Client {
    public static void main(String[] args) {
        // 需求：创建微信产品族（手机+PC支付）
        PaymentFamilyFactory wechatFactory = new WechatPaymentFactory();
        MobilePayment wechatMobile = wechatFactory.createMobilePayment();
        PcPayment wechatPc = wechatFactory.createPcPayment();
        wechatMobile.mobilePay(80.0); // 微信手机端支付：80.0元
        wechatPc.pcPay(200.0); // 微信PC端支付：200.0元

        // 需求：创建支付宝产品族
        PaymentFamilyFactory alipayFactory = new AlipayPaymentFactory();
        MobilePayment alipayMobile = alipayFactory.createMobilePayment();
        alipayMobile.mobilePay(50.0); // 支付宝手机端支付：50.0元
    }
}

• 优点：能统一创建一组相关产品，保证产品族内的产品兼容性；
• 缺点：扩展产品族的 “维度”（比如新增 “平板端支付”）需要修改抽象工厂接口，违反开闭原则，适合产品族稳定的场景。

工厂模式的核心价值

• 解耦：对象创建和使用分离，使用者只需关注 “用什么”，不用关注 “怎么创建”；
• 易扩展：新增产品时，简单工厂只需改少量代码，工厂方法 / 抽象工厂只需新增类，不影响原有逻辑；
• 易维护：创建逻辑集中在工厂类，修改时只需改工厂，无需改所有使用该对象的地方；
• 隐藏细节：工厂可以在创建对象时做初始化（如配置、连接），使用者无需关心。

三种形式的选择：

• 简单工厂：产品类型少、扩展频率低，追求简单（如支付方式只有 2-3 种）；
• 工厂方法：产品类型多、需要频繁扩展，追求开闭原则（如支付方式可能新增银联、云闪付）；
• 抽象工厂：需要创建一组相关产品（产品族），如 “微信的手机 + PC 支付”“支付宝的手机 + PC 支付”；

核心思想：将对象创建交给专门的工厂，解耦创建与使用，提升代码灵活性；