设计模式——工厂模式

工厂模式是软件设计模式中创建型模式的一种，主要用于解耦对象的创建过程。其核心思想是定义一个用于创建对象的接口或类，让子类决定实例化哪一个类，从而使客户端（调用者）无需知道具体生产何种产品。

原理

工厂模式通常分为三种形态：

简单工厂模式 (Simple Factory Pattern)

• 定义：提供一个静态方法的类（称为工厂类），这个方法接收参数并根据参数返回不同类型的对象实例。
• 原理：客户端不直接创建所需对象，而是通过调用工厂类的静态方法来获取。工厂类内部处理对象的具体创建逻辑，并将创建的对象作为抽象的产品类型返回给客户端。

// 简单工厂示例代码
public interface Pizza {
    void prepare();
}

public class GreekPizza implements Pizza {
    @Override
    public void prepare() {
        // 准备希腊披萨的材料和制作过程
    }
}

public class CheesePizza implements Pizza {
    @Override
    public void prepare() {
        // 准备芝士披萨的材料和制作过程
    }
}

// 工厂类
public class PizzaFactory {
    public static Pizza createPizza(String type) {
        if ("Greek".equals(type)) {
            return new GreekPizza();
        } else if ("Cheese".equals(type)) {
            return new CheesePizza();
        } else {
            throw new IllegalArgumentException("Invalid pizza type");
        }
    }
}

// 使用简单工厂
public class Client {
    public static void main(String[] args) {
        Pizza pizza = PizzaFactory.createPizza("Greek");
        pizza.prepare();
    }
}

工厂方法模式 (Factory Method Pattern)

• 定义：定义一个创建对象的接口，但让子类决定实例化哪个类。工厂方法使一个类的实例化延迟到其子类。
• 原理：在抽象基类中定义一个工厂方法，由子类实现该方法以创建对象。这样每个子类可以决定生成什么类型的对象。

// 工厂方法示例代码
public abstract class PizzaStore {
    abstract Pizza createPizza(String type);
    
    public void orderPizza(String type) {
        Pizza pizza = createPizza(type);
        pizza.prepare();
    }
}

public class GreekPizzaStore extends PizzaStore {
    @Override
    Pizza createPizza(String type) {
        if ("Greek".equals(type)) {
            return new GreekPizza();
        } else {
            throw new IllegalArgumentException("Greek store only sells Greek Pizzas!");
        }
    }
}

// 其他如 CheesePizzaStore 类也类似...

// 使用工厂方法
public class Client {
    public static void main(String[] args) {
        PizzaStore store = new GreekPizzaStore();
        store.orderPizza("Greek");
    }
}

抽象工厂模式 (Abstract Factory Pattern)

• 定义：提供一个接口，用于创建相关或依赖对象家族的一系列工厂方法，而不需要指定具体的类。
• 原理：不仅创建一个产品的实例，还可能创建一系列相互关联或者有依赖关系的产品族，每个产品族是一个特定接口下的多种实现。

```java
// 抽象工厂示例代码简化版
interface PizzaIngredientFactory {
    Dough createDough();
    Sauce createSauce();
    Cheese createCheese();
    // ... 其他配料
}

class GreekPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    Dough createDough() { /* 返回希腊风格面团 */ }

    // 其他实现...
}

class ItalianPizzaIngredientFactory implements PizzaIngredientFactory {
    @Override
    Dough createDough() { /* 返回意大利风格面团 */ }

    // 其他实现...
}

class PizzaStore {
    private final PizzaIngredientFactory ingredientFactory;

    PizzaStore(PizzaIngredientFactory ingredientFactory) {
        this.ingredientFactory = ingredientFactory;
    }

    // 使用工厂来创建披萨及其原料
    // ...
}

// 使用抽象工厂
public class Client {
    public static void main(String[] args) {
        PizzaStore greekStore = new PizzaStore(new GreekPizzaIngredientFactory());
        // 使用希腊风味原料制作披萨
    }
}

应用场景

• 当需要为不同的需求创建具有相同接口的不同对象时。
• 需要解耦对象的创建与使用，隐藏对象创建细节，提高代码的可扩展性和灵活性。
• 创建复杂对象或多个相互依赖的对象时，可以通过抽象工厂一次性创建出对象家族。

适用性

• 在系统需要支持可扩展的系列产品时，例如添加新的披萨种类只需要增加新的工厂实现即可，原有代码无须修改。
• 当一个类希望由它的子类来指定它所创建的对象是什么的时候，使用工厂方法模式。
• 当需要隔离复杂对象的创建过程，特别是当这个过程涉及多步操作且有多种变化因素时，可以考虑抽象工厂模式。