工厂模式
工厂模式就是专门负责将大量有共同接口的类实例化，而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口，由子类决定实例化哪一个类。工厂模式相当于创建实例对象的new，经常要根据类Class生成实例对象，如A a=new A() 工厂模式也是用来创建实例对象的。
UML类图
- 抽象产品类（AbstractProduct）：类中定义抽象一些方法，在子类中具体实现。
- 具体产品类（ProductX）：实现基类中的抽象方法（多个不同的具体产品，X=1,2,3..）。
- 抽象工厂类或接口（AbstractFactory）：定义具体工厂的公共接口。
- 具体工厂类（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类图
- 抽象产品类（AbstractProduct）：类中定义抽象一些方法，在子类中具体实现。
- 具体产品类（ConcreteProduct）：实现基类中的抽象方法。
- 工厂类（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
