Question

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

实现操作界面的1个类
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;
    }
}

Multiply class

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));
    }
}

Answer 1

实际上它是战略模式。当然，Marko是对的，Context类是完全冗余的。拥有它们的原因是什么？

类Add，Multiply，Subtract是策略，因为它们定义了实际对参数的作用，而不是它们自己。伪代码可以是：如果操作是添加，则使用添加策略否则，如果操作是Multiply，则使用Multiply策略等等......

最好正确地调用类（即AddStrategy，MultiplyStrategy）而不是Context，最好是（控制器或处理器，如果你愿意），它的代码看起来像：

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);
   }
}

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

Answer 2

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

上下文类是多余的。在战略模式中没有这样的要求。所以基本上，你可以使用“Type to interface to the implementation”规则。您可以执行此操作，而不是使用这些上下文类。
```
public class Context {

protected Operation OP;    

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

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

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

Answer 3

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

This page用现实生活中的例子来解释它。

任何人都可以告诉我这是一种策略模式

3 个答案: