每天一个设计模式（4）：简单工厂“模式”

4.简单工厂“模式”

一.简单工厂介绍

1.1 简单工厂定义

　　简单工厂模式（Simple Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。实际上简单工厂并不是一种设计模式，反而比较像一种编程习惯，可以将客户程序从具体类解耦。

1.2 适用场景

　　简单工厂实例化的类具有相同的接口或者基类，在子类比较固定并不需要扩展时，可以使用简单工厂。如数据库生产工厂就是简单工厂的一个应用。

　　简单工厂需要知道所有要生成的类型，当子类过多或者子类层次过多时不适合使用。

1.3 优缺点

　　采用简单工厂的优点是可以使用户根据参数获得对应的类实例，避免了直接实例化类，降低了耦合性

　　缺点是可实例化的类型在编译期间已经被确定，如果增加新类型，则需要修改工厂，不符合OCP（开闭原则）的原则。

二.UML关系图

由上图我们可以看到简单工厂模式由三部分组成：

• 简单工厂角色（Creator）：这是简单工厂模式的核心，由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用，创建所需要的产品对象。
• 抽象产品角色（Product）：简单工厂模式所创建的所有对象的父类，注意，这里的父类可以是接口也可以是抽象类，它负责描述所有实例所共有的公共接口。
• 具体产品角色（Concrete Product）：简单工厂所创建的具体实例对象，这些具体的产品往往都拥有共同的父类。

三.简单工厂例子

本人认为下面这个女娲造人的例子是说明简单工厂“模式”最经典的例子，通过该例子可以清晰的认识到简单工厂。

3.1 女娲造人

话说：“天地开辟，未有人民，女娲抟土为人。”女娲需要用土造出一个个的人，但在女娲造出人之前，人的概念只存在于女娲的思想里面。

首先，在这个造人的思想里面，有几个重要的角色：女娲本身、抽象的人的概念和女娲所造出的一个个具体的人。

1. 女娲是一个工厂类，也就是简单工厂模式的核心角色。
2. 抽象的人是最早只存在于女娲的头脑里的一个想法，女娲按照这个想法造出的一个个具体的人，便都符合这个抽象的人的定义。换言之，这个抽象的想法规定了所有具体的人必须都有的接口（特征或者功能）。
3. 具休的一个个的人，包括张三，李四等。这些人便是简单工厂模式里面的具体产品角色

 其UML类图出下所示：

其中女娲对应的就是简单工厂角色，女娲脑里的想法对应的就是抽象产品角色，创造出出来的具休的人对应的就是具体产品角色。

示例代码：

//定义女娲脑里对人的抽象概念的接口
interface People{
    public void eat();
    public void sleep();
    public void talk();
}

//创造具体人类的具体实现类
class Zhangsan implements People{
    public void eat(){
        System.out.println("Zhangsan can eat。。。。。");
    }
    public void sleep(){
        System.out.println("Zhangsan can sleep。。。。。");
    }
    public void talk(){
        System.out.println("Zhangsan can talk。。。。。");
    }
}

class Lisi implements People{
    public void eat(){
        System.out.println("Lisi can eat。。。。。");
    }
    public void sleep(){
        System.out.println("Lisi can sleep。。。。。");
    }
    public void talk(){
        System.out.println("Lisi can talk。。。。。");
    }
}

//女娲简单工厂
class Nvwa{
    public static People getPeopleInstance(String type){
        People p=null;
        if("Zhangsan".equals(type)){
            p=new Zhangsan();
        }
        if("Lisi".equals(type)){
            p=new Lisi();
        }
        return p;
    }
}

public class FactoryDemo {
    public static void main(String[] args) {
        People p=Nvwa.getPeopleInstance("Zhangsan");
        if(p!=null){
            p.eat();
            p.sleep();
            p.talk();
        }else{
            System.out.println("造不了这种人。。。");
        }
    }
}

3.2 生产披萨

UML类图：

示例代码：

简单工厂实现披萨店

public class SimplePizzaFactory
{
    public Pizza createPizza(String type)
    {
        Pizza pizza = null;        
        if(type.equals("cheese"))
        {
            pizza = new CheesePizza();
        }
        else if(type.equals("greel"))
        {
            pizza = new GreekPizza();
        }
        else if(type.equals("pepperoni"))
        {
            pizza = new PepperoniPizza();
        }
        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.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
}

四.总结

总结一下：简单工厂模式分离产品的创建者和消费者，有利于软件系统结构的优化；但是由于一切逻辑都集中在一个工厂类中，导致了没有很高的内聚性，同时也违背了“开放封闭原则”。另外，简单工厂模式的方法一般都是静态的，而静态工厂方法是无法让子类继承的，因此，简单工厂模式无法形成基于基类的继承树结构。

参考：《Head First设计模式》

http://blog.csdn.net/weiwenlongll/article/details/6918164

http://www.blogjava.net/jzgl-ever/archive/2008/07/26/217704.html