为什么我的对象仍然使用一个方法，即使我已经覆盖了它？

Question

可能重复：Why my Virtual method is not overriden?

我一直在研究 Head First 设计模式。顺便说一句，我开始这本书是作为 Code Complete 2 的先决条件。无论如何，我正在使用装饰器模式 (the chapter can actually even be read online).

所以，我有 4 个课程：

1. 饮料类 - 摘要
2. Espresso 类 - 继承饮料
3. BeverageDecorator 类 - 抽象
4. 摩卡类-继承饮料装饰

这是 1、3、4 类的源代码。

饮料类：

    public abstract class Beverage
{
    public Beverage()
    {
        Description = "Unknown Beverage";
    }

    public String getDescription()
    {
        return Description;
    }

    public abstract double cost();

    public String Description { get; set; }

}

BeverageDecorator 类：

    public abstract class BeverageDecorator : Beverage
{
    public new abstract String getDescription();
}

摩卡类：

    public class Mocha : BeverageDecorator
{
    Beverage beverage;

    public Mocha(Beverage beverage)
    {
        this.beverage = beverage;
    }

    public override string getDescription()
    {
        return beverage.Description + ", Mocha";
    }

    public override double cost()
    {
        return beverage.cost() + .20;
    }
}

所以他们非常直截了当。然后，当我将此代码放入 Main() 方法时，我不断收到“未知饮料”的描述。

        static void Main(string[] args)
    {

        Beverage beverage = new Espresso();
        beverage = new Mocha(beverage);
        Console.WriteLine(beverage.Description +
            " $" + beverage.cost());

        Console.Read();

    }

Mocha 从它继承的类 - Beverage Decorator - 到上面的类 - Beverage Class。即使我在 Beverage Decorator 中有方法并且我覆盖了它。为什么会这样？我知道这与抽象类有关，但我似乎无法弄清楚。

Answer 1

你没有真正覆盖它。您已使用 new 运算符隐藏其下方的成员。该运算符的一个问题是，如果调用者使用对包含稍后隐藏的成员的类型的引用，它会绕过隐藏。在您的情况下，当您使用 Beverage 并期望看到被覆盖的结果时：

Beverage beverage = new Espresso();        
beverage = new Mocha(beverage);        
Console.WriteLine(beverage.Description + " $" + beverage.cost());

要覆盖某些内容，该内容需要为virtual 或abstract，并且覆盖成员需要使用override。你的成员不是抽象的或虚拟的，在你的派生类中你有new string getDescription 而不是override string getdescription。

因此，当您与Beverage 交谈时，它会在您的代码中忽略BeverageDecorator 中所做的隐藏。

关于装饰器模式的更大讨论，装饰类不需要继承它所装饰的内容。通常是通过将装饰类作为构造参数来完成的。如果您需要装饰和一些多态性，请考虑结合使用接口：

interface ICommonStuff
{
    string getDescription();
}

public class Beverage : ICommonStuff { }

public class BeverageDecorator : ICommonStuff
{
    public BeverageDecorator(Beverage b) { }
}

但是，你真的需要装饰吗？这是我在假期经常问的问题......

Answer 2

嗯，有两个问题。首先，看起来您的 Description 属性应该调用 getDescription 而不是相反。然后getDescription 需要在Beverage 类中是虚拟的，并且在BeverageDecorator 中覆盖 而不是隐藏。

您的代码看起来像是 C# 和 Java 的混合体，这无济于事。例如，您真的需要 Description 属性和 getDescription 方法吗？诚然，重写半个属性有点棘手（至少，我总是对确切的规则感到困惑），但在 C# 代码中使用驼峰式命名是绝对奇怪的。

这是一个替代实现（没有装饰器类 - 不清楚它是如何提供帮助的）：

using System;

public abstract class Beverage
{
    public Beverage()
    {
        Description = "Unknown Beverage";
    }

    private string description;

    public virtual string Description
    {
        get { return description; }
        set { description = value; }
    }
}

public class Espresso : Beverage
{
    public Espresso()
    {
        Description = "Espresso";
    }
}

public class Mocha : Beverage
{
    private readonly Beverage beverage;

    public Mocha(Beverage beverage)
    {
        this.beverage = beverage;
    }

    public override string Description
    {
        get { return beverage.Description + ", Mocha"; }
        set { /* Ignored */ }
    }
}

public class Test
{
    static void Main()
    {
        Beverage espresso = new Espresso();
        Beverage mocha = new Mocha(espresso);
        Console.WriteLine(mocha.Description); // Prints Espresso, Mocha
    }
}

Answer 3

public new abstract String getDescription();

这不是方法覆盖，它是与基类中的getDescription 方法无关的新方法。

Beverage.getDescription 不能被覆盖，因为它不是虚拟的。改为这样声明：

public abstract String getDescription();

或类似：

public virtual String getDescription()
{
    return Description;
}