如何将多态对象作为派生对象传递？

Question

为了简单起见，我有两个类：ActionTaken和MovementTaken. MovementTaken是一个派生类ActionTaken。我有一个Queue完整的动作，每个动作都有一个char决定动作类型的。（每个动作都有一个正确的类型）我想将 的元素传递Queue给一个函数，该函数专门与一个MovementTaken参数一起工作，但是由于我使用多态性，所以参数是 type ActionTaken，但是我不能使用来自 的成员变量MovementTaken，但是不要不存在于ActionTaken. 但是如果我将 functionactivateMovement的参数设置为 type MovementTaken，我相信会有一个错误，说你不能将基类型转换为派生类型。这是代码：public abstract class ActionTaken : MonoBehaviour{    public char type;    public Transform minionTakingAction;}public class MovementTaken : ActionTaken{    public int targetTileH;    public int targetTileV;    public MovementTaken(Transform _minionTakingAction, int _targetTileH, int _targetTileV)    {        type = 'M';        minionTakingAction = _minionTakingAction;        targetTileH = _targetTileH;        targetTileV = _targetTileV;    }}Queue<ActionTaken> actionTaken;public void activateMovement(ActionTaken toActivate){//some code using toActivate's members targetTileH and targetTileV}

Answer 1

如果您知道传递给该方法的参数是一个MovementTaken实例，则可以将其向下转换：

public void activateMovement(ActionTaken toActivate)

{

    MovementTaken casted = toActivate as MovementTaken;

    // Do something with casted.targetTileH and/or caster.targetTileV

Answer 2

Abstract类的优点是定义基本实现，或强制派生类型进入实现细节：

public abstract class ActionTaken : MonoBehaviour

{

    public char Type { get; protected set; }

    public Transform Target { get; }

    // base ctor

    protected ActionTaken(Transform target)

    {

        Type = '\0'; 

        Target = target;

    }

    // Force implementation onto sub class

    public abstract void Activate();

}

public class MovementTaken : ActionTaken

{

    public int TileH { get; set; }

    public int TileV { get; set; }

    public MovementTaken(Transform target, int tileH, int tileV)

        : base(target)

    {

        Type = 'M';

        TileH = tileH;

        TileV = tileV;

    }

    public override void Activate()

    {

        //some code using TileH and TileV

    }

}

因此，您的调用代码将是：

Queue<ActionTaken> actionTaken;

public void activateMovement(ActionTaken action)

{

    action.Activate();

}

我也不确定Type它的用途，但如果你仍然需要它，最好在每个类中定义一个常量，ActionTaken如果你有更多的话。

如果你最终Queue<ActionTaken>用各种派生的运动类型填充你的，这可能是有意义的。否则，您的ActivateMovement方法可能最终会成为一个冗长的switch声明。

接口在这里也可能是有利的：

public interface IActionTaken

{

    Transform Target { get; }

    void Activate();

}

然后您将替换您的队列： Queue<IActionTaken> Actions

调用队列中所有动作的代码可以非常简单：

while(Actions.Count > 0)

{

    IActionTaken current = Actions.Dequeue();

    current.Activate();

}