寂然解读设计模式 - 工厂模式 - 简单工厂模式
I walk very slowly, but I never walk backwards
工厂模式 - 简单工厂模式
寂然
大家好~，我是寂然，本节课呢，我们来看下一个，工厂模式， 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一，无论是实际应用还是面试都非常高频和广泛，话不多说，那我们开始启程吧
案例引出 - 披萨订购
那在聊工厂模式之前，我们现来看一个需求
有这样一个披萨店的需求，披萨的种类很多(比如 GreekPizz、CheesePizz 等)
披萨的制作有 prepare，bake，cut，box 等
要求：完成披萨店订购功能，便于披萨种类的扩展，便于维护
拿到这个需求，大家会怎么实现呢？我们先不要想着工厂模式，用平时的思路，来完成下需求
解决方案一 - 一般实现方式
首先我们用一般常用的实现方式来解决，比如我们定义一个抽象类 pizza，因为我们 Pizza 的种类有很多，最容易想到的就是定义一个模板，定义好 Pizza 的通用方法，比如，披萨的制作都需要 prepare，bake，cut，box 等方法，就可以定义到抽象类 Pizza里面，具体种类的 Pizza 继承抽象父类 Pizza ，就可以使用里面的通用方法了，同时子类可以重写方法，实现子类特有的业务逻辑，那根据上面的思路，对应的类图如下图所示
根据类图，我们先把基础的类定义出来，代码示例如下图所示
//抽象类接口 Pizza
public abstract class Pizza {
//定义一个属性，披萨的名称，并给定set方法
protected String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
//认为不同的披萨，准备的原材料不同，所以定义成抽象方法
public abstract void prepare();
//烘焙方法
public void bake() {
System.out.println(name + "正在烘焙中");
}
//切割方法
public void cut() {
System.out.println(name + "正准备把披萨大卸八块");
}
//打包方法
public void box() {
System.out.println(name + "将披萨打包给顾客");
}
}
//希腊披萨
public class GreekPizza extends Pizza {
@Override
public void prepare() {
System.out.println("准备希腊披萨的原材料");
}
}
//奶酪披萨
public class CheesePizza extends Pizza {
@Override
public void prepare() {
System.out.println("准备原材料 奶酪，芝士等");
}
}
OK，架构有了，当然我们还要完成订购披萨的功能，新建 OrderPizza ，写入订购披萨的逻辑，同时我们希望获取客户想要订购的披萨种类，进行订购并制作，完整的实现代码如下图所示
//订购披萨
public class OrderPizza {
//当然后面会进行改进，这是第一版的实现方式
//构造器
public OrderPizza(){
Pizza pizza = null;
String orderType; //订购披萨的类型
while(true){
orderType = getType();//给定一个固定值先
if (orderType.equals("GreekPizza")){
pizza = new GreekPizza();
pizza.setName("GreekPizza");
}else if (orderType.equals("CheesePizza")){
pizza = new CheesePizza();
pizza.setName("CheesePizza");
}else{
break;
}
//输出 Pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}
}
//定义方法获取客户希望订购的披萨种类
private String getType(){
System.out.println("你想订购那个种类的Pizza呢？");
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
return str;
}
}
//披萨商店，发出披萨订购任务
public class PizzaStore {
public static void main(String[] args) {
new OrderPizza(); //构造器中完成相应功能
}
}
方案分析
OK，运行过后，首先保证实现了简易的订购披萨的需求，运行结果如下图所示
那我们来谈谈这种实现方式的利弊
优点：符合我们一般的写法，容易理解和接受
缺点：很明显，违反了设计模式的开闭原则，对扩展开放，对修改关闭，即当我们给类增加新功能的时候，尽量不修改代码，或者尽量少修改代码，而上面的实现方式，假设我们新增 FruitPizza，我们需要做如下改动才能实现
//新定义水果披萨类
public class FruitPizza extends Pizza {
@Override
public void prepare() {
System.out.println("准备原材料 香蕉，菠萝等");
}
}
//新增加判断条件，如果是 FruitPizza 的处理逻辑
else if (orderType.equals("FruitPizza")){
pizza = new FruitPizza();
pizza.setName("FruitPizza");
}
改进思路
其实修改代码是在允许范围内的，但是如果我们在其他的地方也有创建 Pizza 的代码，那就也需要修改，而创建 Pizza 的代码，往往有多处，针对这个问题，我们可以有这样一个思路：把创建 Pizza 对象的功能封装到一个类中，这样我们有新的 Pizza 种类的时候，只需要修改该类即可，其他地方涉及到创建 Pizza 对象的代码就不需要修改了，这种思路其实就是简单工厂模式
基本介绍 - 简单工厂模式
简单工厂模式是属于创建型模式，是工厂模式的一种，简单工厂模式是由一个工厂对象决定创建出哪一种产品/类的实例，简单工厂模式是工厂模式家族中最简单实用的模式
简单工厂模式：定义了一个创建对象的类，由这个类来封装实例化对象的行为，在简单工厂模式中，可以根据参数的不同返回不同类的实例
在软件开发中，当我们涉及到大量的创建某种或者某类对象时，就会使用到工厂模式，你只需要使用工厂对象来需创建对象即可，具体的创建细节被工厂对象封装起来
解决方案二 - 简单工厂模式
那我们使用简单工厂模式的思想，来对代码进行重构，首先定义 SimpleFactory 类，让该类作为工厂对象，来封装实例化对象的行为，原来 订购披萨类 OrderPizza 里不再需要创建Pizza，调用SimpleFactory 类实例化对象的方法即可，代码示例如下图所示
// 案例演示 - 使用简单工厂模式
// 简单工厂类
public class SimpleFactory {
//实例化对象的方法
public Pizza createPizza(String orderType){
Pizza pizza = null;
if (orderType.equals("GreekPizza")){
pizza = new GreekPizza();
pizza.setName("GreekPizza");
}else if (orderType.equals("CheesePizza")){
pizza = new CheesePizza();
pizza.setName("CheesePizza");
}else if (orderType.equals("FruitPizza")){
pizza = new FruitPizza();
pizza.setName("FruitPizza");
}
return pizza;
}
}
上面我们按照简单工厂模式的思想，把按需创建对象的行为封装到 SimpleFactory 工厂类中，那现在 OrderPizza 中依赖 setSimpleFactory 即可，比如以成员属性的形式，那获取客户想要订购的披萨种类，进行订购并制作的逻辑我们另外封装一个方法，或者直接封装在 simpleFactory 的 set() 方法里 ，那根据这样的想法，示例代码如下
//创建简单工厂类对象,给定set方法
SimpleFactory simpleFactory;
Pizza pizza = null; //初始化Pizza对象，初始值为null
//构造器里调用 setSimpleFactory
public OrderPizza(SimpleFactory simpleFactory){
setSimpleFactory(simpleFactory);
}
public void setSimpleFactory(SimpleFactory simpleFactory) {
String ordertype = "";
this.simpleFactory = simpleFactory;
//可能是反复订购
while (true){
ordertype = getType();//得到用户想要的类型
pizza = this.simpleFactory.createPizza(ordertype);
if (pizza != null){ //表示订购成功
//输出 Pizza 制作过程
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
}else{
System.out.println("披萨订购失败，没有你要的Pizza");
break;
}
}
}
//披萨商店，发出披萨订购任务
public class PizzaStore {
public static void main(String[] args) {
//new OrderPizza();
//使用简单工厂模式
new OrderPizza(new SimpleFactory());
}
}
方案分析
OK，上面我们用简单工厂模式将代码重构完毕，首先保订购披萨的需求运行正常，运行结果如下图所示
那我们来聊聊这种方式的好处或者说这种情况下，使用简单工厂模式处理的好处，假设我们新增第四种Pizza，除了对该Pizza进行定义以外，只需要在 SimpleFactory 工厂类，加一条 else if 判断语句即可，其他地方不需要做改动，因为在简单工厂模式中，工厂类负责封装实例化对象的细节，所以业务逻辑中创建 Pizza 的代码只有这一处
简单工厂模式也叫静态工厂模式，举个例子，还可以在 SimpleFactory 工厂类中把实例化对象的方法 createPizza 定义为静态，这样的话 OrderPizza 里直接通过类名来调用 createPizza 即可，不需要通过构造器了，也是可以的，这里就不做演示了
下节预告
OK，由于篇幅的限制，本节内容就先到这里，下一节，我们接着来聊工厂模式，同样是披萨订购的案例，我们进行扩展，引出第二种要介绍的工厂方法模式，最后，希望大家在学习的过程中，能够感觉到设计模式的有趣之处，高效而愉快的学习，那我们下期见~