3、设计模式之工厂方法模式

解决的问题

工厂模式是为了解决简单工厂模式的缺点而设计的：工厂一旦需要生产新产品就需要修改工厂类的方法逻辑，违背了“开放 - 关闭原则

定义

定义了一个创建对象的抽象方法，由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

修改简单工厂模式中的代码

类图如下

披萨类：Pizza

//将pizza定义成抽象类
public abstract class Pizza {
    
    
    protected String name;
    //不同的披萨准备的原材料不一样，因此，定义成抽象方法
    public abstract void prepare();
    public void bake(){
    
    
        System.out.println(name +" baking;");
    }
    public void cut(){
    
    
        System.out.println(name +" cuting;");
    }
    public void box(){
    
    
        System.out.println(name +" boxing;");
    }

    public void setName(String name){
    
    
        this.name=name;
    }
}

披萨实现类：GreekPizza、CheesePizza

public class GreekPizza extends Pizza {
    
    
    @Override
    public void prepare() {
    
    
        setName("希腊披萨");
        System.out.println("希腊披萨准备原材料中");
    }
}

public class CheesePizza extends Pizza {
    
    
    @Override
    public void prepare() {
    
    
        setName("奶酪披萨");
        System.out.println("奶酪披萨准备原材料中");
    }
}

工厂抽象类：PizzaFacroty

public abstract class PizzaFacroty {
    
    
    Pizza pizza = null;
    String orderType;

    public PizzaFacroty() {
    
    
        pizza = createPizza(); //抽象方法
        //输出pizza
        if (pizza != null) {
    
    
            pizza.prepare();
            pizza.bake();
            pizza.cut();
            pizza.bake();
        } else {
    
    
            System.out.println("订购披萨失败");
        }
    }

    //定义一个抽象方法，让各个工厂子类自己实现
    abstract Pizza createPizza();
}

工厂实现类：PizzaFacroty、PizzaFacroty

public class GreekPizzaFactory extends PizzaFacroty {
    
    
    @Override
    Pizza createPizza() {
    
    
        Pizza pizza = new GreekPizza();
        return pizza;
    }
}

public class CheesePizeFacroty extends PizzaFacroty {
    
    
    @Override
    Pizza createPizza() {
    
    
        Pizza pizza = new CheesePizza();
        return pizza;
    }
}

主函数类：PizzaStore

public class PizzaStore {
    
    
    public static void main(String[] args) {
    
    
        String orderType = getType();
        if("greek".equals(orderType)) {
    
    
            new GreekPizzaFactory();
        }
        else if("cheese".equals(orderType))
        {
    
    
            new CheesePizeFacroty();
        }
    }
    
    private static String getType() {
    
    
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        System.out.println("input pizza type:");
        String str = null;
        try {
    
    
            str = in.readLine();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        }
        return str;
    }
}

总结：遵守了开闭原则和单一职责原则，如果新增一类披萨不需要修改原来的代码，只需要新增一个披萨实现类和对应的工厂实现类就行，一个工厂类只负责创建对应的产品。但是代码变得复杂了，同时会有更多的类需要编译和运行，给系统带来了一些额外的开销，而且一个工厂只能创建一类产品