设计模式-工厂模式

概述：

---

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。(用工厂方法代替new操作的一种模式)

适用性：

---

• 当一个类不知道它所必须创建的对象的类的时候。
• 当一个类希望由它的子类来指定它所创建的对象的时候。
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

工厂模式分类：

---

工厂模式在《Java与模式》中分为三类：

1. 简单工厂模式（Simple Factory）：不利于产生系列产品.
2. 工厂方法模式（Factory Method）：又称为多形性工厂.
3. 抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品.

这三种模式从上到下逐步抽象，并且更具一般性。
GOF在《设计模式》一书中将工厂模式分为两类：工厂方法模式（Factory Method）与抽象工厂模式（Abstract Factory）。将简单工厂模式（Simple Factory）看为工厂方法模式的一种特例，两者归为一类。

简单工厂模式：

---

简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
在简单工厂模式中,一个工厂类处于对产品类实例化调用的中心位置上,它决定哪一个产品类应当被实例化。

先来看看它的组成：

1. 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑。在java中它往往由一个具体类实现。
2. 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。在java中由接口或者抽象类来实现。
3. 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

简单工厂模式例子：

---

以动物为例子实现：动物有很多，如猫，狗，猴子，海豚等动物

抽象产品类：

package com.mode.factory;

/**
 * 动物接口(动物实体类，实现该接口)
 */
public interface IAnimal {

    // == 动物标识 ==
    /**
     * 猫
     */
    public static final int F_CAT = 1;

    /**
     * 狗
     */
    public static final int F_DOG = 2;

    /**
     * 海豚
     */
    public static final int F_DOLPHIN = 3;

    /**
     * 猴子
     */
    public static final int F_MEONKEY = 4;

    /**
     * 动物名
     */
    void name();
}

具体产品类：

/**
 * 猫实体类
 */
public class CatVo implements IAnimal {

    @Override
    public void name() {
        System.out.println("猫");
    }
}

/**
 * 海豚实体类
 */
public class DolphinVo implements IAnimal {

    @Override
    public void name() {
        System.out.println("海豚");
    }
}

// DogVo...MonkeyVo...

工厂类：

/**
 * 简单工厂
 */
public class SimpleFactory {

    /**
     * 创建动物
     * @param id 传入ID标识
     * @return 返回具体对象
     */
    public IAnimal createAnimal(int id) {
        switch (id) {
        case IAnimal.F_CAT:
            return new CatVo();
        case IAnimal.F_DOG:
            return new DogVo();
        case IAnimal.F_DOLPHIN:
            return new DolphinVo();
        case IAnimal.F_MEONKEY:
            return new MonkeyVo();
        }
        return null;
    }
}

调用：

public class MainMethod {

    public static void main(String[] args) {
        simpleFactoryMain();
    }

    public static void simpleFactoryMain() {
        // 初始化简单工厂类
        SimpleFactory sFactory = new SimpleFactory();
        // 创建动物
        IAnimal animal = sFactory.createAnimal(IAnimal.F_DOLPHIN);
        // 获取创建的动物名
        animal.name();
    }
}

---

工厂方法模式：

---

工厂方法模式是简单工厂模式的进一步抽象化和推广，工厂方法模式里不再只由一个工厂类决定那一个产品类应当被实例化,这个决定被交给抽象工厂的子类去做。

来看下它的组成：

1. 抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2. 具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3. 抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4. 具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活 起来——当有新的产品（即暴发户的汽车）产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代 码。可以看出工厂角色的结构也是符合开闭原则的！

工厂方法模式例子：

---

以动物为例子实现：动物有很多，如猫，狗，猴子，海豚等动物

抽象产品角色类：

package com.mode.factory;

/**
 * 动物接口(动物实体类，实现该接口)
 */
public interface IAnimal {

    // 如上

    /**
     * 动物名
     */
    void name();
}

具体产品角色类：

/**
 * 猫实体类
 */
public class CatVo implements IAnimal {

    @Override
    public void name() {
        System.out.println("猫");
    }
}

// DolphinVo...DogVo...MonkeyVo...

抽象工厂类：

/**
 * 动物工厂抽象类
 */
public abstract class AnimalFactory {
    abstract IAnimal create();
}

具体工厂类：

/**
 * 猴子工厂类
 */
public class MonkeyFactory extends AnimalFactory {

    @Override
    public IAnimal create() {
        return new MonkeyVo();
    }

}
//....

调用：

public class MainMethod {

    public static void main(String[] args) {
        factoryMethodMain();
    }

    /**
     * 工厂方法调用
     */
    public static void factoryMethodMain() {
        // 初始化简单工厂类
        AnimalFactory aFactory = new MonkeyFactory();
        // 创建动物
        IAnimal animal = aFactory.create();
        // 获取创建的动物名
        animal.name();
    }
}

可以看出工厂方法的加入，使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。因为如果不能避免这种情况，可以考虑使用简单工厂模式与工厂方法模式相结合的方式来减少工厂类：即对于产品树上类似的种类（一般是树的叶子中互为兄弟的）使用简单工厂模式来实现。

简单工厂和工厂方法模式的比较

---

工厂方法模式和简单工厂模式在定义上的不同是很明显的。

工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。

反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

抽象工厂模式：

---

以动物为例子实现：动物有很多，如猫，狗，猴子，海豚等动物

抽象产品角色类：

package com.mode.factory;

/**
 * 动物接口(动物实体类，实现该接口)
 */
public interface IAnimal {

    // 如上

    /**
     * 动物名
     */
    void name();
}

具体产品角色类：

/**
 * 猫实体类
 */
public class CatVo implements IAnimal {

    @Override
    public void name() {
        System.out.println("猫");
    }
}

// DolphinVo...DogVo...MonkeyVo...

抽象工厂类：

/**
 * 动物抽象工厂类
 */
public abstract class AnimalAbstractFactory {
    public abstract CatVo createCat();

    public abstract DogVo createDog();

    public abstract DolphinVo createDolphin();

    public abstract MonkeyVo createMonkey();

}

具体工厂类：

/**
 * 默认工厂(用于创建具体产品)
 */
public class DefaultFactory extends AnimalAbstractFactory {

    @Override
    public CatVo createCat() {
        return new CatVo();
    }

    @Override
    public DogVo createDog() {
        return new DogVo();
    }

    @Override
    public DolphinVo createDolphin() {
        return new DolphinVo();
    }

    @Override
    public MonkeyVo createMonkey() {
        return new MonkeyVo();
    }

}

调用：

public class MainMethod {

    public static void main(String[] args) {
        abstractFactoryMain();
    }

    /**
     * 抽象工厂调用
     */
    public static void abstractFactoryMain() {
        AnimalAbstractFactory aFactory = new DefaultFactory();
        // 创建动物-狗
        DogVo dogVo = aFactory.createDog();
        dogVo.name();
        // 创建动物-猫
        CatVo catVo = aFactory.createCat();
        catVo.name();
    }
}

总结：

---

1. 简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
2. 工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
3. 抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

代码下载

---

工厂模式FactoryMode - 17KB

---

参考：
- 工厂模式(百度百科)
- 《Head First 设计模式》 读书笔记04 工厂模式（一）
- 《Head First设计模式》 读书笔记05 工厂模式（二）
- 23种设计模式（3）：抽象工厂模式
- 23种设计模式（2）：工厂方法模式

---