简单工厂模式｜工厂方法模式｜抽象工厂模式

工厂模式（Factory Pattern）是一种创建型设计模式，用于将对象的创建与使用分离。

业务场景

假设我们有一个支付系统，需要支持多种支付方式（如支付宝、微信支付、信用卡）。

简单工厂

定义：简单工厂模式又称为静态工厂方法模式，由一个工厂类根据参数创建特定对象。

• 特点：
  通过一个静态方法来创建对象，客户端无需直接实例化对象。
  单一工厂类负责所有产品对象的创建。
• 优点：
  封装了对象创建的逻辑，客户端无需了解具体实现。
• 缺点：
  工厂类职责过重，违反“单一职责原则”。
  增加新产品需要修改工厂类，违反“开闭原则”。

// 定义支付接口
public interface Payment {
    void pay(double amount);
}

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

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

// 支付方式：信用卡支付
public class CreditCardPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("使用信用卡支付：" + amount + " 元");
    }
}

// 支付工厂类
public class PaymentFactory {
    public static Payment getPayment(String type) {
        switch (type) {
            case "ALIPAY":
                return new Alipay();
            case "WECHAT":
                return new WeChatPay();
            case "CREDITCARD":
                return new CreditCardPay();
            default:
                throw new IllegalArgumentException("未知的支付方式: " + type);
        }
    }
}

// 主程序
public class PaymentService {
    public static void main(String[] args) {
        // 模拟用户选择支付方式
        String paymentType = "WECHAT"; // 用户选择微信支付
        
        // 通过工厂获取对应的支付对象
        Payment payment = PaymentFactory.getPayment(paymentType);
        
        // 调用支付方法
        payment.pay(100.00); // 支付 100 元
    }
}

工厂方法

定义：工厂方法模式为每个具体产品提供一个单独的工厂类，客户端通过具体工厂类创建对象。

• 特点：
  将实例化逻辑延迟到子类，符合“开闭原则”。
  每个工厂类只负责生产一个具体产品。
• 优点：
  符合开闭原则，新增产品时无需修改已有代码。
  客户端只需依赖抽象工厂和抽象产品。
• 缺点：
  增加了系统复杂性，每新增一个产品都需要对应的工厂类。

// 1. 支付接口
public interface Payment {
    void pay(double amount);  // 支付接口，支付金额
}

// 2. 具体支付方式实现

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

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

// 信用卡支付
public class CreditCardPay implements Payment {
    public void pay(double amount) {
        System.out.println("使用信用卡支付：" + amount + "元");
    }
}

// 3. 支付工厂接口
public interface PaymentFactory {
    Payment createPayment();  // 工厂方法，创建支付对象
}

// 4. 具体支付工厂实现

// 支付宝工厂
public class AlipayFactory implements PaymentFactory {
    public Payment createPayment() {
        return new Alipay();
    }
}

// 微信支付工厂
public class WeChatPayFactory implements PaymentFactory {
    public Payment createPayment() {
        return new WeChatPay();
    }
}

// 信用卡支付工厂
public class CreditCardPayFactory implements PaymentFactory {
    public Payment createPayment() {
        return new CreditCardPay();
    }
}

// 5. 客户端代码
public class PaymentClient {
    public static void main(String[] args) {
        // 客户选择使用支付宝支付
        PaymentFactory alipayFactory = new AlipayFactory();
        Payment alipay = alipayFactory.createPayment();
        alipay.pay(100);  // 支付100元
        
        // 客户选择使用微信支付
        PaymentFactory wechatFactory = new WeChatPayFactory();
        Payment wechatPay = wechatFactory.createPayment();
        wechatPay.pay(200);  // 支付200元
        
        // 客户选择使用信用卡支付
        PaymentFactory creditCardFactory = new CreditCardPayFactory();
        Payment creditCardPay = creditCardFactory.createPayment();
        creditCardPay.pay(300);  // 支付300元
    }
}

抽象工厂

定义：抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

• 特点：
  能够生产一族产品（多个相关产品）。
  通过抽象层隔离具体实现，满足“开闭原则”。
• 优点：
  客户端与具体类解耦。
  易于扩展，可以创建多种产品系列。
• 缺点：
  系统复杂性较高，新增产品系列较难。

// 抽象工厂接口
public interface PaymentFactory {
    Payment createPayment();  // 创建支付方式
    Receipt createReceipt();  // 创建支付凭证
}

// 支付接口
public interface Payment {
    void pay(double amount);
}

// 支付凭证接口
public interface Receipt {
    void generateReceipt();
}

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

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

// 支付凭证实现类：支付宝
public class AlipayReceipt implements Receipt {
    @Override
    public void generateReceipt() {
        System.out.println("生成支付宝支付凭证");
    }
}

// 支付凭证实现类：微信支付
public class WeChatReceipt implements Receipt {
    @Override
    public void generateReceipt() {
        System.out.println("生成微信支付凭证");
    }
}

// 支付宝工厂
public class AlipayFactory implements PaymentFactory {
    @Override
    public Payment createPayment() {
        return new Alipay();
    }

    @Override
    public Receipt createReceipt() {
        return new AlipayReceipt();
    }
}

// 微信支付工厂
public class WeChatPayFactory implements PaymentFactory {
    @Override
    public Payment createPayment() {
        return new WeChatPay();
    }

    @Override
    public Receipt createReceipt() {
        return new WeChatReceipt();
    }
}

// 主程序
public class PaymentService {
    public static void main(String[] args) {
        // 客户选择支付工厂（抽象工厂）
        PaymentFactory factory = new WeChatPayFactory();  // 可以切换为 AlipayFactory

        // 通过工厂创建支付方式和支付凭证
        Payment payment = factory.createPayment();
        Receipt receipt = factory.createReceipt();

        // 执行支付和生成凭证
        payment.pay(200.00);        // 支付 200 元
        receipt.generateReceipt();  // 生成支付凭证
    }
}

汇总