标签: strategy-pattern

我刚遇到两种模式.

1. 战略模式

2. 装饰

策略模式: -

策略模式提供了几种可用于执行特定操作或任务的算法.

装饰图案: -

装饰器模式为组件添加了一些功能.

事实上,我发现策略模式和装饰模式也可以互换使用.

这是链接: - 何时以及如何应用策略模式而不是装饰模式？

Strategy Pattern和Decorator Pattern有什么区别？

什么时候应该使用策略模式,何时应该使用Decorator模式？

用同一个例子解释两者之间的区别.

Strategy模式和PolymorphismJava 之间有什么区别？

我很困惑,通过策略模式实现的任何事情基本上都可以通过多态实现.如果我在这方面错了,请纠正我.

请给我一个根除我的困惑的例子.

我知道之前已经问过这个问题(例如,桥梁模式和策略模式之间有什么区别？).

但是,有人可以使用明确的例子解释,区别的是什么,以及在哪种情况下必须选择另一种情况？更少概念理论,更实际的"现实生活"情景将不胜感激.

这些术语是相同的还是依赖注入和策略模式之间存在任何重要差异？对我而言,马丁福勒似乎只是用一个更有吸引力的名字重新命名了战略模式,我错过了什么？

任务是用java实现漂亮的策略设计模式enum:

public enum MyEnum {

    FIRST {
        @Override
        public String doIt() {
            return "1: " + someField; //error
        }
    },
    SECOND {
        @Override
        public String doIt() {
            return "2: " + someField; //error
        }
    };

    private String someField;

    public abstract String doIt();

} 

但是在提到someField我的时候

无法对someField的非静态字段进行静态引用.

有什么不对,有可能做得更好吗？

何时使用战略模式？

我看到像这样的客户端代码片段:

class StrategyExample {

    public static void main(String[] args) {

        Context context;

        // Three contexts following different strategies
        context = new Context(new ConcreteStrategyAdd());
        int resultA = context.executeStrategy(3,4);

        context = new Context(new ConcreteStrategySubtract());
        int resultB = context.executeStrategy(3,4);

        context = new Context(new ConcreteStrategyMultiply());
        int resultC = context.executeStrategy(3,4);

    }

}

看起来你可以将它重构为:

class StrategyExample {

    public static void main(String[] args) {
         // Three contexts following different strategies
        int resultA =new ConcreteStrategyAdd().execute(3,4);
        int resultB =new ConcreteStrategySubtract().execute(3,4);
        int resultC =new ConcreteStrategyMultiply().execute(3,4);
    }

} …

我终于忍受了Dependency Injection(早就应该); 我开始玩Unity并遇到战略模式的问题.我可以使用容器向我返回基于名称的策略的特定实现,但我没有看到我应该如何在上下文中获得正确的策略.
让我们举一个简单的例子说明:上下文是一辆汽车,它有一个IEngine(策略),有2个实现,FastEngine和SlowEngine.代码将沿着这些方向看:

public interface IEngine
{
    double MaxSpeed
    {
        get;
    }
}

internal class FastEngine:IEngine
{
    public double MaxSpeed
    {
        get 
        { 
            return 100d; 
        }
    }
}

internal class SlowEngine:IEngine
{
    public double MaxSpeed
    {
        get
        {
            return 10d;
        }
    }
}

public class Car
{
    private IEngine engine;
    public double MaximumSpeed
    {
        get
        {
            return this.engine.MaxSpeed;
        }
    }

    public Car(IEngine engine)
    {
        this.engine = engine;
    }
}

我的问题如下:我应该如何实例化快车或慢车？我可以使用容器为我提供每个实现,我可以设置一个"默认"实现来使用:

IUnityContainer container = new UnityContainer();
container.RegisterType<IEngine, FastEngine>();
container.RegisterType<IEngine, FastEngine>("Fast"); …

在过去,我已经看到策略模式被解释为一种机制,它允许函数/类的用户为该函数/类提供它们自己的功能.

我一直被告知,实现模式的方法是将函数指针引入类/函数并在内部调用它们,从而允许程序员提供自己的"策略",这些策略将由这些函数和对象在内部使用.

最近看,我看到策略模式似乎总是通过使用继承层次结构来解释/定义,如下所示:

战略模式实施

这是意见/实施的不同,还是功能指针传递的不是战略模式的变化？我最感兴趣所以当我评论或解释我的代码时,我不会混淆人们:)

说我用春天,我有以下策略......

接口

public interface MealStrategy {
    cook(Meat meat);
}

第一战略

@Component
public class BurgerStrategy  implements
MealStrategy {
  @Autowired CookerDao cookeryDao;

  @Override
  public void cook(Meat meat) {
      cookeryDao.getBurger(meat);
  }
}

下一步策略......

@Component
public class SausageStrategy  implements
MealStrategy {
  @Autowired CookerDao cookeryDao;

  @Override
  public cook(Meat meat) {
      return cookeryDao.getSausage(meat);
  }
}

背景...

@Component
@Scope("prototype")
public class MealContext {
    private MealStrategy mealStrategy;

    public void setMealStrategy(MealStrategy strategy) {
        this.strategy = strategy;
    }

    public void cookMeal(Meat meat) {
        mealStrategy.cook;
    }
}

现在说这个上下文是通过mvc控制器访问的,比如...

@Autowired
private MealContext …

策略模式和委托模式(不是委托)之间有什么区别？