设计模式（1）--简单工厂模式、策略模式

1. 简单工厂模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述简单工厂模式的：简单工厂模式是类的创建模式，又叫做静态工厂方法（Static Factory Method）模式。简单工厂模式是由一个工厂对象决定创建出哪一种产品类的实例。

先放图再解释。下图一是从《大话设计模式》中摘出来的。问题是：用任意一种面向对象语言实现一个计算器控制台程序，要求输入两个数和运算符号，得到结果。

简单工厂模式实现的关键点有两个：

1. 继承：定义一个抽象父类“抽象产品”（Operation类），和一堆具体的子类“实际产品”（OperationAdd等子类）。抽象父类的设计是非常重要的（属性、方法）

2. 关联关系：定义一个“工厂类”，他提供生产产品的方法（图中createOperate()），然后返回一个产品（Operation类）。关联关系使一个类知道另一个类的属性和方法。

解决问题：如何实例化一个合适的对象

扩展方法：新增“产品”子类，并修改“工厂类”的创建逻辑。

使用方法：使用工厂类创建产品类，然后调用产品方法或属性。（客户端了解两个类：工厂类和产品抽象类）

优点：简单。但应用很广哦

缺点：每次还需要修改创建逻辑，如果创建逻辑挂掉，整个就挂了。而且每次扩展都要修改“工厂类”代码，这就需要重新编译部署代码。

使用场景：负责创建的对象比较少；客户只知道传入工厂的参数，不关心对象创建逻辑。容易违反高内聚低耦合，一般只在很简单的情况下使用。

图一. 简单工程模式类图示例

 1 class Test{
 2     public static void main( String[] args ){
 3         Operation oper;
 4         OperationFactory operFac = new OperationFactory();
 5         oper = operFac.createOperation("+");
 6         oper.setOpA(1);
 7         oper.setOpB(2);
 8         oper.getResult();
 9     }
10 }
11
12 class OperationFactory{
13     public Operation createOperation( String op ){
14         if( op == "+" )    return new OperationAdd();
15         if( op == "-" )    return new OperationMinus();
16         if( op == "*" )    return new OperationMultiply();
17         return new OperationDivide();
18     }
19 }
20
21 abstract class Operation{
22     private double opA;
23     private double opB;
24
25     public double getOpA() {
26         return opA;
27     }
28
29     public void setOpA(double opA) {
30         this.opA = opA;
31     }
32
33     public double getOpB() {
34         return opB;
35     }
36
37     public void setOpB(double opB) {
38         this.opB = opB;
39     }
40
41     public abstract double getResult();
42 }
43
44 class OperationAdd extends Operation{
45     public double getResult(){
46         return getOpA() + getOpB();
47     }
48 }
49
50 class OperationMinus extends Operation{
51     public double getResult(){
52         return getOpA() - getOpB();
53     }
54 }
55
56 class OperationMultiply extends Operation{
57     public double getResult(){
58         return getOpA() * getOpB();
59     }
60 }
61
62 class OperationDivide extends Operation{
63     public double getResult(){
64         if( getOpB() == 0 )
65             try {
66                 throw new Exception("除数不能为0");
67             } catch (Exception e) {
68             }
69         return getOpA() / getOpB();
70     }
71 }

View Code

2. 策略模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述策略（Strategy）模式的：

　　策略模式属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。

先放图再解释。下图二是从《大话设计模式》中摘出来的。问题实例是：做一个商场收银软件，根据客户购买商品的单价和数量，向客户收费。而商场可能做活动：打折、满减、满返之类的。

策略模式实现的关键点有两个：

1. 继承：实现某个功能需要一个“抽象算法类”（Strategy），算法可以有不同的实现，这些”具体算法类“（ConcreteStrategy）继承”抽象算法类“的通用接口。（Strategy类的接口设计是很重要的）

2. 聚合关系：对算法的使用进行封装，即提供一个算法的对外接口（Context类），Context类持有一个Strategy，把算法的使用和算法本身分开。 Context里有算法，但这个算法具体是啥，根据上下文不同，可能会是不同的算法。在什么样的情况下，配置采用哪个算法来实现，这就是Context的工作。用户只需要提供上下文给Context，然后Context就提供调用算法的接口。这个时候，Context和Strategy的关系更密切，它充当了算法与客户之间的接口，客户完全接触不到Strategy类了，但是Context完全了解Strategy。（聚合关系中，整体和个体是“has-a”的关系，整体部分可分离。）

扩展方法：新定义一个符合Strategy接口定义的算法，在Context里重新添加这一配置（如果采用反射，则可以避免这部分代码的修改，只需新定义ConcreteStrategy就好了，这个以后会讲）

使用方法：用户向Context传递上下文，然后调用Context的算法接口方法就好了。（客户端了解一个类：Context类）----这个可能是要和简单工厂模式联合使用

优点：

（1）提供管理相关算法的协议。同类算法实现不同，但有相同的行为特征，还可以把公共代码放到父类，避免冗余。

（2）封装算法变化。

 1 class Context{
 2     Strategy str;
 3     public Context( Strategy str ){
 4         this.str = str;
 5     }
 6
 7     public void contextInterface(){
 8         str.algorithmInterface();
 9     }
10 }
11
12 public abstract class Strategy {
13     public abstract void algorithmInterface();
14 }
15
16 class ConcreteStrategyA extends Strategy{
17     public void algorithmInterface(){}
18 }
19
20 class ConcreteStrategyB extends Strategy{
21     public void algorithmInterface(){}
22 }
23
24 class ConcreteStrategyC extends Strategy{
25     public void algorithmInterface(){}
26 }

View Code

图二.策略模式类图

3. 总结

策略模式和简单工厂模式的几点不同：

策略模式有两层封装。第一，把具体算法封装到Strategy：所有实现相同功能的算法继承这个类；第二，把算法封装起来，只提供用户需要的功能：用Context把算法封装起来，Context定义用户可以使用的接口，Context确定使用哪个算法实现用户要求的具体功能。
简单工厂模式有一层封装。把产品封装到Product类，并提供生产产品的方法。即没有策略模式中的第二层封装，这里用户需要完成配置产品的动作，虽然使用工厂方法，这个配置动作简单了一些，但是用户还是要执行。但是策略模式中，用户根本就不需要去了解任何配置的事情，也不需要了解算法的存在。
策略模式的应用强调：相同行为不同实现的算法封装。算法和产品的不同在于，算法原本只是为了实现对象的某个行为，由于实现经常变动，因此把这种经常改变的部分提取出来，作为一个抽象类封装起来。所以说策略模式属于对象行为模式。
简单工厂模式的应用强调：相同类别产品的封装。产品关注的是一个个的对象。所以简单工厂模式属于类的创建型模式。
这两种模式都不注重实现，都是在于如何组织、调用产品或算法，所以抽象出一些新的类实现这些管理功能。----设计模式有点参考管理学的东西吧。

posted on 2015-08-31 16:42 HF_Cherish 阅读(...) 评论(...) 编辑收藏

转载于:https://www.cnblogs.com/hf-cherish/p/4759881.html