面向对象语言中的设计模式——工厂模式

工厂模式可以细分为三种：简单工厂模式、工厂模式和抽象工厂模式。
工厂模式顾名思义，将程序比作工厂，其中的对象比作加工的产品，根据产品的不同选择不同的生产方式。

举例：有一家披萨店，向顾客提供多种口味的披萨，设计这样的一个披萨店。

披萨种类：

1. 芝士比萨（CheesePizza）
2. 希腊比萨（GreekPizza）
3. 腊肠比萨（PepperoniPizza）

代码实现：

public class PizzaStore {
    Pizza orderPizza(Srting type) {
        Pizza pizza;

        //根据pizza类型决定具体类
        if(type.equals("cheese")) {
            pizza = new CheesePizza();
        }
        else if(type.equals("Greek")) {
            pizza = new GreekPizza();
        }
        else if(type.equals("pepperoni") {
            pizza = new PepperonPizza();
        })

        //使用pizza类的方法做一些准备
        pizza.prepare(); 

        return pizza;
    }
}

优点：写法简单
缺点：增加或者去掉披萨种类时需要改变该类的代码，违背了开闭原则

修改如下：
将创建披萨对象的代码从orderPizza方法中抽离
定义一个新的类SimplePizzaFactory，负责创建披萨对象

public class SimplePizzaFactory {
    public Pizza orderPizza(String type) {
        Pizza pizza;

        //根据pizza类型决定具体类
        if(type.equals("cheese")) {
            pizza = new CheesePizza();
        }
        else if(type.equals("Greek")) {
            pizza = new GreekPizza();
        }
        else if(type.equals("pepperoni") {
            pizza = new PepperonPizza();
        })

        //使用pizza类的方法做一些准备
        pizza.prepare(); 

        return pizza;
    }
}


public class PizzaStore {
    //构造器
    SimplePizzaFactory factory;
    public PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }

    public Pizza orderPizza(String type) {
        Pizza pizza;

        //根据传入订单类型使用工厂创建披萨
        pizza = factory.createPizza(type);

        // //根据pizza类型决定具体类
        // if(type.equals("cheese")) {
        //     pizza = new CheesePizza();
        // }
        // else if(type.equals("Greek")) {
        //     pizza = new GreekPizza();
        // }
        // else if(type.equals("pepperoni") {
        //     pizza = new PepperonPizza();
        // })

        //使用pizza类的方法做一些准备
        pizza.prepare(); 

        return pizza;
    }
}

简单工厂模式：

新的需求：

• 在多个城市开设不同的加盟店
• 每个店制作披萨的方式统一
• 每个店的披萨需要适应当地口味
  • 纽约（NY）比萨工厂，生产纽约风味的各种比萨
  • 芝加哥（Chicago）比萨工厂，生产芝加哥风味的各种比萨

解决方法：
把createPizza()方法放回到PizzaStore中， 并设置为抽象方法，然后为每个区域创建一个PizzaStore的子类。
并不急于创建createPizza()的具体方法，可拓展，之前写好的代码无需修改就能创建新的方法

public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza;

        //根据传入订单类型使用工厂创建披萨
        pizza = createPizza(type);

        pizza.prepare(); 

        return pizza;
    }

    //创建抽象方法供子类实现
    abstract Pizza createPizza(String type);
}

工厂方法：来处理对象的创建，并将这样的行为封装在子类中

分店的实现：

public class NYPizzaStore extends PizzaStore {
    @Override
    Pizza createPizza(String type) {
        Pizza pizza = null;

        //根据pizza类型决定具体类
        if(type.equals("cheese")) {
            pizza = new NYStyleCheesePizza();
        }
        else if(type.equals("Greek")) {
            pizza = new NYStyleGreekPizza();
        }
        else if(type.equals("pepperoni") {
            pizza = new NYStylePepperonPizza();
        })
        return pizza;
    }
}

工厂方法：工厂方法使一个类的实例化延迟到其子类

抽象工厂模式（Abstract Factory Pattern）：是围绕一个超级工厂创建其他工厂。该超级
工厂又称为其他工厂的工厂
把产品分为产品等级和产品族

标签：披萨,equals,工厂,面向对象,new,设计模式,type,pizza
来源： https://www.cnblogs.com/asdf1229/p/16057431.html