在子类的覆盖函数中使用子接口

Question

尊敬的 OOP 专家您好，

如果之前有人问过这个问题，我很抱歉，我还没有找到任何类似的问题（我可能没有合适的词来解释）。

为了制作一个灵活的系统，我尝试使用Interfaces 和Abstract 类。涉及的实体非常简单：

public interface IAbilityTarget
{
    // A bunch of properties and functions
}

public interface IDamagable : IAbilityTarget
{
    int Life { get; set; }
}

public abstract class Ability
{
    public abstract bool CanBeUsed( IAbilityTarget[] targets );
    public abstract void Use( IAbilityTarget[] targets );
}    

public class Fireball : Ability
{
    public override bool CanBeUsed( IDamagable[] targets )
    {
        return true ; // for the sake of the example
    }

    public override void Use( IDamagable[] targets )
    {
        for( int index = 0 ; index < targets.Length ; ++index )
            targets[index].Life -= 1 ;
    }
}

我的问题如下：为什么我有CS0115 错误？

错误 CS0115：`Fireball.CanBeUsed(IDamagable[])' 被标记为覆盖，但找不到合适的覆盖方法

由于IDamagable 扩展了IAbilityTarget，我不明白为什么会出现错误。我不想在Fireball 中实现以下内容以避免错误：

public override bool CanBeUsed( IAbilityTarget[] targets )
{
    return true;
}
public bool CanBeUsed( IDamagable[] targets )
{
    return CanBeUsed( (IAbilityTarget[]) targets );
}

为了避免错误，我必须进行哪些更改，而不必为每个子接口重载CanBeUsed。

Answer 1

你是 Fireball 违反了里氏替换原则。

因为引用了Ability 的客户端可以将IAbilityTarget 的数组传递给它的每个方法。

但如果该引用的底层（运行时）类型确实是Fireball，则传递给方法的那些对象必须实现IDamagable，这是一个更严格的要求。 IE。如果不改变调用方法的方式，就不能用 Fireball 替换 Ability。

通常，覆盖必须less严格遵守它们需要的前置条件（不使用类型，而是使用传递对象的任何状态）。你的限制越来越了。

Answer 2

由于 IDamagable 扩展了 IAbilityTarget，我不明白为什么会出现错误。

如果Fireball 中的Use 方法确实覆盖了Ability 中的Use 方法，则会出现不一致的情况。

class MyDummyTarget : IAbilityTarget { ... }

...

Ability myAbility = new Fireball();
myAbility.Use(new IAbilityTarget[] { new MyDummyTarget() });

从编译器的角度来看，这应该可以工作：myAbility.Use 需要一个 IAbilityTarget[]，这是你给它的。但是，由于覆盖，myAbility.Use 调用了在Fireball 中定义的方法，该方法接受IDamagable[]。现在，如何将数组中的MyDummyTarget 对象转换为IDamagable？没办法。

您需要更改参数类型，以使两种方法的参数类型相同。要么让他们都接受IAbilityTarget[] 或IDamagable[]。我认为前者可能更有意义。

来自您的其他评论：

当然，但是在 Fireball::Use() 函数中，我想减少生命，但是这个属性只在 IDamageable 接口中定义！

你可以这样做：

public override void Use( IAbilityTarget[] targets )
{
    for( int index = 0 ; index < targets.Length ; ++index ) {
        if (targets[index] is IDamagable) {
            ((IDamagable)targets[index]).Life -= 1 ;
        }
    }
}

如果您想要更安全的方法，

public abstract class Ability<T> where T : IAbilityTarget
{
    public abstract bool CanBeUsed( T[] targets );
    public abstract void Use( T[] targets );
}    

public class Fireball : Ability<IDamagable>
{
    public override bool CanBeUsed( IDamagable[] targets )
    {
        return true ; // for the sake of the example
    }

    public override void Use( IDamagable[] targets )
    {
        for( int index = 0 ; index < targets.Length ; ++index )
            targets[index].Life -= 1 ;
    }
}

但这会阻止您将Ability<IAbilityTarget> 转换为Ability<IDamagable>。

有时你只需要接受类型系统的限制。