java设计模式之工厂方法模式以及简单工厂模式还有抽象工厂模式

提到工厂模式，有必要先说明下，工厂模式其实包含了三种模式：简单工厂模式、工厂方法模式和抽象工厂模式

一 、工厂方法(Factory Method)模式

　　工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。

　　二、 工厂方法模式角色与结构

　　抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。

　　具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。在上图中有两个这样的角色：BulbCreator与TubeCreator。

　　抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。在上图中，这个角色是Light。

　　具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

　　


三：一个简单实例

1
// 产品 Plant接口

2

3
　　public
interface Plant { }

4

5
　　//具体产品PlantA，PlantB

6

7
　　public
class PlantA
implements Plant {

8

9
　　public PlantA () {

10

11
　　System.out.println("create PlantA !");

12

13
　　}

14

15
　　public
void doSomething() {

16

17
　　System.out.println(" PlantA do something ...");

18

19
　　}

20

21
　　}

22

23
　　public
class PlantB
implements Plant {

24

25
　　public PlantB () {

26

27
　　System.out.println("create PlantB !");

28

29
　　}

30

31
　　public
void doSomething() {

32

33
　　System.out.println(" PlantB do something ...");

34

35
　　}

36

37
　　}

38

39
　　// 产品 Fruit接口

40

41
　　public
interface Fruit { }

42

43
　　//具体产品FruitA，FruitB

44

45
　　public
class FruitA
implements Fruit {

46

47
　　public FruitA() {

48

49
　　System.out.println("create FruitA !");

50

51
　　}

52

53
　　public
void doSomething() {

54

55
　　System.out.println(" FruitA do something ...");

56

57
　　}

58

59
　　}

60

61
　　public
class FruitB
implements Fruit {

62

63
　　public FruitB() {

64

65
　　System.out.println("create FruitB !");

66

67
　　}

68

69
　　public
void doSomething() {

70

71
　　System.out.println(" FruitB do something ...");

72

73
　　}

74

75
　　}

76

77
　　// 抽象工厂方法

78

79
　　public
interface AbstractFactory {

80

81
　　public Plant createPlant();

82

83
　　public Fruit createFruit() ;

84

85
　　}

86

87
　　//具体工厂方法

88

89
　　public
class FactoryA
implements AbstractFactory {

90

91
　　public Plant createPlant() {

92

93
　　return
new PlantA();

94

95
　　}

96

97
　　public Fruit createFruit() {

98

99
　　return
new FruitA();

100

101
　　}

102

103
　　}

104

105
　　public
class FactoryB
implements AbstractFactory {

106

107
　　public Plant createPlant() {

108

109
　　return
new PlantB();

110

111
　　}

112

113
　　public Fruit createFruit() {

114

115
　　return
new FruitB();

116

117
　　}

118

119
　　}

120

121

　四、工厂方法模式与简单工厂模式

　　工厂方法模式与简单工厂模式再结构上的不同不是很明显。工厂方法类的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。

　　工厂方法模式之所以有一个别名叫多态性工厂模式是因为具体工厂类都有共同的接口，或者有共同的抽象父类。

　　当系统扩展需要添加新的产品对象时，仅仅需要添加一个具体对象以及一个具体工厂对象，原有工厂对象不需要进行任何修改，也不需要修改客户端，很好的符合了"开放-封闭"原则。而简单工厂模式在添加新产品对象后不得不修改工厂方法，扩展性不好。

　　工厂方法模式退化后可以演变成简单工厂模式。

二：

简单工厂模式
意图
一个工厂类根据传入的参量，动态决定应该创建出哪一个产品类的实例。
简单工厂模式是属于创建型模式，又叫做静态工厂方法（Static Factory Method）模式。
模式结构及参与者



Factory：工厂角色

接受客户端的请求，通过请求负责创建相应的产品对象。
AbstractProduct：抽象产品角色

工厂模式所创建对象的父类或是共同拥有的接口。可以是抽象类或接口。
ConcreteProduct：具体产品角色

工厂模式所创建的对象都是这个角色的实例。

实例

[java]

public void pay(String type){

if(type.equalsIgnoreCase("cash")){

//现金支付处理代码

}else if(type.equalsIgnoreCase("creditcard")){

//信用卡支付处理代码

}

else if(type.equalsIgnoreCase("voucher")){

//代金券支付处理代码

}else{

……

}

}

那么上述代码，我们可以看出，此段代码带有很多的判断逻辑，较为复杂，难以维护。下面对上述代码进行重构。
[java]

public abstract class AbstractPay{

public abstract void pay();

}

[java] view plaincopy

public class CashPay extends AbstractPay{

public void pay(){

//现金支付处理代码

}

}

[java]

public class PayMethodFactory{

public static AbstractPay getPayMethod(String type){

if(type.equalsIgnoreCase("cash")){

return new CashPay(); //根据参数创建具体产品

}

else if(type.equalsIgnoreCase("creditcard")){

return new CreditcardPay(); //根据参数创建具体产品

}

……

}

}

效果

简单工厂模式的要点在于：当你需要什么，只需要传入一个正确的参数，就可以获取你所需要的对象，而无需知道其创建细节。
优点

1）将对象的创建和对象本身业务处理分离，可以降低系统的耦合度，使得两者修改起来都相对容易。

2）由于工厂方法是静态方法，使用起来很方便，可通过类名直接调用，而且只需要传入一个简单的参数即可。

缺点

简单工厂模式最大的问题在于工厂类的职责相对过重，增加新的产品需要修改工厂类的判断逻辑，这一点与开闭原则是相违背的。

模式应用场景

在JDK类库中广泛使用了简单工厂模式，如工具类java.text.DateFormat，它用于格式化一个本地日期或者时间。

[java]

public final static DateFormat getDateInstance();

public final static DateFormat getDateInstance(int style);

public final static DateFormat getDateInstance(int style,Locale locale);

模式扩展

简单工厂模式的简化：在有些情况下，一个抽象产品类同时也是子类的工厂，也就是说把静态工厂方法写到抽象产品类中。



三：抽象工厂模式

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的，抽象工厂模式可以向客户端提供一个接口，使得客户端在不必置顶产品的具体类型的情况下能够创建多个产品族的产品对象。

1.抽象工厂模式中的角色和职责

。抽象工厂角色（Creator）

抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口

。 具体工厂角色(Concrete Creator)

具体工厂类是抽象工厂类的一个实现，负责实例化某个产品族的产品对象

。抽象角色（product）

抽象模式所创建的所有对象的父类，它描述所有实例所共有的公共接口

。 具体产品角色（Concfrete Product）

抽象模式岁创建的具体实例对象

抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品具体类型的情况下，创建多个产品族中的产品对象。这就是抽象工厂模式的用意。

每个模式都是针对一定问题的解决方案。抽象工厂模式面对的问题是多产品等级结构的系统设计。

在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。

产品族：是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如AMD的CPU和ADM芯片的主板，组成一个家族。Intel的CPU和Intel芯片的主板，又组成一个家族。而这两个家族都来自于两个产品等级：CPU，主板。一个等级结构是由相同的结构的产品组成，示意图如下：



理解这个产品结构是理解抽象工厂模式的关键所在，所以我不惜花费时间来画此图。如果领悟不到此图的含义，就无法区分工厂方法模式和抽象工厂模式的区别。

从上图可以看出，抽象工厂模式的每个工厂创造出来的都是一族产品，而不是一个或者一组。组是可以随意组合的！其实两个就这点点差别，呵呵，估计现在你已经差不多明白了抽象工厂模式的含义。不废话了，看个例子，真相将大白于天下！

1.3.1 抽象工厂模式在农场中的实现

1.3.1.1 背景

聪明的农场主总是让自己的庄园越来越有价值，“农场”在经历了简单工厂模式和工厂模式后，不断的扩大生产。如今，再次面临新的大发展，一项重要的工作就是引进塑料大棚技术，在大棚里种植热带（Tropical）和亚热带（Northern）的水果和蔬菜，用以满足市场需求，获取更大的利益。

1.3.1.2 产品角色图

经过分析，对产品角色进行分析得出下图



经过分析，所谓的各个园丁其实就是工厂角色，而蔬菜和水果则是产品角色。将抽象工厂模式用于农场中，系统设计图如下：



1.3.1.4.1 抽象工厂：Gardener.java
package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:Gardener.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:55:23

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 抽象工厂角色：工厂接口

*/

public interface Gardener {
public Fruit createFruit(String name);
1.3.1.4.2 抽象水果产品：Fruit.java
package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:Fruit.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:54:15

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 抽象产品角色：水果接口

*/

public interface Fruit {

}
1.3.1.4.3 抽象蔬菜产品：Veggie.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:Veggie.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:56:22

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 抽象产品角色：蔬菜接口

*/

public interface Veggie {

}
1.3.1.4.4 热带水果：TropicalFruit.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:TropicalFruit.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:57:08

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 具体产品角色：热带水果

*/

public class TropicalFruit implements Fruit {

private String name;
}
1.3.1.4.5 热带蔬菜：TropicalVeggie.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:TropicalVeggie.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:58:03

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 具体产品角色：热带蔬菜

*/

public class TropicalVeggie implements Veggie {

private String name;
public TropicalVeggie(String name) {

System.out.println("热带工厂为您创建了：热带水果－"+name);

}
}
1.3.1.4.6 亚热带水果：NorthernFruit.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:NorthernFruit.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:58:55

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 具体产品角色：亚热带水果

*/

public class NorthernFruit implements Fruit {

private String name;
public NorthernFruit(String name) {

System.out.println("亚热带工厂为您创建了：亚热带水果－"+name);

}
}

1.3.1.4.7 亚热带蔬菜：NorthernVeggie.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:NorthernVeggie.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 22:59:36

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 具体产品角色：亚热带蔬菜

*/

public class NorthernVeggie implements Veggie {

private String name;
public NorthernVeggie(String name) {

System.out.println("亚热带工厂为您创建了：亚热带蔬菜－"+name);

}
}
1.3.1.4.8 热带工厂：TropicalGardener.java

/**

* Created by IntelliJ IDEA.

* FileName:TropicalGardener.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 23:01:49

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 具体工厂角色：热带工厂

*/

public class TropicalGardener implements Gardener {

public Fruit createFruit(String name) {

return new TropicalFruit(name);

}
public Veggie createVeggie(String name) {

return new TropicalVeggie(name);

}

}
1.3.1.4.9 亚热带工厂：NorthernGardener.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:NorthernGardener.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 23:00:31

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 具体工厂角色：亚热带工厂

*/

public class NorthernGardener implements Gardener {

public Fruit createFruit(String name) {

return new NorthernFruit(name);

}
public Veggie createVeggie(String name) {

return new NorthernVeggie(name);

}

}

1.3.1.4.10 测试类（客户端）：TestApp.java

package com.lavasoft.patterns.abstractfactory.ybms;
/**

* Created by IntelliJ IDEA.

* FileName:TestApp.java

* User: LavaSoft

* Date: 2006-12-5

* Time: 23:03:22

* 《Java与模式》（--阎宏博士著）读书笔记

* 工厂模式--抽象工厂模式--一般性模式（农场应用）

* ReadMe: 测试类（客户端）

*/

public class TestApp {

private void test(){

Veggie tv,nv;

Fruit tf,nf;

TropicalGardener tg=new TropicalGardener();

NorthernGardener ng=new NorthernGardener();
tv=tg.createVeggie("热带菜叶");

nv=ng.createVeggie("东北甜菜");

tf=tg.createFruit("海南椰子");

nf=ng.createFruit("雪梨");

}

public static void main(String args[]){

TestApp test=new TestApp();

test.test();

}

}
1.3.1.4.11 测试运行结果

热带工厂为您创建了：热带水果－热带菜叶

亚热带工厂为您创建了：亚热带蔬菜－东北甜菜

热带工厂为您创建了：热带水果－海南椰子

亚热带工厂为您创建了：亚热带水果－雪梨
Process finished with exit code 0

看完设计图和源码，原理已经很清楚了，这个模式应用很灵活，猴交给你了，看你怎么玩它！哈哈哈哈。。。。

1.3.1.5 女娲举绳造万物

女娲举绳造物的故事很适合在这里举例子，女娲的绳子按照阴阳划分，产品则按人、兽划分。将抽象工厂模式用于女娲造万物的模拟系统设计中。系统设计图如下：