Question

我是新手，并试图理解继承和设计模式的概念。

当我浏览一些博客时，我遇到了这种模式http://en.wikipedia.org/wiki/Strategy_pattern。

我发现它很有趣，想要了解更多。所以我开发了以下程序。

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

    Console.Read();
}      

abstract class Strategy
{
    public abstract int execute(int a, int b);

    public void Test()
    {
        Console.Write("tttt");
    }
}

class ConcreteStrategyAdd : Strategy
{
    public override int execute(int a, int b)
    {
        Console.WriteLine("Called ConcreteStrategyAdd's execute()");
        return a + b;  // Do an addition with a and b
    }
}

class ConcreteStrategySubtract : Strategy
{

    public override int execute(int a, int b)
    {
        Console.WriteLine("Called ConcreteStrategySubtract's execute()");
        return a - b;  // Do a subtraction with a and b
    }
}

class ConcreteStrategyMultiply : Strategy
{
    public override int execute(int a, int b)
    {
        Console.WriteLine("Called ConcreteStrategyMultiply's execute()");
        return a * b;   // Do a multiplication with a and b
    }
}

class Context
{
    private Strategy strategy;

    // Constructor
    public Context(Strategy strategy)
    {
        this.strategy = strategy;
    }

    public int executeStrategy(int a, int b)
    {
        return strategy.execute(a, b);
    }
}

该程序编译正常并正在运行。但我的问题是，当Context构造函数期望基类作为参数时，如何将派生类作为参数传递？铸造是否隐含发生？为什么编译器没有错误？

context = new Context(new ConcreteStrategyAdd());  

public Context(Strategy strategy)
{
    this.strategy = strategy;
}

Answer 1

简单地说：

派生类（或子类）是其基类的实例。

因此，当您将ConcreteStrategyAdd的实例传递给构造函数时，您实际上是在传递Strategy个对象。

没有涉及铸造。类型层次结构允许这种类型的编程。它允许程序员在代码中使用polymorphism。

Answer 2

由于ConcreteStrategyAdd 是策略，因此不需要任何转换 - 它满足了作为策略的所有要求。这是多态性的原理。

也许需要一个更简单的例子：

abstract class Fruit { }

class Apple : Fruit { }
class Orange : Fruit { }
class Melon : Fruit { }

class FruitBasket
{
    void Add(Fruit item) { ... }
}

FruitBasket basket = new FruitBasket();
basket.Add(new Apple()); // Apple IS A fruit
basket.Add(new Orange()); // Orange IS A fruit
basket.Add(new Melon()); // Melon IS A fruit

class Potato : Vegetable { }

basket.Add(new Potato()); // ERROR! Potato IS NOT A fruit.

Answer 3

派生类是基类。（这是继承的整个概念：继承定义了'是'关系）。

另外，请查看Liskov substitution principle。：）

Answer 4

如果您使用比策略模式更简单的示例，则更容易理解。

假设您有一个名为“Fruit”的类和一个名为“Apple”的类，它来自水果。任何编写为与Fruit一起使用的方法一般可以与Apple或任何其他特定类型的水果一起使用

当参数类型是基类时，将Derived类作为参数传递给方法

4 个答案: