工厂模式

工厂模式(Factory Pattern)就是专门负责将大量有共同接口的类实例化,而且不必事先知道每次是要实例化哪一个类的模式。它定义一个用于创建对象的接口,由子类决定实例化哪一个类。工厂模式相当于创建实例对象的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()方法。

常规写法:

建立英雄类:

1
2
3
4
5
6
public abstract class Hero {
protected String name;

public abstract void say();

}

寒冰射手-艾希类(继承Hero类):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Ashe extends Hero {

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

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

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

1
2
3
4
5
6
7
public enum Who {
Ashe,
Garen,
Yi,
Lux,
Yasuo
}

然后客户端调用:(菜鸟写法)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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;
}
}

}

艾希

客户端调用:(好学生写法,父类的子类引用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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的过程。那就看看工厂方法怎么去实现吧。

工厂模式写法

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

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

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

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

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

然后客户端调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
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):用以封装实例化对象过程,根据传入的参数决定生产不同的产品。
利用简单工厂的写法:

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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;
}

}

客户端代码做简单修改:

1
2
3
4
5
6
7
8
9
10
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