JAVA设计模式学习4——简单工厂模式

从这节开始学习设计模式，首先学习创建模式，其中工厂模式是创建模式里面最常见也常用的一种，工厂模式又分简单工厂模式(Simple Factory)，工厂方法模式(Factory Method)和抽象工厂模式(Abstractor Factory)，这里先学习最简单的也就是简单工厂模式。

简单工厂模式（Simple Factory）也称静态工厂方法模式，是工厂方法模式的特殊实现。简单工厂模式的一般性结构如下图：

         简单工厂模式就是由一个工厂类根据传入的参量决定创建出哪一种产品类型的实例，下面我们拿实例来介绍简单工厂模式。如下图，抽象类型车包括子类火车，汽车，拖拉机。

工厂根据传入的参数来创建具体车的类型。上图中无法形象地表示抽象类所以用接口代替了。

java代码如下： 

 

Java代码  

1. package com.pattern.SimpleFactory;   
2. /**  
3. *  
4. *【描述】：工厂类  
5. *【作者】：alaric  
6. *【时间 】：May 20, 2012  
7. *【文件】：com.pattern.SimpleFactoryFactory.java  
8. *  
9. */  
10. public class Factory {   
11. /**  
12. *  
13. *【描述】：创建车的实例 这个类里面的判断代码在实际应用中多配置成map，如果用spring 则可以配置在bean的xml内 
14. *【作者】：alaric  
15. *【时间 】：May 20, 2012  
16. * @throws TypeErrorException  
17. *  
18. */  
19. public TrafficMachine creator(String type) throws TypeErrorException{   
20. if(type.equals("Automobile")){   
21. return new Automobile();   
22. }else if (type.equals("Tractor")) {   
23. return new Tractor();   
24. }else if (type.equals("Train")) {   
25. return new Train();   
26. }else{   
27. throw new TypeErrorException("not find "+type);   
28. }   
29. }   
30. }   
31. package com.pattern.SimpleFactory;   
32. /**  
33. *  
34. *【描述】：汽车类  
35. *【作者】：alaric  
36. *【时间 】：May 20, 2012  
37. *【文件】：com.pattern.SimpleFactoryAutomobile.java  
38. *  
39. */  
40. public class Automobile extends TrafficMachine{   
41. @Override  
42. public void traffic() {   
43. // TODO Auto-generated method stub   
44. }   
45. }   
46. package com.pattern.SimpleFactory;   
47. /**  
48. *  
49. *【描述】：拖拉机  
50. *【作者】：alaric  
51. *【时间 】：May 20, 2012  
52. *【文件】：com.pattern.SimpleFactoryTractor.java  
53. *  
54. */  
55. public class Tractor extends TrafficMachine{   
56. @Override  
57. public void traffic() {   
58. // TODO Auto-generated method stub   
59. }   
60. /**  
61. *  
62. *【描述】：耕地  
63. *【作者】：alaric  
64. *【时间 】：May 20, 2012  
65. *  
66. */  
67. public void plough(){   
68. }   
69. }   
70. package com.pattern.SimpleFactory;   
71. /**  
72. *  
73. *【描述】：火车  
74. *【作者】：alaric  
75. *【时间 】：May 20, 2012  
76. *【文件】：com.pattern.SimpleFactoryTrain.java  
77. *  
78. */  
79. public class Train extends TrafficMachine {   
80. private int nodeNum; //节数  
81. private int trainNum; //车次  
82. @Override  
83. public void traffic() {   
84. // TODO Auto-generated method stub   
85. }   
86. public int getNodeNum() {   
87. return nodeNum;   
88. }   
89. public void setNodeNum(int nodeNum) {   
90. this.nodeNum = nodeNum;   
91. }   
92. public int getTrainNum() {   
93. return trainNum;   
94. }   
95. public void setTrainNum(int trainNum) {   
96. this.trainNum = trainNum;   
97. }   
98. }   
99. package com.pattern.SimpleFactory;   
100. /**  
101. *  
102. *【描述】：抽象类 车  
103. *【作者】：alaric  
104. *【时间 】：May 20, 2012  
105. *【文件】：com.pattern.SimpleFactoryMachine.java  
106. *  
107. */  
108. public abstract class TrafficMachine {   
109. public float power ;   
110. public float load ;   
111. public abstract void traffic();   
112. }   
113. package com.pattern.SimpleFactory;   
114. /**  
115. *  
116. *【描述】：类型异常类  
117. *【作者】：alaric  
118. *【时间 】：May 20, 2012  
119. *【文件】：com.pattern.SimpleFactoryTypeErrorException.java 
120. *  
121. */  
122. public class TypeErrorException extends Exception{   
123. /**  
124. *  
125. */  
126. private static final long serialVersionUID = 562037380358960152L;   
127. public TypeErrorException(String message) {   
128. super(message);   
129. // TODO Auto-generated constructor stub   
130. }   
131. }  

package com.pattern.SimpleFactory;
/**
*
*【描述】：工厂类
*【作者】：alaric
*【时间 】：May 20, 2012
*【文件】：com.pattern.SimpleFactoryFactory.java
*
*/
public class Factory {
/**
*
*【描述】：创建车的实例 这个类里面的判断代码在实际应用中多配置成map，如果用spring 则可以配置在bean的xml内
*【作者】：alaric
*【时间 】：May 20, 2012
* @throws TypeErrorException
*
*/
public TrafficMachine creator(String type) throws TypeErrorException{
if(type.equals("Automobile")){
return new Automobile();
}else if (type.equals("Tractor")) {
return new Tractor();
}else if (type.equals("Train")) {
return new Train();
}else{
throw new TypeErrorException("not find "+type);
}
}
}
package com.pattern.SimpleFactory;
/**
*
*【描述】：汽车类
*【作者】：alaric
*【时间 】：May 20, 2012
*【文件】：com.pattern.SimpleFactoryAutomobile.java
*
*/
public class Automobile extends TrafficMachine{
@Override
public void traffic() {
// TODO Auto-generated method stub
}
}
package com.pattern.SimpleFactory;
/**
*
*【描述】：拖拉机
*【作者】：alaric
*【时间 】：May 20, 2012
*【文件】：com.pattern.SimpleFactoryTractor.java
*
*/
public class Tractor extends TrafficMachine{
@Override
public void traffic() {
// TODO Auto-generated method stub
}
/**
*
*【描述】：耕地
*【作者】：alaric
*【时间 】：May 20, 2012
*
*/
public void plough(){
}
}
package com.pattern.SimpleFactory;
/**
*
*【描述】：火车
*【作者】：alaric
*【时间 】：May 20, 2012
*【文件】：com.pattern.SimpleFactoryTrain.java
*
*/
public class Train extends TrafficMachine {
private int nodeNum; //节数
private int trainNum; //车次
@Override
public void traffic() {
// TODO Auto-generated method stub
}
public int getNodeNum() {
return nodeNum;
}
public void setNodeNum(int nodeNum) {
this.nodeNum = nodeNum;
}
public int getTrainNum() {
return trainNum;
}
public void setTrainNum(int trainNum) {
this.trainNum = trainNum;
}
}
package com.pattern.SimpleFactory;
/**
*
*【描述】：抽象类 车
*【作者】：alaric
*【时间 】：May 20, 2012
*【文件】：com.pattern.SimpleFactoryMachine.java
*
*/
public abstract class TrafficMachine {
public float power ;
public float load ;
public abstract void traffic();
}
package com.pattern.SimpleFactory;
/**
*
*【描述】：类型异常类
*【作者】：alaric
*【时间 】：May 20, 2012
*【文件】：com.pattern.SimpleFactoryTypeErrorException.java
*
*/
public class TypeErrorException extends Exception{
/**
*
*/
private static final long serialVersionUID = 562037380358960152L;
public TypeErrorException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}

        通过以上分析及其代码列举可知，简单工厂类的构造有三种角色，它们分别是工厂角色，抽象产品角色和具体产品角色。工厂类的创建方法根据传入的参数来判断实例化那个具体的产品实例。

        工厂类角色：这个角色是工厂方法模式的核心，含有与应用紧密相连的商业逻辑。工厂类在客户端的直接调用下创建产品对象，它往往由一个具体的java类来实现。
        抽象产品角色：担当这个角色的是一个java接口或者java抽象类来实现。往往是工厂产生具体类的父类。
        具体产品角色：工厂方法模式所创建的任何对象都是这个角色的实例，具体产品往往就是一个具体的java类来承担。

简单工厂的优缺点：
         1、优点是因为客户端可以直接消费产品，而不关心具体产品的实现，免除了客户端直接创建产品对象的责任，简单工厂模式就是通过这种方法实现了对责任的分割。
         2、缺点是简单工厂在当产品多层次结构复杂时工厂只能依靠自己，这样就形成了一个万能类，如果这个工厂不能工作了，所有的创建都将不能实现，而且当产品类别多结构复杂的情况下，把所有创建放进一个工厂来，是的后期程序的扩展较为困难。这个困难将在下节（工厂方法）进行讲述。