谁能告诉我这是一种策略模式答案

【问题标题】：Can any one tell me how this is a strategy pattern谁能告诉我这是一种策略模式
【发布时间】：2016-11-21 13:52:41
【问题描述】：

在下面的代码中基本上是三个 3 主要类

1个实现Operation接口的类
2 扩展自 Context 类的类
3 演示策略模式的主类

所以我的问题是，这种策略模式如何应用在这段代码中

操作界面

public interface Operation { 
    public float run(float a,float b);
}

添加类

public class Add implements Operation{ 
    @Override
    public float run(float a, float b) {
        return a+b;
    }
}

乘法类

public class Multiply implements Operation {
    @Override
    public float run(float a, float b) {
        return a*b;
    }
}

减去类

public class Subtract implements Operation {
    @Override
    public float run(float a, float b) {
        return a-b;
    }
}

上下文类

public abstract class Context {
    protected Operation OP;

    public abstract float run(float a,float b);
}

AddContext 类

public class AddContext extends Context {
    public AddContext(){
        OP = new Add();
    }
    @Override
    public float run(float a, float b) {
        return OP.run(a,b);
    }
}

MultiplyContext 类

public class MultiplyContext extends Context {
    public MultiplyContext(){
        OP = new Multiply();
    }
    @Override
    public float run(float a, float b) {
        return OP.run(a,b);
    }
}

SubtractContest 类

public class SubtractContext extends Context {
    public SubtractContext(){
        OP = new Subtract();
    }
    @Override
    public float run(float a, float b) {
        return OP.run(a,b);
    }
}

主类

public class Main {
    public static void main(String... o){
// 1st Strategy        
        Context c = new AddContext();
        System.out.println(c.run(1,2));

// 2nd Strategy
        c = new SubtractContext();
        System.out.println(c.run(1,2));

// 3rd Strategy
         c = new MultiplyContext();
        System.out.println(c.run(1,2));
    }
}

【问题讨论】：

我看到的一件事是...Context 类的盲目冗余。
你怎么知道是策略模式？有什么参考吗？我在那些行中看不到任何东西
因为在我的期中论文里
请检查这是{tutorialspoint.com/design_pattern/strategy_pattern.htm}的修改版本
Operation 及其实现者是Strategy 的经典示例。调用者只看到Operation，各种策略执行不同类型的操作。

标签： java design-patterns strategy-pattern

【解决方案1】：

其实就是策略模式。当然，Marko 是对的，Context 类是完全多余的。拥有它们的原因是什么？

类 Add、Multiply、Subtract 是策略，因为它们定义了参数的实际作用，而不是它们本身。伪代码可以是：如果操作是 Add 则使用 Add 策略否则，如果运算是乘法，则使用乘法策略等等...

最好正确调用类（即 AddStrategy、MultiplyStrategy），而不是 Context，最好是（如果您愿意，可以使用 Controller 或 Processor），其代码如下所示：

public class Controller()
{
   private Operation addStrategy = new AddStrategy();
   private Operation multiplyStrategy = new MultiplyStrategy();
   private Operation subtractStrategy = new SubtractStrategy();


   public float runOperation(String op,float a, float b)
   {
     Operation requestedStrategy;
     switch (op)
     {
       case "+":              
            requestedStrategy = addStrategy;
            break;
       case "*":              
            requestedStrategy = multiplyStrategy;
            break;
       case "-":              
            requestedStrategy = subtractStrategy;
            break;
       default:
            throw new Exception("Unsupported operation");
     }

     return requestedStrategy.run(a,b);
   }
}

所以，它是经典的策略模式。

【讨论】：

更好，operationMap.get(opSymbol).run(a, b)
当然，有很多方法。我只是想让它更清晰可读，而不是更好地运行:)
实际上您的方法可能更快，但我建议的方法更具可读性。
是的... :) 并且在现实生活中地图要好得多 - 我几乎总是使用您的方法，因为通常策略不在控制器实现中，而是在抽象/通用类中，通常是 Spring bean等等...但下一个问题可能是“那张地图是什么？那张地图上有什么？等等... :) 我只是在开玩笑 :)

【解决方案2】：

这是策略模式，但应该添加一些东西。

上下文类是多余的。在策略模式中没有这样的要求。所以基本上，你可以在那里使用“类型接口而不是实现”规则。您可以这样做，而不是拥有那些上下文类。
```
public class Context {

protected Operation OP;    

public Context(Operation OP) {
   this.OP = OP;
}

public float doStuff(float a,float b){
       OP.run(a,b);
}

}
```
然后您的客户端类可以使用自定义策略实例化上下文类。

【讨论】：

【解决方案3】：

很多人说这是策略模式，但我不同意。策略模式要求您可以更改上下文的操作。这更像是一种奇怪的、退化的命令模式。

This page 用一个真实的例子来解释它。

【讨论】：