工厂方法模式的java实现例子

转载出处：http://blog.youkuaiyun.com/pnjlc/article/details/52711486

说明：本文是《大话设计模式》一书的学习文摘和网上相关信息文摘，原书代码例子用C#写，下面用Java改写。

1、工厂方法模式：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

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

2、工厂方法模式由4种角色组成：
（1）抽象工厂(Creator)角色：是工厂方法模式的核心，与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
（2）具体工厂(Concrete Creator)角色：这是实现抽象工厂接口的具体工厂类，包含与应用程序密切相关的逻辑，并且受到应用程序调用以创建产品对象。
（3）抽象产品(Product)角色：工厂方法模式所创建的对象的超类型，也就是产品对象的共同父类或共同拥有的接口。
（4）具体产品(Concrete Product)角色：这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建，它们之间往往一一对应。

3、工厂方法模式的UML类图


4、工厂方法和简单工厂的区别  
   工厂方法模式把简单工厂的内部逻辑判断移到了客户端代码来进行。
   工厂方法模式是简单工厂模式的衍生，首先完全实现开放－封闭原则，实现了可扩展。其次更复杂的层次结构，可以应用于产品结果复杂的场合。

5、下面实现一个加减乘除的工厂方法模式

[java] view plain copy

print ?

1. package demo8;  
2. /** 
3.  * 工厂接口 
4.  * 
5.  */  
6. interface IFactory {  
7.     Operation CreateOperation();  
8. }  
9.   
10.   
11. package demo8;  
12. /** 
13.  * 具体工厂(Concrete Creator)角色：加法类工厂 
14.  * 
15.  */  
16. public class AddFactory implements IFactory {  
17.     @Override  
18.     public Operation CreateOperation() {  
19.         return new OperationAdd();  
20.     }     
21. }  
22.   
23.   
24. package demo8;  
25. /** 
26.  * 具体工厂(Concrete Creator)角色：减法类工厂 
27.  * 
28.  */  
29. public class SubFactory implements IFactory {  
30.     @Override  
31.     public Operation CreateOperation() {          
32.         return new OperationSub();  
33.     }  
34. }  
35.   
36.   
37. package demo8;  
38. /** 
39.  * 具体工厂(Concrete Creator)角色：乘法类工厂 
40.  * 
41.  */  
42. public class MulFactory implements IFactory {  
43.     @Override  
44.     public Operation CreateOperation() {          
45.         return new OperationMul();  
46.     }  
47. }  
48.   
49.   
50. package demo8;  
51. /** 
52.  * 具体工厂(Concrete Creator)角色：除法类工厂 
53.  * 
54.  */  
55. public class DivFactory implements IFactory {  
56.     @Override  
57.     public Operation CreateOperation() {          
58.         return new OperationDiv();  
59.     }  
60. }  
61.   
62.   
63. package demo8;  
64. /** 
65.  * 抽象产品(Product)角色：运算类 
66.  * 
67.  */  
68. public abstract class Operation {  
69.     private double numberA = 0;  
70.     private double numberB = 0;  
71.   
72.     public void setNumberA(double numberA) {  
73.         this.numberA = numberA;  
74.     }  
75.     public void setNumberB(double numberB) {  
76.         this.numberB = numberB;  
77.     }  
78.     public double getNumberA() {  
79.         return numberA;  
80.     }  
81.     public double getNumberB() {  
82.         return numberB;  
83.     }  
84.     public double getResult() {  
85.         double result = 0;  
86.         return result;  
87.     }     
88. }  
89.   
90.   
91. package demo8;  
92. /** 
93.  * 具体产品(Concrete Product)角色：加法类 
94.  * 
95.  */  
96. public class OperationAdd extends Operation {     
97.     @Override  
98.     public double getResult() {  
99.         double result = 0;  
100.         result = super.getNumberA() + super.getNumberB();  
101.         return result;  
102.     }  
103. }  
104.   
105.   
106. package demo8;  
107. /** 
108.  * 具体产品(Concrete Product)角色：减法类 
109.  * 
110.  */  
111. public class OperationSub extends Operation {     
112.     @Override  
113.     public double getResult() {  
114.         double result = 0;  
115.         result = super.getNumberA() - super.getNumberB();  
116.         return result;  
117.     }  
118. }  
119.   
120.   
121. package demo8;  
122. /** 
123.  * 具体产品(Concrete Product)角色：乘法类 
124.  * 
125.  */  
126. public class OperationMul extends Operation {  
127.     @Override  
128.     public double getResult() {  
129.         double result = 0;  
130.         result = super.getNumberA() * super.getNumberB();  
131.         return result;  
132.     }  
133. }  
134.   
135.   
136. package demo8;  
137. /** 
138.  * 具体产品(Concrete Product)角色：除法类 
139.  * 
140.  */  
141. public class OperationDiv extends Operation {  
142.     @Override  
143.     public double getResult() {  
144.         double result = 0;  
145.         if (super.getNumberB() == 0)              
146.             throw new ArithmeticException("除数不能为0.");             
147.         result = super.getNumberA() / super.getNumberB();  
148.         return result;  
149.     }  
150. }  
151.   
152.   
153. package demo8;  
154. /** 
155.  * 客户端 
156.  * 
157.  */  
158. public class Demo8 {  
159.     public static void main(String[] args) {  
160.         IFactory operFactory = new AddFactory();          
161.         Operation oper = operFactory.CreateOperation();  
162.         oper.setNumberA(10);  
163.         oper.setNumberB(7);  
164.         double result = oper.getResult();  
165.         System.out.println(result);  
166.     }  
167. }  

package demo8;
/**
 * 工厂接口
 *
 */
interface IFactory {
	Operation CreateOperation();
}


package demo8;
/**
 * 具体工厂(Concrete Creator)角色：加法类工厂
 *
 */
public class AddFactory implements IFactory {
	@Override
	public Operation CreateOperation() {
		return new OperationAdd();
	}	
}


package demo8;
/**
 * 具体工厂(Concrete Creator)角色：减法类工厂
 *
 */
public class SubFactory implements IFactory {
	@Override
	public Operation CreateOperation() {		
		return new OperationSub();
	}
}


package demo8;
/**
 * 具体工厂(Concrete Creator)角色：乘法类工厂
 *
 */
public class MulFactory implements IFactory {
	@Override
	public Operation CreateOperation() {		
		return new OperationMul();
	}
}


package demo8;
/**
 * 具体工厂(Concrete Creator)角色：除法类工厂
 *
 */
public class DivFactory implements IFactory {
	@Override
	public Operation CreateOperation() {		
		return new OperationDiv();
	}
}


package demo8;
/**
 * 抽象产品(Product)角色：运算类
 *
 */
public abstract class Operation {
	private double numberA = 0;
	private double numberB = 0;

	public void setNumberA(double numberA) {
		this.numberA = numberA;
	}
	public void setNumberB(double numberB) {
		this.numberB = numberB;
	}
	public double getNumberA() {
		return numberA;
	}
	public double getNumberB() {
		return numberB;
	}
	public double getResult() {
		double result = 0;
		return result;
	}	
}


package demo8;
/**
 * 具体产品(Concrete Product)角色：加法类
 *
 */
public class OperationAdd extends Operation {	
	@Override
	public double getResult() {
		double result = 0;
		result = super.getNumberA() + super.getNumberB();
		return result;
	}
}


package demo8;
/**
 * 具体产品(Concrete Product)角色：减法类
 *
 */
public class OperationSub extends Operation {	
	@Override
	public double getResult() {
		double result = 0;
		result = super.getNumberA() - super.getNumberB();
		return result;
	}
}


package demo8;
/**
 * 具体产品(Concrete Product)角色：乘法类
 *
 */
public class OperationMul extends Operation {
	@Override
	public double getResult() {
		double result = 0;
		result = super.getNumberA() * super.getNumberB();
		return result;
	}
}


package demo8;
/**
 * 具体产品(Concrete Product)角色：除法类
 *
 */
public class OperationDiv extends Operation {
	@Override
	public double getResult() {
		double result = 0;
		if (super.getNumberB() == 0)			
			throw new ArithmeticException("除数不能为0.");			
		result = super.getNumberA() / super.getNumberB();
		return result;
	}
}


package demo8;
/**
 * 客户端
 *
 */
public class Demo8 {
	public static void main(String[] args) {
		IFactory operFactory = new AddFactory();		
		Operation oper = operFactory.CreateOperation();
		oper.setNumberA(10);
		oper.setNumberB(7);
		double result = oper.getResult();
		System.out.println(result);
	}
}