【设计模式】用Java实现工厂模式

一.工厂模式介绍与使用场景

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的方式，将对象的实例化过程封装在工厂类中，使得客户端代码与具体对象的创建过程解耦。

工厂模式基于一个简单的原则：将对象的创建与使用分离。它通过引入一个工厂类，将对象的实例化过程集中在工厂类中，并提供一个统一的接口供客户端使用，从而降低了客户端与具体对象之间的依赖关系。

工厂模式包含三个核心角色：

1. 抽象产品（Abstract Product）：定义了产品的共同接口，所有具体产品都实现了这个接口。

2. 具体产品（Concrete Product）：实现了抽象产品接口，是工厂模式中要创建的对象。

3. 抽象工厂（Abstract Factory）：定义了创建产品的方法，返回抽象产品类型的对象。

应用场景：

1. 当一个类不知道它所必须创建的对象的类时，可以使用工厂模式。工厂模式将对象的实例化过程封装在工厂类中，客户端只需与工厂类进行交互，无需了解具体的实现类。这样可以减少类之间的耦合性，提高代码的灵活性和可维护性。

2. 当一个类希望由子类来指定所要创建的对象时，可以使用工厂模式。抽象工厂定义了创建产品的方法，具体的工厂子类负责实现这个方法并创建具体产品。这样可以使得系统的扩展性更好，新加入的产品只需要添加相应的具体工厂类即可。

3. 当需要通过一组相关的对象来实现某个功能时，可以使用工厂模式。抽象工厂可以创建一组相关的产品对象，保证这些对象之间的兼容性。这样可以确保在创建产品时不会出现不匹配或不一致的情况。

4. 当需要创建复杂对象时，可以使用工厂模式。工厂模式可以封装复杂对象的创建过程，将其拆分成多个简单的步骤，并由工厂类负责组装这些步骤，最终返回一个完整的对象。这样可以提高代码的可读性和可维护性。

5. 当需要动态切换不同的实现时，可以使用工厂模式。工厂模式可以根据配置或者条件选择不同的具体工厂类来创建对象，从而实现运行时的动态切换。这样可以方便地切换不同的实现，而不需要修改客户端的代码。

二.工厂模式实现

下面以一个简单的汽车工厂为例，使用Java实现工厂模式：

首先，定义抽象产品接口 Car：

public interface Car {
    void drive();
}

然后，创建两个具体产品类 Sedan 和 SUV，它们实现了抽象产品接口：

public class Sedan implements Car {
    @Override
    public void drive() {
        System.out.println("Driving Sedan");
    }
}

public class SUV implements Car {
    @Override
    public void drive() {
        System.out.println("Driving SUV");
    }
}

接下来，创建抽象工厂接口 CarFactory，定义了创建汽车的方法：

public interface CarFactory {
    Car createCar();
}

然后，创建具体工厂类 SedanFactory 和 SUVFactory，它们实现了抽象工厂接口，并分别负责创建 Sedan 和 SUV：

public class SedanFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Sedan();
    }
}

public class SUVFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SUV();
    }
}

最后，我们可以在客户端中使用工厂模式来创建汽车对象：

public class Client {
    public static void main(String[] args) {
        CarFactory sedanFactory = new SedanFactory();
        Car sedan = sedanFactory.createCar();
        sedan.drive();  // 输出：Driving Sedan
        
        CarFactory suvFactory = new SUVFactory();
        Car suv = suvFactory.createCar();
        suv.drive();  // 输出：Driving SUV
    }
}

在上述示例中，我们通过抽象工厂接口和具体工厂类来创建不同类型的汽车对象。客户端只需与抽象工厂接口和抽象产品接口进行交互，而无需直接调用具体产品类，从而实现了客户端与具体对象之间的解耦。

工厂模式可以提供灵活性和可扩展性，将对象的创建过程封装在工厂类中，使得系统更易于维护和扩展。它常用于框架设计、依赖注入（DI）等场景中。

现在我们再用一个贴近实际的例子说明

假设我们正在开发一个电商系统，其中有多个支付方式，包括支付宝支付和微信支付。我们希望使用工厂模式来创建不同的支付对象，以实现支付的灵活性和可扩展性。

首先，我们定义一个抽象产品接口 Payment，用于表示支付方式：

public interface Payment {
    void pay(double amount);
}

然后，创建两个具体产品类 Alipay 和 WeChatPay，它们实现了抽象产品接口：

public class Alipay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Using Alipay to pay: $" + amount);
    }
}

public class WeChatPay implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Using WeChat Pay to pay: $" + amount);
    }
}

接下来，创建一个工厂类 PaymentFactory，用于根据不同的支付方式创建具体的支付对象：

public class PaymentFactory {
    public static Payment createPayment(String paymentType) {
        if (paymentType.equalsIgnoreCase("Alipay")) {
            return new Alipay();
        } else if (paymentType.equalsIgnoreCase("WeChatPay")) {
            return new WeChatPay();
        } else {
            throw new IllegalArgumentException("Unsupported payment type: " + paymentType);
        }
    }
}

最后，我们可以在客户端中使用工厂模式来创建支付对象：

public class Client {
    public static void main(String[] args) {
        // 创建支付对象
        Payment alipay = PaymentFactory.createPayment("Alipay");
        Payment weChatPay = PaymentFactory.createPayment("WeChatPay");
        
        // 使用支付对象进行支付
        double amount = 100.0;
        alipay.pay(amount);
        weChatPay.pay(amount);
    }
}

在上述示例中，我们使用工厂模式通过 PaymentFactory 创建了具体的支付对象，而客户端只需与抽象产品接口 Payment 进行交互，无需直接调用具体的支付类。这样可以实现支付方式的灵活切换和扩展，例如在工厂类中新增其他支付方式时，客户端的代码无需修改。