简单工厂模式和策略模式

简单工厂模式

使用简单工厂模式实现计算器

public class Operation{
    private double _numberA = 0;
    private double _numberB = 0;

    public double get_numberA() {
        return _numberA;
    }
    public void set_numberA(double _numberA) {
        this._numberA = _numberA;
    }
    public double get_numberB() {
        return _numberB;
    }
    public void set_numberB(double _numberB) {
        this._numberB = _numberB;
    }

    public virtual double GetResult()
    {
        double result = 0;
        return result;
    }
}

加减乘除类：

class operationAdd : Operation{
    public Override doubleOverride GetResult(){
        doubleOverride result = 0;
        result = NumberA + NumberB;
        return result;
    }
}

class operationSub : Operation{
    public Override doubleOverride GetResult(){
        doubleOverride result = 0;
        result = NumberA - NumberB;
        return result;
    }
}

class operationMul : Operation{
    public Override doubleOverride GetResult(){
        doubleOverride result = 0;
        result = NumberA * NumberB;
        return result;
    }
}

class operationAdd : Operation{
    public Override doubleOverride GetResult(){
        doubleOverride result = 0;
        if(NumberB == 0)
            throw new Exception("除数不能为0")
        result = NumberA / NumberB;
        return result;
    }
}

简单运算工厂类：

public class OperationFactory{
    public static OperationFactory createOpera(String operate){
        OperationFactory oper = null;
        switch(operate){
        case "+":
            oper = new OperationAdd();
            break;
        case "-":
            oper = new OperationSub();
            break;
        case "*":
            oper = new OperationMul();
            break;
        case "/":
            oper = new OperationDiv();
            break;
        }
        return oper;
    }
}

Operation oper;
Oper = OperationFactory.createOperate("+");
Oper.NumberA = 1;
Oper.NumberB = 2;
double result = oper.GetResult();

策略模式

定义了算法家族分别封装起来，让它们可以互相替换

具体算法类

//具体算法A
class ConcreteStrategyA : Strategy{
    //算法A实现方法
    public override void AlgorithmInterface(){};
}

//具体算法B
class ConcreteStrategyB : Strategy{
    //算法B实现方法
    public override void AlgorithmInterface(){};
}

//具体算法C
class ConcreteStrategyC : Strategy{
    //算法C实现方法
    public override void AlgorithmInterface(){};
}

抽象算法类

abstract class Strategy{
    //算法方法
    public override void AlgorithmInterface();  
}

Context

//上下文
class Context{
    Strategy strategy;
    public Context(Strategy strategy){//用一个ConcreteStrategy来配置
        this.strategy = strategy;
    }
    //上下文接口
    public void ContextInterface(){
        strategy.AlgorithmInterface();
    }
}

客户端代码：

static void Main(String[] args){
    Context context;
    context = new Context(new ConcreteStrategyA());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyB());
    context.ContextInterface();

    context = new Context(new ConcreteStrategyC());
    context.ContextInterface();
}

二者的区别：

1. 简单工厂模式是通过传入一个条件，工厂类进行判断，生成一个对象；策略模式则是先生成一个策略对象，然后把它当做参数传入Context对象，通过Context调用改策略方法
2. 在简单工厂模式中实现了通过条件选取一个类去实例化对象，策略模式则将选取相应对象的工作交给模式的使用者，它本身不去做选取工作
3. Factory是直接创建具体的对象并用该对象去执行相应的动作，而Context将这个操作给了Context类，没有创建具体的对象，实现的代码的进一步封装，客户端代码并不需要知道具体的实现过程