工厂模式 - 简单工厂模式

1. 基本概念

• 简单工厂模式属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例
• 定义了一个创建对象的类，由这个类来封装实例化对象的代码
• 在软件开发中，当我们会用到大量的创建某类的对象的时候，就会使用该模式

2. 一个例子

有一个披萨项目，要便于披萨种类的扩展，便于维护
① 披萨的种类很多(如GreekPizza，CheesePizza等)
② pizza的制作有prepare，break，cut，box
③ 完成披萨店订购功能

2.1 最初的想法

因为有很多不同种类的pizza，所以为他们抽象出来一个pizza抽象类，里面有pizza的prepare，break，cut，box公有方法，再对具体的pizza继承pizza抽象类，实现相应的方法

Pizza抽象类

public abstract class Pizza {
    protected String name;
    /**
     * 每种pizza都有自己的原材料，所以prepare方法应该是抽象的由子类实现
     */
    public abstract void prepare();

    /**
     * bake cut box方法大同小异可以在这里一起实现
     */
    public void bake(){
        System.out.println("bake");
    }

    public void cut(){
        System.out.println("cut");
    }

    public void box(){
        System.out.println("box");
    }
}

两个具体实现类

public class CheesePizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给CheesePizza准备原材料");
    }
}

public class GreekPizza extends Pizza {
    @Override
    public void prepare() {
        System.out.println("给GreekPizza准备原材料");
    }
}

还需要一个PizzaStore来订购Pizza的订单，当我们新建一个订单就会完成对一个pizza的定制

PizzaStore类

public class PizzaStore{
    public OrderPizza(String type){
        Pizza pizza = null;
        if(type.equals("CheesePizza")){
            pizza = new CheesePizza();
        }
        if(type.equals("GreekPizza")){
            pizza = new GreekPizza();
        }
        if(pizza!=null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
    }
}

可以看到只要产生了一个OrderPizza的订单，它的构造器就完成了一个pizza的定制

2.2 简单工厂模式改进

违背了设计模式的开闭原则
可以想到上面的代码是有问题的，如果这个时候我新增了一个pizza的具体类，那么为了生产这个pizza，我需要在OrderPizza 里面修改源码，新增if判断生产新增pizza

这样会产生什么问题呢？
我们可能有多个OrderPizza店面，那么如果增肌了一个pizza种类，我们所有的OrderPizza都要改变

改进思路
修改代码我们可以接受，但是希望只修改一处代码，而不是向上面那样修改所有的OrderPizza，根据这个思路我们可以把创建Pizza对象封装到一个类中，当我们有了新的Pizza对象的时候，只需要修改创建Pizza类就行，其他答复不用修改，这就是简单工厂模式

简单工厂类

public class SimpleFactory {
	//根据type返回pizza对象
    public Pizza createPizza(String type){
        Pizza pizza = null;
        if(type.equals("CheesePizza")){
            pizza = new CheesePizza();
        }
        if(type.equals("GreekPizza")){
            pizza = new GreekPizza();
        }
        return pizza;
    }

}

PizzaStore聚合SimpleFactory

public class PizzaStore{
	//为PizzaStore加上了SimpleFactory的引用
    SimpleFactory simpleFactory;
	
    public void PizzaStore(SimpleFactory simpleFactory) {
        this.simpleFactory = simpleFactory;
    }
	
    public OrderPizza(String type){
        Pizza pizza = null;
        pizza = simpleFactory.createPizza(type);
        if(pizza!=null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
    }
}

这也就完成了简单工厂模式

静态工厂模式
简单工厂模式也可以叫静态工厂模式，因为我们完全可以把上面的工厂中的createPizza方法写成静态的，这样我们调用的时候就可以通过类去创建

3. 还可以改进

如果生产的方法发生改变，那么就要进SimpleFactory类中对createPizza方法进行改变，很明显违背了对扩展开发，对修改封闭

改进方法
把SmpleFactory定义为一个接口，再去继承他实现生产不同披萨的工厂

SimpleFactory接口

public interface SimpleFactory {
    public Pizza createPizza();

}

两个具体工厂

public class CheesePizzaFactory implements SimpleFactory {
    @Override
    public Pizza createPizza() {
        Pizza pizza = new CheesePizza();
        return pizza;
    }
}

public class GreekPizzaFactory implements SimpleFactory {
    @Override
    public Pizza createPizza() {
        return new GreekPizza();
    }
}

PizzaStore

@Data
public class PizzaStore{
	//为PizzaStore加上了SimpleFactory的引用
    SimpleFactory simpleFactory;
	
    public void PizzaStore(SimpleFactory simpleFactory) {
        this.simpleFactory = simpleFactory;
    }
	
    public OrderPizza(){
        Pizza pizza = null;
        pizza = simpleFactory.createPizza();
        if(pizza!=null){
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.box();
        }
    }
}

这样主需要确定工厂就可以生产出想要的Pizza，而且满足开闭原则，想新产新的pizzza只需要创建新的Factory即可