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

1. 简单工厂模式

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

---

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

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

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

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

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

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

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

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

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

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

 

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

 

 

class Test{
    public static void main( String[] args ){
        Operation oper;
        OperationFactory operFac = new OperationFactory();
        oper = operFac.createOperation("+");
        oper.setOpA(1);
        oper.setOpB(2);
        oper.getResult();
    }
}

class OperationFactory{
    public Operation createOperation( String op ){
        if( op == "+" )    return new OperationAdd();
        if( op == "-" )    return new OperationMinus();
        if( op == "*" )    return new OperationMultiply();
        return new OperationDivide();
    }
}

abstract class Operation{
    private double opA;
    private double opB;
    
    public double getOpA() {
        return opA;
    }

    public void setOpA(double opA) {
        this.opA = opA;
    }

    public double getOpB() {
        return opB;
    }

    public void setOpB(double opB) {
        this.opB = opB;
    }

    public abstract double getResult();
}

class OperationAdd extends Operation{
    public double getResult(){
        return getOpA() + getOpB();
    }
}

class OperationMinus extends Operation{
    public double getResult(){
        return getOpA() - getOpB();
    }
}

class OperationMultiply extends Operation{
    public double getResult(){
        return getOpA() * getOpB();
    }
}

class OperationDivide extends Operation{
    public double getResult(){
        if( getOpB() == 0 )
            try {
                throw new Exception("除数不能为0");
            } catch (Exception e) {
            }
        return getOpA() / getOpB();
    }
}

 

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）封装算法变化。

 

class Context{
    Strategy str;
    public Context( Strategy str ){
        this.str = str;
    }
    
    public void contextInterface(){
        str.algorithmInterface();
    }
}

public abstract class Strategy {
    public abstract void algorithmInterface();
}

class ConcreteStrategyA extends Strategy{
    public void algorithmInterface(){}
}

class ConcreteStrategyB extends Strategy{
    public void algorithmInterface(){}
}

class ConcreteStrategyC extends Strategy{
    public void algorithmInterface(){}
}

 

 

 

 

 图二.策略模式类图

 

 3. 总结

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

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