工厂模式

工厂模式就是专门负责将大量有共同接口的类实例化，而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。工厂模式相当于创建实例对象的new，经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的。

UML类图

1. 抽象产品类（AbstractProduct）：类中定义抽象一些方法，在子类中具体实现。
2. 具体产品类（ProductX）：实现基类中的抽象方法（多个不同的具体产品，X=1,2,3..）。
3. 抽象工厂类或接口（AbstractFactory）：定义具体工厂的公共接口。
4. 具体工厂类（FactoryX）：定义创建对应具体产品实例的方法。（每个工厂对应一种具体产品，X=1,2,3...）。

案例分析

既然是工厂，当然是要生产产品。那我们来造什么好呢？，，嗯，，，造小孩？NO，NO，NO！我们还是来造英雄吧。

场景：玩《英雄联盟》（5v5 moba端游）新开一局游戏，游戏开始每个玩家需要选一个信赖的英雄。选好后，英雄会很兴奋，说一句专属的台词。那么程序上是new出该英雄的对象，执行该对象的say()方法。

常规写法：

建立英雄类：

public abstract class Hero {
    protected String name;

    public abstract void say();

}

寒冰射手-艾希类（继承Hero类）：

public class Ashe extends Hero {

    // 简化构造方法，只弄个名字。
    public Ashe() {
        this.name = "寒冰射手-艾希";
    }

    // 艾希台词
    // 艾希台词
    @Override
    public void say() {
        System.out.println(name + "：" + "世间万物皆系于一箭之上。");
    }
}

类似的写了亚索类，光辉类，盖伦类，剑圣类（全部英雄的话，还有好多）。再写个枚举（可以不需要，仅仅拿来当对应标识使用）。

public enum Who {
    Ashe,
    Garen,
    Yi,
    Lux,
    Yasuo
}

然后客户端调用：（菜鸟写法）

import java.util.Scanner;

public class Client1 {

    public static void main(String[] args) {
        Scanner can = new Scanner(System.in);
        String name = can.next();
        can.close();
        switch (Who.valueOf(name)) {
        case Ashe:
            // 艾希
            Ashe ashe = new Ashe();
            ashe.say();
            break;
        case Yasuo:
            // 亚索
            Yasuo yasuo = new Yasuo();
            yasuo.say();
            break;
        case Garen:
            // 德玛
            Garen garen = new Garen();
            garen.say();
            break;
        case Lux:
            // 光辉
            Lux lux = new Lux();
            lux.say();
            break;
        case Yi:
            // 剑圣
            Yi yi = new Yi();
            yi.say();
            break;
        }
    }

}

客户端调用：（好学生写法，父类的子类引用）

public class Client2 {

    public static void main(String[] args) {
        Scanner can = new Scanner(System.in);
        String name = can.next();
        can.close();
        Hero hero = null;
        switch (Who.valueOf(name)) {
        case Ashe:
            // 艾希
            hero = new Ashe();
            break;
        case Yasuo:
            // 亚索
            hero = new Yasuo();
            break;
        case Garen:
            // 德玛
            hero = new Garen();
            break;
        case Lux:
            // 光辉
            hero = new Lux();
            break;
        case Yi:
            // 剑圣
            hero = new Yi();
            break;
        }
        hero.say();
    }

}

这里客户端需要知道：

• 英雄怎么构造，怎么new出来。（事实上英雄的构造远没有这么简单。）
• 每个英雄的方法怎么调用。（这里都是say()方法）

我们前面提到，利用工厂可以把创建对象的过程封装掉，客户端只要知道得到对象后调用其方法即可。用工厂代替new的过程。那就看看工厂方法怎么去实现吧。

工厂模式写法

先建立一个工厂类的接口：

public interface Factory {
    //创建英雄的接口
    public abstract Hero create();
}

然后建立不同英雄对应的工厂实现类。比如艾希工厂：

public class AsheFactory implements Factory {
    //实现具体的创建英雄的方法。
    public Hero create() {
        return new Ashe();
    }
}

同样的建立亚索工厂，光辉工厂，盖伦工厂，剑圣工厂等。

然后客户端调用：

public class Client3 {

    public static void main(String[] args) {
        Scanner can = new Scanner(System.in);
        String name = can.next();
        can.close();
        Factory factory = null;
        switch (Who.valueOf(name)) {
        case Ashe:
            // 艾希工厂
            factory = new AsheFactory();
            break;
        case Yasuo:
            // 亚索工厂
            factory = new YasuoFactory();
            break;
        case Garen:
            // 德玛工厂
            factory = new GarenFactory();
            break;
        case Lux:
            // 光辉工厂
            factory = new LuxFactory();
            break;
        case Yi:
            // 剑圣工厂
            factory = new YiFactory();
            break;
        }
        Hero hero = factory.create();
        hero.say();
    }

}

switch中不再是英雄的创建过程，而是选择英雄工厂的过程。根据不同name选择不同的工厂，然后由工厂去实例化具体英雄对象。

新增一个英雄，就新增一个对应的工厂。需要修改的只有客户端代码。

如果不需要新增也不需要减少。我们是不是可以把工厂的选择封装起来。让多家工厂合并成一家工厂。那就是接下来要讲的简单工厂模式

---

简单工厂模式

简单工厂模式（Simple Factory Pattern）是类的创建模式，又叫做静态工厂方法模式。就是由一个工厂类根据传入的参量决定创建出哪一种产品类的实例。与上面工厂模式的区别就是它只需要一个工厂。

UML类图

1. 抽象产品类（AbstractProduct）：类中定义抽象一些方法，在子类中具体实现。
2. 具体产品类（ConcreteProduct）：实现基类中的抽象方法。
3. 工厂类（Factory）：用以封装实例化对象过程，根据传入的参数决定生产不同的产品。

利用简单工厂的写法：

其他地方不变，将工厂合并成一个工厂类，并在内部写个静态方法，根据传入的参数决定创建不同的英雄对象：

public class SimpleFactory {

    public static Hero create(String name) {
        Hero hero = null;
        switch (Who.valueOf(name)) {
        case Ashe:
            // 艾希
            hero = new Ashe();
            break;
        case Yasuo:
            // 亚索
            hero = new Yasuo();
            break;
        case Garen:
            // 德玛
            hero = new Garen();
            break;
        case Lux:
            // 光辉
            hero = new Lux();
            break;
        case Yi:
            // 剑圣
            hero= new Yi();
            break;
        }

        return hero;
    }

}

客户端代码做简单修改：

public class Client4 {
    public static void main(String[] args) {
        Scanner can = new Scanner(System.in);
        String name = can.next();
        can.close();
        // 根据传入的名字构建不同的英雄。
        Hero hero = SimpleFactory.create(name);
        hero.say();
    }
}

客户端不需要知道对象的构建过程，只要传入参数得到不同对象。

但是简单工厂是固定的，如果增减英雄他就要修改。不符合开闭原则。这时候用前面工厂模式好，把修改转移给客户端，而不修改工厂代码。

运行结果

选个盖伦试试：

不浪了，不浪了。

---

抽象工厂模式

请看下篇【设计模式】抽象工厂模式。

附件

设计模式Demo
GitHub源码：https://github.com/wzmyyj/Design-Pattern