用披萨订购案例详细讲解三种工厂模式

披萨订购场景的三种工厂模式

在日常生活中，你可能经常会去披萨店购买披萨，这个场景中就会涉及到工厂模式。工厂模式是一种常用的设计模式，可以将对象的创建过程封装成一个独立的模块，从而让调用者无需关心对象的具体创建细节。在披萨订购场景中，工厂模式可以帮助我们快速创建不同的披萨类型，从而简化代码并提高程序的可维护性。

1. 简单工厂模式

简单工厂模式是最简单的一种工厂模式，它通过一个静态方法来创建对象。在披萨订购场景中，我们可以创建一个披萨工厂类，该类提供了一个静态方法来创建不同的披萨类型。例如，我们可以定义一个名为“PizzaFactory”的类，其中包含以下代码：

public class PizzaFactory {

    public static Pizza createPizza(String type) {
        if (type.equals("纽约")) {
            return new NYPizza();
        } else if (type.equals("芝加哥")) {
            return new ChicagoPizza();
        } else {
            return null;
        }
    }
}

这个工厂类提供了两个静态方法，用于创建纽约披萨和芝加哥披萨。我们可以通过以下代码来使用这个工厂类：

Pizza pizza = PizzaFactory.createPizza("纽约");

这段代码将创建一个纽约披萨对象，并将其存储在“pizza”变量中。

2. 工厂方法模式

工厂方法模式是一种更灵活的工厂模式，它通过一个抽象类来定义对象的创建方法，并由其子类来实现这些方法。在披萨订购场景中，我们可以创建一个抽象的披萨类，该类提供一个抽象方法用于创建披萨。例如，我们可以定义一个名为“Pizza”的抽象类，其中包含以下代码：

public abstract class Pizza {

    public abstract void prepare();

    public abstract void bake();

    public abstract void cut();

    public abstract void box();
}

这个抽象类定义了披萨创建的四个步骤：准备、烘焙、切割和装盒。我们可以通过以下代码来创建纽约披萨和芝加哥披萨的子类：

public class NYPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("准备纽约披萨");
    }

    @Override
    public void bake() {
        System.out.println("烘焙纽约披萨");
    }

    @Override
    public void cut() {
        System.out.println("切割纽约披萨");
    }

    @Override
    public void box() {
        System.out.println("装盒纽约披萨");
    }
}

public class ChicagoPizza extends Pizza {

    @Override
    public void prepare() {
        System.out.println("准备芝加哥披萨");
    }

    @Override
    public void bake() {
        System.out.println("烘焙芝加哥披萨");
    }

    @Override
    public void cut() {
        System.out.println("切割芝加哥披萨");
    }

    @Override
    public void box() {
        System.out.println("装盒芝加哥披萨");
    }
}

这两个子类分别实现了纽约披萨和芝加哥披萨的创建过程。我们可以通过以下代码来创建披萨工厂类：

public class PizzaFactory {

    public Pizza createPizza(String type) {
        if (type.equals("纽约")) {
            return new NYPizza();
        } else if (type.equals("芝加哥")) {
            return new ChicagoPizza();
        } else {
            return null;
        }
    }
}

这个工厂类与简单工厂模式的工厂类非常相似，但它使用抽象类来定义对象的创建过程，从而使工厂类更加灵活和可扩展。

3. 抽象工厂模式

抽象工厂模式是一种更高级的工厂模式，它通过一个抽象工厂类来创建一系列相关对象。在披萨订购场景中，我们可以创建一个抽象披萨工厂类，该类提供一系列方法用于创建披萨、披萨面团和披萨酱。例如，我们可以定义一个名为“PizzaAbstractFactory”的抽象类，其中包含以下代码：

public abstract class PizzaAbstractFactory {

    public abstract Pizza createPizza(String type);

    public abstract Dough createDough();

    public abstract Sauce createSauce();
}

这个抽象类定义了三个方法，用于创建披萨、披萨面团和披萨酱。我们可以通过以下代码来创建纽约披萨工厂和芝加哥披萨工厂：

public class NYPizzaFactory extends PizzaAbstractFactory {

    @Override
    public Pizza createPizza(String type) {
        if (type.equals("纽约")) {
            return new NYPizza();
        } else {
            return null;
        }
    }

    @Override
    public Dough createDough() {
        return new NYDough();
    }

    @Override
    public Sauce createSauce() {
        return new NYSauce();
    }
}

public class ChicagoPizzaFactory extends PizzaAbstractFactory {

    @Override
    public Pizza createPizza(String type) {
        if (type.equals("芝加哥")) {
            return new ChicagoPizza();
        } else {
            return null;
        }
    }

    @Override
    public Dough createDough() {
        return new ChicagoDough();
    }

    @Override
    public Sauce createSauce() {
        return new ChicagoSauce();
    }
}

这两个工厂类分别实现了纽约披萨工厂和芝加哥披萨工厂，它们都提供了创建披萨、披萨面团和披萨酱的方法。我们可以通过以下代码来使用这些工厂类：

PizzaAbstractFactory factory = new NYPizzaFactory();
Pizza pizza = factory.createPizza("纽约");

这段代码将创建一个纽约披萨工厂，并使用这个工厂来创建纽约披萨。

总结

工厂模式是一种常用的设计模式，可以将对象的创建过程封装成一个独立的模块，从而让调用者无需关心对象的具体创建细节。在披萨订购场景中，我们可以使用简单工厂模式、工厂方法模式和抽象工厂模式来创建不同的披萨类型。这三种模式各有优缺点，但它们都能够帮助我们简化代码并提高程序的可维护性。