工厂方法模式-Factory Method

工厂方法模式:定义一个用于创建对象的接口,让子类决定实例化哪一个类.工厂方法模式让一个类的实例化延迟到其子类.

工厂方法模式与简单工厂模式的对比:

• 简单工厂模式:最大的优点在于工厂类中包含类必要的判断逻辑,根据客户端的选择动态实例化相关的类,对于客户端来说,去除了与具体产品的依赖.但是,正因为把判断逻辑放到了工厂类中,当有新的功能增加时,需要修改工厂类这就违背了开闭原则.
• 工厂方法模式:相对的工厂方法模式把相关判断逻辑放到类客户端,需要增加功能时需要修改客户端代码,并增加新的具体工厂方法.工厂方法模式克服了简单工厂违背开闭原则的问题,有保持了封装对象创建过程中的优点.

工厂方法模式结构图:

代码实现:

 1 /**
 2  * 运算类的父类,定义公共的方法
 3  */
 4 public abstract class Operation {
 5 
 6     protected double numberA;
 7     protected double numberB;
 8 
 9     public double getNumberA() {
10         return numberA;
11     }
12 
13     public void setNumberA(double numberA) {
14         this.numberA = numberA;
15     }
16 
17     public double getNumberB() {
18         return numberB;
19     }
20 
21     public void setNumberB(double numberB) {
22         this.numberB = numberB;
23     }
24 
25     // 取得结果
26     public abstract double getResult();
27 }

 1 /**
 2  * 加法运算类
 3  */
 4 public class OperationAdd extends Operation {
 5 
 6     @Override
 7     public double getResult() {
 8         return numberA + numberB;
 9     }
10 }
11 
12 /**
13  * 减法法运算类
14  */
15 public class OperationSub extends Operation {
16 
17     @Override
18     public double getResult() {
19         return numberA - numberB;
20     }
21 }
22 
23 /**
24  * 乘法运算类
25  */
26 public class OperationMul extends Operation {
27 
28     @Override
29     public double getResult() {
30         return numberA * numberB;
31     }
32 }
33 
34 /**
35  * 除法运算类
36  */
37 public class OperationDiv extends Operation {
38 
39     @Override
40     public double getResult() {
41         if(numberB == 0){
42             System.out.println("Sorry,除数不能为: 0");
43             return 0D;
44         }
45         return numberA / numberB;
46     }
47 }

1 /**
2  * 工厂接口
3  */
4 public interface IFactory {
5 
6     public abstract Operation createOperation();
7 }

 1 /**
 2  * 加法类工厂
 3  */
 4 public class AddFactory implements IFactory {
 5 
 6     @Override
 7     public Operation createOperation() {
 8         return new OperationAdd();
 9     }
10 }
11 
12 /**
13  * 减法类工厂
14  */
15 public class SubFactory implements IFactory {
16 
17     @Override
18     public Operation createOperation() {
19         return new OperationSub();
20     }
21 }
22 
23 /**
24  * 乘法类工厂
25  */
26 public class MulFactory implements IFactory {
27 
28     @Override
29     public Operation createOperation() {
30         return new OperationMul();
31     }
32 }
33 
34 /**
35  * 除法类工厂
36  */
37 public class DivFactory implements IFactory {
38 
39     @Override
40     public Operation createOperation() {
41         return new OperationDiv();
42     }
43 }

 1 public class Test {
 2 
 3     public static void main(String[] args) {
 4         IFactory factory = new AddFactory();
 5         Operation operation = factory.createOperation();
 6 
 7         operation.setNumberA(67.2D);
 8         operation.setNumberB(35.4D);
 9 
10         System.out.println(operation.getResult());
11     }
12 }

(本随笔参考了程杰老师的<<大话设计模式>>)

转载于:https://www.cnblogs.com/LionheartCGJ/p/7087576.html