概念

简单工厂（Simple Factory）模式，又称静态工厂方法模式（Static Factory Method Pattern）。
简单工厂可以理解为，定义一个工厂类，根据传入的参数不同而返回不同的实例，这些实例通常有共同的父类。
虽然简单工厂经常会被使用，但是并不能算作是一种设计模式，反而更像是一种编程习惯。

提出问题

当我们创建产品类对象时，会使用到new操作符，但是代码绑着具体类的实例会导致代码更脆弱，更缺乏弹性。
实例化这个活动不应该总是公开的进行。
否则一旦有变化或扩展，就必须重新打开这段代码进行检查和修改。
我们的原则是：“找出会变化的方面，把他们从不变的部分分离出来”。
即让我们编写的代码符合开放-关闭原则。

思路

创建一个factory类，将创建产品类对象的代码放在factory类中，由factory类的对象专职创建产品类的对象。

UML图

• 工厂类 : Factory
• 抽象产品类 : Product
• 具体产品类 : ConcreteProductA 和 ConcreteProductB

实例

假设有一个披萨店，如果有了披萨订单，运用简单工厂处理披萨订单。

类图

代码：

• 抽象类Pizza

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public abstract class Pizza {
    public void prepare() {
        System.out.println("prepare...");
    }

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

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

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

• Pizza类的实现类CheesePizza

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public class CheesePizza extends Pizza {

}

• Pizza类的实现类VeggiePizza

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public class VeggiePizza extends Pizza {

}

• Pizza类的实现类ClamPizza

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public class ClamPizza extends Pizza {

}

• Pizza类的实现类PepperoniPizza

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public class PepperoniPizza extends Pizza {

}

• 简单工厂类SimplePizzaFactory

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public class SimplePizzaFactory {

    public static Pizza creatPizza(String type) {
        // TODO 所有客户用这个方法来实例化新对象
        Pizza pizza = null;
        if (type.equals("Cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        } else if (type.equals("clam")) {
            pizza = new ClamPizza();
        } else if (type.equals("veggie")) {
            pizza = new VeggiePizza();
        }
        return pizza;
    }
}

• 客户类PizzaStore

package cn.edu.nwpu.simpleFactory;
/**
 * 
 * @author yylin
 *
 */
public class PizzaStore {

    private SimplePizzaFactory factory = null;
    
    PizzaStore(SimplePizzaFactory factory) {
        this.factory = factory;
    }
    // 处理披萨订单的方法
    public Pizza orderPizza(String type) {
        Pizza pizza = null;
        
        pizza = factory.creatPizza(type);
        
        pizza.prepare(); // 准备
        pizza.bake(); // 烘烤
        pizza.cut(); // 切片
        pizza.box(); //装盒
        
        return pizza;
    }
}

总结

1. 利用静态方法定义一个简单工厂，称为静态工厂，静态工厂不需要使用创建对象的方法来实例化对象，但是不能通过继承来改变创建对象的区别。

2. 简单工厂的优点：实现对象的创建和对象的使用分离，将对象的创建交给专门的工厂类负责。

3. 简单工厂的缺点：工厂类不够灵活，增加新的具体产品需要修改工厂类的判断逻辑代码，而且产品较多时，工厂方法代码将会非常复杂。

4. 在简单工厂模式中，可以根据参数的不同返回不同类的实例。简单工厂模式专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

5. 简单工厂模式包含三个角色：
   （1）工厂角色：负责实现创建所有实例的内部逻辑；
   （2）抽象产品角色：是所创建的所有对象的父类，负责描述所有实例所共有的公共接口；
   （3）具体产品角色：是创建目标，所有创建的对象都充当这个角色的某个具体类的实例。

6. 简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无须知道其创建细节。

7. 简单工厂模式适用情况包括：
   （1）工厂类负责创建的对象比较少；
   （2）客户端只知道传入工厂类的参数，对于如何创建对象不关心。

参考：Head First设计模式