zoukankan      html  css  js  c++  java
  • 设计模式(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类,并提供生产产品的方法。即没有策略模式中的第二层封装,这里用户需要完成配置产品的动作,虽然使用工厂方法,这个配置动作简单了一些,但是用户还是要执行。但是策略模式中,用户根本就不需要去了解任何配置的事情,也不需要了解算法的存在。
    • 策略模式的应用强调:相同行为不同实现的算法封装。算法和产品的不同在于,算法原本只是为了实现对象的某个行为,由于实现经常变动,因此把这种经常改变的部分提取出来,作为一个抽象类封装起来。 所以说策略模式属于对象行为模式
    • 简单工厂模式的应用强调:相同类别产品的封装。产品关注的是一个个的对象。所以简单工厂模式属于类的创建型模式
    • 这两种模式都不注重实现,都是在于如何组织、调用产品或算法,所以抽象出一些新的类实现这些管理功能。----设计模式有点参考管理学的东西吧。

     

  • 相关阅读:
    进程控制
    文件、目录操作相关函数
    Linux 系统IO函数 复制文件内容
    gdb调试
    makefile的使用
    GCC编译器
    vim命令的使用
    Linux Ubuntu笔记(常用命令)
    博客搬家(CSDN->博客园)
    level 4
  • 原文地址:https://www.cnblogs.com/hf-cherish/p/4759881.html
Copyright © 2011-2022 走看看