C# 覆盖可能性

Question

我正在编写一个程序，计算 2 维空间和 3 维空间中 2 点之间的距离。

我创建了两个类“2DPoint”和“3DPoint”。 3DPoint 继承自 2DPoint。

我在 2DPoint 中有一个“calculateDistance”方法，我想在 3DPoint 中覆盖它。

这是 2DPoint 中的代码：

 public virtual double calcDistance(int xco1, int xco2, int yco1, int yco2)
 {

        .....(some maths)


            return distance;
 }

现在我遇到的问题是在 3DPoint 中，我必须输入 X、Y，然后输入 2 个点的 Z 坐标，因此通过在 3DPoint 类中声明“覆盖”，它不会让我覆盖2D 点中的方法。

例如，

public override double calcDistance(int xco1, int xco2, int yco1, int yco2, int zco1, int zco2)
 {

        .....(some maths)


            return distance;
 }

所以我有 3 个问题：

1. 是否可以使用我编写代码的覆盖命令来覆盖 2DPoint calcDistance？
2. 如果没有，有没有办法使用覆盖命令解决我的问题？
3. 重载与覆盖相同吗，因为这是我能看到的唯一解决方法。

Answer 1

这是一个比较简单的误解。

• 重写是更改子类中例程行为的一种方法。重写的方法具有与原始方法相同的参数。
• 重载是指具有相同名称但参数不同的方法。编译器通过匹配参数来确定您的意思。

我看不到足够的代码来知道您的基本设计是否合理，但从表面上看，您似乎需要使用重载。

Answer 2

您不必重写 2 参数函数，只需创建一个具有 3 个参数的新函数即可。创建 3d 实例后，它将对调用源可见。通过使用 3 个参数的不同“签名”（或者甚至相同的参数数量，但类型不同），编译器将知道它应该调用哪个函数。例如：

public class Calc2d
{
   public virtual CalcDistance( int Parm1, int parm2 )
   { ... }
}

public class Calc3d : Calc2d
{
   public virtual CalcDistance( int Parm1, int parm2, int Parm3 )
   { ... }
}

在 3d 类中，CalcDistance 的两个实例都是可见的，但根据传递的参数数量来决定调用哪个实例。

Answer 3

首先，您不可能创建 2DPoint 和 3DPoint 类。接下来，我真的怀疑 3D 点是否应该继承 2D 点。

至于你的问题，

1. 重写要求参数相同（简单地说）
2. 不，这里没有什么可以重写的是
3. 的，重载与重写不同

Answer 4

您不应该让 3DPoint 成为 2DPoint 的子类，因为这不是 is-a 关系。 2D 点不是 3D 点的泛化，它们只是不同，不应该继承另一个点。

顺便说一句，我不明白你的方法签名 public virtual double calcDistance(int xco1, int xco2, int yco1, int yco2)。尽管它是一个实例方法，但它仍需要点的坐标，因此始终在特定点上执行。像 public virtual double calcDistance(2DPoint other) 这样的东西对我来说更有意义。

Answer 5

针对您的问题的更好设计并适当使用多态性将是创建 2D 点类，该类在构造函数中接受 4 个参数（Xs 和 Ys）。然后是一个 3D 点类，它接受 6 个参数（X、Y 和 Z）。

然后您将写入 2DPoint

public virtual double calcDistance() 

和 3DPoint

public override double calcDistance() 

Answer 6

1）您不能更改重写方法时采用的参数。如果您尝试这样做，您最终会在子类中得到两个可用的方法。

3) 重载是指您的方法采用不同的参数集，例如 Calc(int x) 和 Calc(int x, int y)。这与重写不同，因为重写会更改一个类中与其基类相比的行为。

您可以执行以下操作之一：

i) 让您的方法在接口上运行。点。检查 IPoint 的类型，如果它是 2DPoint 并且您期望是 3dPoint，则抛出异常。您可以添加泛型以使其成为强类型。这可能就是我会采取的方法。它确保您调用正确的方法，并且会在编译时而不是运行时抱怨。

interface IPoint<TPoint> where TPoint : IPoint
{
   Double CalcuateDistance(TPoint point);
}

public class 2DPoint : IPoint<2DPoint>
{
   public Double X { get; set; }
   public Double Y { get; set; }
   public Double CalculateDistance(2DPoint point)
   {
      // some maths using this.X/this.Y and point.X/point.Y
   }
}

public class 3DPoint : IPoint<3DPoint>
{
   public Double X { get; set; }
   public Double Y { get; set; }
   public Double Z { get; set; }

   public Double CalculateDistance(3DPoint point)
   {
      // some maths using this.X/this.Y/this.Z and point.X/point.Y/point.Z
   }
}

使用这种方法，如果您对两种类型的点具有通用功能，则可以将其放置在抽象基类中，而不是 AbstractPoint中。 ：IPoint。如果您这样做，您将定义：

abstract class AbstractPoint<TPoint> : IPoint<TPoint>
{
   public virtual double CalculateDistance(TPoint point);
}

当您在 2DPoint 和 3DPoint 中重写此设置时，您将自动传入正确类型的 TPoint :)

ii) 让您的基类方法采用 az，其默认值为 0为所有 2D 点传入 0。这与您的基础上有 2 个方法相同（一个接受 az，一个不接受，并在正确的时间调用正确的方法）

Calc(int x, int y, int z = 0);

iii) 删除继承并拥有 2 个单独的具体类。