设计模式之—-工厂模式
工厂模式（Factory Pattern）是java中最常用的设计模式之一，这种类型设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象是不会对客户暴露创建逻辑，并且是通过使用一个共同的接口，以此来达到解耦的目的。
下面的例子以造车为例来说明三种模式。
分类
1、简单工厂模式 (Simple 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| public abstract class Car {
}
public enum CarType {
BMW, AUDI, DAZHONG;
}
public class BmwCar extends Car{
public BmwCar(){
System.out.println("这是宝马车");
}
}
public class AudiCar extends Car{
public AudiCar(){
System.out.println("这是奥迪车");
}
}
public class DaZhongCar extends Car {
public DaZhongCar() {
System.out.println("这是大众车");
}
}
public class CarFactory {
public static Car createCar(CarType carType) {
switch (carType) {
case BMW:
return new BmwCar();
case AUDI:
return new AudiCar();
case DAZHONG:
return new DaZhongCar();
default:
return null;
}
}
public static void main(String[] args) {
CarFactory.createCar(CarType.AUDI);
}
}
|
输出：
1
2
3
| 这是奥迪车
Process finished with exit code 0
|
这种工厂模式，已经完成了我们工厂模式的基本的需求，创建对象和解耦
缺点：
1、用户调用需要知道自己要创建的对象在工厂中的类型
2、拓展很麻烦，如果新增一个产品，需要在产品的具体创建对象的实现，还需使工厂支持创建这种产品，这显然是违背开闭原则的
2、工厂方法模式（Factory Method）
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 interface Factory {
Car createCar();
}
public class AudiFactory implements Factory{
@Override
public Car createCar() {
return new AudiCar();
}
}
public class BmwFactory implements Factory{
@Override
public Car createCar() {
return new BmwCar();
}
}
public class DaZhongFactory implements Factory{
@Override
public Car createCar() {
return new DaZhongCar();
}
}
public class ConsumerTest {
public static void main(String[] args) {
final BmwFactory bmwFactory = new BmwFactory();
bmwFactory.createCar();
}
}
|
输出：
1
2
3
| 这是宝马车
Process finished with exit code 0
|
工厂方法模式组成：
1)抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。
方法工厂模式和简单工厂模式最大的不同，就是将实现交给了具体的工厂，核心工厂只提供产品线，具体的实现工厂只需要去实现对应的需求即可。如果新增产，只需要去实现对应的产品工厂即可，显然这种方式是符合开闭原则的
3、抽象工厂模式 (Abstract 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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| public interface Factory {
Car createCar();
double pricing();
}
public class AudiFactory implements Factory {
@Override
public Car createCar() {
return new AudiCar();
}
@Override
public double pricing() {
System.out.println("定价：20_0000");
return 20_0000;
}
}
public class BmwFactory implements Factory {
@Override
public Car createCar() {
return new BmwCar();
}
@Override
public double pricing() {
System.out.println("定价：25_0000");
return 25_0000;
}
}
public class DaZhongFactory implements Factory {
@Override
public Car createCar() {
return new DaZhongCar();
}
@Override
public double pricing() {
System.out.println("定价：18_0000");
return 18_0000;
}
}
public class ConsumerTest {
public static void main(String[] args) {
final BmwFactory bmwFactory = new BmwFactory();
bmwFactory.createCar();
bmwFactory.pricing();
}
}
|
总结：
无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。
