标签: strategy-pattern

我在维基百科上看过这个解释,特别是C++示例,并且没有认识到只定义3个类,创建实例和调用它们之间的区别,以及那个例子.我看到的只是将其他两个类放入流程中,无法看到哪里会有好处.现在我肯定我错过了一些明显的东西(树木) - 有人可以用一个明确的现实世界的例子来解释它吗？

到目前为止,我可以从答案中得到什么,在我看来,这只是一种更为复杂的方式:

have an abstract class: MoveAlong with a virtual method: DoIt()
have class Car inherit from MoveAlong, 
     implementing DoIt() { ..start-car-and-drive..}
have class HorseCart inherit from MoveAlong, 
     implementing DoIt() { ..hit-horse..}
have class Bicycle inherit from MoveAlong, 
     implementing DoIt() { ..pedal..}
now I can call any function taking MoveAlong as parm 
passing any of the three classes and call DoIt
Isn't this what Strategy intents? (just simpler?)

[编辑 - 更新]我在上面引用的函数被替换为另一个类,其中MoveAlong属于属性,根据需要根据在这个新类中实现的算法设置.(与接受的答案中的内容类似.)

[编辑 - 更新] …

是否有任何标准的通用的"回调"或Java的"功能/法"类型,如System.Action<T>或System.Func<T,U>在.NET？

在我的具体情况中,我需要一个包装一个方法的类,该方法接受一个(泛型)参数类型T并且不返回任何内容(即void).

是的,为我自己创建这样的类/接口很容易,但如果有的话,我更喜欢标准库类.

当我使用Java(或类似语言)编程时,我经常使用简单版本的策略模式,使用接口和实现类,在我的代码中提供特定概念的运行时可选实现.

作为一个非常人为的例子,我可能希望拥有一个可以在我的Java代码中产生噪音的Animal的一般概念,并希望能够在运行时选择动物的类型.所以我会沿着这些方向编写代码:

interface Animal {
    void makeNoise();
}

class Cat extends Animal {
    void makeNoise() { System.out.println("Meow"); }
}

class Dog extends Animal {
    void makeNoise() { System.out.println("Woof"); }
}

class AnimalContainer {
    Animal myAnimal;

    AnimalContainer(String whichOne) {
        if (whichOne.equals("Cat"))
            myAnimal = new Cat();
        else
            myAnimal = new Dog();
    }

    void doAnimalStuff() {
        ...
        // Time for the animal to make a noise
        myAnimal.makeNoise();
        ...
    }

很简单.不过,最近,我一直在Scala开展一个项目,我想做同样的事情.使用特征这样做似乎很容易,例如:

trait Animal {
    def makeNoise:Unit
}

class Cat extends Animal {
    override def …

我提出这个问题是因为几天前我在这里提出的另一个问题.
我必须解决一个特定的问题,在得到两个回复后,我意识到两个模式可以帮助解决这个问题(以及任何其他类似问题).

1. 责任链
2. 战略

我的问题是:

这些模式之间究竟有什么区别？

你能给我一个具体的例子,当我更喜欢使用私有继承而非组合时？就个人而言,我将使用组合而非私有继承,但可能存在这样的情况:使用私有继承是特定问题的最佳解决方案.阅读C++ faq,给出了一个使用私有继承的示例,但我似乎比私有继承更容易使用组合+策略模式甚至公共继承.

我正在尝试找到一种实现依赖于第三方库类的服务的好方法.如果库不可用或无法提供答案,我还有一个'默认'实现用作后备.

public interface Service {

    public Object compute1();

    public Object compute2();
}

public class DefaultService implements Service {

    @Override
    public Object compute1() {
       // ...
    }

    @Override
    public Object compute2() {
        // ...
    }
}

该服务的实际实现将是这样的:

public class ServiceImpl implements Service {
    Service defaultService = new DefaultService();
    ThirdPartyService thirdPartyService = new ThirdPartyService();

    @Override
    public Object compute1() {
        try {
            Object obj = thirdPartyService.customCompute1();
            return obj != null ? obj : defaultService.compute1();
        } 
        catch (Exception e) {
            return defaultService.compute1();
        }
    } …

我已经越来越熟悉工厂模式(以及战略模式)以及模式可以带来的巨大好处.但是,我一直在努力应对以下情况:

以前,我会做类似以下的事情,其中​​有一个经理类可以构建和保存汽车.这里没有依赖注入,并且是一个糟糕的实现,特别是在尝试单元测试时.

public class CarManager
{
    public static Car GetCarFromDatabase(int carId) { return new Car(); }

    public static void SaveCar(Car car) { }
}

我现在看到我可以Factories为我制造不同的车,无论是来自数据库,还是来自哪里!这很棒!所以,这是我的问题:

Q1:我的理解是,Factories只应构建对象,这是正确的吗？如果是这样,我的第二个问题呢？

Q2:如果我按照工厂模式构建我的对象,我应该如何保存我的对象？这有不同的模式,还是我不完全理解工厂模式？

我用Java编程,但这是一个更多的设计问题,因此任何OO程序员都可以回答这个问题.我对战略设计模式有疑问.以下是我发现有用的几种墨水:

2. 战略模式解释-OO设计.

我使用策略模式两次,一组四个策略,一组三个.在每种情况下,我都通过维持一个腐朽的计数器来决定使用哪种策略.如果软件决定使用的策略成功,则计数器增加1.如果使用的策略不成功,则计数器减1.无论成功与否,所有计数器都会乘以.9左右的数字,以便随着时间的推移"衰减"计数器.软件将根据哪个策略具有最高计数器来选择使用哪种策略.我非常简单的UML的一个例子如下所示:

.

并以链接形式(为了更容易阅读): 示例UML

上面的UML是我想要使用的模型.如果你从上面的UML中无法分辨,我正在写一个Rock,Paper,Scissors游戏,目的是击败我所有的朋友.

现在,问题是:

我无法决定如何实施"计数器系统"来决定使用哪种策略.我在考虑某种"数据"类,其中可以存储所有计数器和历史字符串,但这对我来说似乎很笨拙.在任何时候我都维持着大约2个字符串和大约8个计数器(可能更多可能更少).这就是为什么我在想一个可以存储所有东西的"数据"类.我可以实例化在chooseStrategy()和chooseMetaStrategy()方法中使用的类,但我只是不知道.这是我自己的第一个项目,我无法决定任何事情.我觉得肯定有更好的解决方案,但我没有足够的经验知道.

谢谢!

------------------------------------跟进1 ---------- ----------------------------------

非常感谢大家的回答和客气话.我确实有一些跟进问题.我是StackOverflow的新手(并且喜欢它)所以如果这不是一个后续问题的正确位置,请告诉我.我正在编辑原帖,因为我的后续工作有点冗长.

我正在研究Paul Sonier关于使用复合图案的建议,它看起来非常有趣(感谢Paul!).出于HistoryMatching和"智能"AntiRotation策略的目的,我想实现两个类都可访问的所有对手游戏的字符串.此外,无论我的节目采用何种策略,我都希望编辑历史字符串,以便我能够准确记录对手的比赛.字符串越全面(实际上我可能会使用LinkedList但是如果有人知道更好的(子字符串/子列表)搜索方法/集合请让我知道)策略可以更好地预测对手的行为.

我想知道如何在仍然使用复合模式的同时实现这个"字符串"或集合.

此外,TheCapn提出,为每个对手存储不同的计数器和历史收集是个好主意.有关如何使用复合模式实现这一点的任何想法？

有一个相同的概念Strategy Pattern和Inheritance,这样我就可以实现Strategy Pattern与Inheritance这听起来很简单和清晰比Strategy Pattern.

Startegy Pattern:

class IBase
{
public:
    virtual void processAction(void *data) = 0; // pure virtual
}

class Worker: public IBase
{
public:
    virtual void processAction(void *data)
    {
        // define logic
    }
}

Inheritance:

class Base
{
public:
    virtual void processAction(void *data) {}
}

class Worker: public Base
{
public:
    virtual void processAction(void *data) override
    {
        // define logic
    }
}

我的问题是它们之间有什么区别 …

我一直在经历Head First Design Patterns(最近刚刚进入)并且我正在阅读关于策略模式的内容,我想到它可能是一种很好的方式来实现计算税收等的常用方法.我在工作中使用的特定对象,但我有一个问题.

这就是我的想法:

public interface ITax
{
    decimal ProvincialTaxRate { get; set; } // Yes, I'm Canadian :)
    decimal CalculateTax(decimal subtotal);
}

public SaskatchewanTax
{
    public decimal ProvincialTaxRate { get; set; }

    public SaskatchewanTax()
    {
        ProvincialTaxRate = new decimal(0.05f);
    }

    public decimal CalculateTax(subtotal)
    {
        return ProvincialTaxRate * subtotal + FederalTaxRate * subtotal;
    }
}

public OntarioTax
{
    public decimal ProvincialTaxRate { get; set; }

    public OntarioTax()
    {
        ProvincialTaxRate = new decimal(0.08f);
    }

    public decimal CalculateTax(decimal subtotal)
    {
        return …