文章目录
  1. 1. 简单工厂的概念
  2. 2. 简单工厂示例

  工厂模式共分为三类,简单工厂(Simple Factory)、工厂方法模式(Factory Method Pattern)和抽象工厂模式(Abstract Factory Pattern)。本文介绍第一种,简单工厂。
  简单工厂严格来说不是一个设计模式,反而像是一种编程习惯,但它是工厂方法模式和抽象工厂模式的基础,因此非常重要。

简单工厂的概念

  简单工厂的类图如下:

  简单工厂由以下几个类组成:

  • 客户端:负责调用简单工厂类创建具体产品类的对象
  • 简单工厂类:简单工厂类是简单工厂的核心,它负责处理创建对象的细节。它能够被客户端调用并创建所需要的产品对象。
  • 抽象产品类:抽象产品类是简单工厂类所创建的所有产品类的父类,它可以是一个接口,也可以是一个抽象类
  • 具体产品类:具体产品类是简单工厂创建的具体产品对象,它们有着共同的父类——抽象产品类。

      简单工厂的核心思想是:使用一个专门的类来负责创建实例的过程。当以后实现改变时,只需要修改这个类即可。
      在实际使用中,需要注意以下几点:

  1. 若具体产品之间没有共同的逻辑,则可以令抽象产品类为一个接口,令具体产品类实现该接口;若具体产品之间有共同的逻辑,则可以令抽象产品类为一个抽象类,封装具体产品类的共同逻辑。
  2. 可以将简单工厂类中创建具体产品的方法定义为静态方法,这是一个很常见的技巧。使用静态方法的优点是在客户端中不需要实例化简单工厂类,缺点是不能通过继承来更改创建具体产品的方法的行为。

简单工厂示例

  假设有这样一个场景:有一个比萨店,需要制作各种类型的比萨,不同的比萨制作过程中有一些步骤是相同的,如:前期准备、烘烤、切片、装盒。但不同的比萨制作使用不同的材料。该案例的类图如下:

  如上图所示,可以将创建比萨的方法createPizza()封装在一个单独类SimplePizzaFactory中,令PizzaStore类来调用SimplePizzaFactory来返回比萨对象。对于比萨对象,可以将各种比萨制作过程中的相同步骤封装在抽象类Pizza中,并将不同比萨特有的原料封装在各个子类中。
  该案例的代码如下:

  • 客户端类
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
package cn.edu.whu;
/**
* 客户端类
* Created by wuwenan on 02/06/2017.
*/
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;
}
}
  • 简单工厂类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package cn.edu.whu;
/**
* 简单工厂类
* Created by wuwenan on 02/06/2017.
*/
public class SimplePizzaFactory {
public Pizza createPizza(String type) {
Pizza pizza = null;
if (type.equals("cheese")) {
pizza = new CheesePizza();
} else if (type.equals("veggie")) {
pizza = new VeggiePizza();
} else if (type.equals("clam")) {
pizza = new ClamPizza();
} else if (type.equals("pepperoni")) {
pizza = new PepperoniPizza();
}
return pizza;
}
}
  • 抽象产品类
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
39
40
package cn.edu.whu;
import java.util.ArrayList;
/**
* 抽象产品类
* Created by wuwenan on 02/06/2017.
*/
public abstract class Pizza {
String name; //比萨名
String dough; //使用的面团
String sauce; //使用的酱料
ArrayList toppings = new ArrayList(); //使用的佐料
void prepare() {
System.out.println("Preparing " + name);
System.out.println("Tossing dough...");
System.out.println("Adding sauce...");
System.out.println("Adding toppings: ");
for (int i=0;i<toppings.size();i++) {
System.out.println(" " + toppings.get(i));
}
}
void bake() {
System.out.println("Baking...");
}
void cut() {
System.out.println("Cutting the pizza...");
}
void box() {
System.out.println("Placing the pizza in box...");
}
public String getName() {
return name;
}
}
  • 具体产品类
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
39
40
41
42
43
44
45
46
47
48
49
package cn.edu.whu;
/**
* 具体产品类
* Created by wuwenan on 02/06/2017.
*/
public class CheesePizza extends Pizza{
public CheesePizza() {
name = "Cheese Pizza";
dough = "Cheese Pizza dough";
sauce = "Cheese Pizza sauce";
toppings.add("Cheese Pizza topping1");
toppings.add("Cheese Pizza topping2");
}
}
public class VeggiePizza extends Pizza {
public VeggiePizza() {
name = "Veggie Pizza";
dough = "Veggie Pizza dough";
sauce = "Veggie Pizza sauce";
toppings.add("Veggie Pizza topping1");
toppings.add("Veggie Pizza topping2");
}
}
public class ClamPizza extends Pizza {
public ClamPizza() {
name = "Clam Pizza";
dough = "Clam Pizza dough";
sauce = "Clam Pizza sauce";
toppings.add("Clam Pizza topping1");
toppings.add("Clam Pizza topping2");
}
}
public class PepperoniPizza extends Pizza {
public PepperoniPizza() {
name = "Pepperoni Pizza";
dough = "Pepperoni Pizza dough";
sauce = "Pepperoni Pizza sauce";
toppings.add("Pepperoni Pizza topping1");
toppings.add("Pepperoni Pizza topping2");
}
}
  • 测试类,这里仅用创建CheesePizza类型的比萨来测试:
1
2
3
4
5
6
7
8
9
public class PizzaTest {
public static void main(String[] args) {
SimplePizzaFactory simpleFactory = new SimplePizzaFactory();
PizzaStore pizzaStore = new PizzaStore(simpleFactory);
String pizzaType = "cheese";
System.out.println("要创建的pizza类型是:" + pizzaType);
pizzaStore.orderPizza(pizzaType);
}
}
  • 运行结果:
1
2
3
4
5
6
7
8
9
10
要创建的pizza类型是:cheese
Preparing Cheese Pizza
Tossing dough...
Adding sauce...
Adding toppings:
Cheese Pizza topping1
Cheese Pizza topping2
Baking...
Cutting the pizza...
Placing the pizza in box...

  若将简单工厂类中的工厂方法修改为静态方法,则可以将SimplePizzaFactory类中的createPizza()方法改写为:

1
2
3
public static Pizza createPizza(String type){
//具体的创建步骤...
};

然后将客户端的PizzaStore方法改写为:

1
2
3
4
5
6
7
8
9
10
11
12
13
public class PizzaStore {
public Pizza orderPizza(String type) {
Pizza pizza;
pizza = SimplePizzaFactory.createPizza(type);
pizza.prepare();
pizza.bake();
pizza.cut();
pizza.box();
return pizza;
}
}

同样可以得到测试的结果。
PS:以上代码已上传至我的Github,地址是:https://github.com/Wanz2/DesignPatterns

文章目录
  1. 1. 简单工厂的概念
  2. 2. 简单工厂示例