Question

任何人都可以解释什么是重载，覆盖和隐藏.Net？

由于

Answer 1

重载是单个方法或运算符的多个可能“签名”的定义。每个签名都采用不同的参数，并且本质上是一个独特的函数，与多个函数具有不同的名称没有区别。这通常用于对概念上类似的操作进行分组，例如重载+以使用BigInteger和String：这两个操作似乎都合理使用+（除非您认为+的所有重载应该定义Abelian groups - String重载不会。）

覆盖是相同方法签名的多个可能实现的定义，因此实现由第0个参数的运行时类型决定（通常由在C＃中命名this。

隐藏是派生类型中方法的定义，其签名与其中一个基本类型的签名相同，但覆盖。

覆盖和隐藏之间的实际区别如下：

如果某个方法被重写，则要调用的实现基于参数this的运行时类型。
如果方法只是隐藏，则要调用的实现基于参数this的编译时类型。

Answer 2

重载提供了多个具有相同名称和不同签名的方法：

void Foo() {...}
void Foo(int i) {...}

在继承中使用重写来更改每个子类的实现：

class SomeBase {
    public virtual void Foo() {}
}
class SomeOther : SomeBase {
    public override void Foo() {
        // different implementation, possibly calling base.Foo();
    }
}

有了上述内容，即使我这样做：

SomeBase obj = new SomeOther();
obj.Foo();

它将调用SomeOther.Foo实现。调用的方法取决于实例类型，而不是变量。

方法隐藏是相反的;它替换方法签名，但仅在从派生类型调用方法时才适用：

class SomeBase {
    public void Foo() {}
}
class SomeOther : SomeBase {
    public new void Foo() {
        // different implementation, possibly calling base.Foo();
    }
}

现在：

SomeOther obj = new SomeOther();
SomeBase baseObj = obj;
obj.Foo(); // calls SomeOther.Foo
baseObj.Foo(); // calls SomeBase.Foo

即。方法调用取决于变量，而不是实例。

Answer 3

重载是指使用不同参数创建多个方法时。例如：

public class Car
{
  public Car()
  {
    // Do stuff
  }

  public Car(int numberOfCylinders)
  {
    // Do stuff
  }
}

您可以看到构造函数具有相同的名称，但参数不同。您将在Intellisense中的Visual Studio中看到重载的方法和构造函数，上面和下方都有小箭头，因此您可以浏览签名。

覆盖是指从基类向方法提供新实现的时候。例如：

   public class Square 
   {
      public double x;

      // Constructor:
      public Square(double x) 
      {
         this.x = x;
      }

      public virtual double Area() 
      {
         return x*x; 
      }
   }

   class Cube: Square 
   {
      // Constructor:
      public Cube(double x): base(x) 
      {
      }

      // Calling the Area base method:
      public override double Area() 
      {
         return (6*(base.Area())); 
      }
   }

请注意，在C＃中，您不能override非虚拟或静态方法。

Answer 4

假设您理解其他海报给出的解释，记住重载和覆盖之间差异的一种方法是，当使用加载时，可能存在“加载'具有相同名称的函数。

傻，我知道，但它适用于我。

Answer 5

简单来说：

重载是指具有不同签名的相同方法名称。这可以在同一个班级。例如：

int Add (int a, int b)
{
  return a + b; // returns int
}
float Add (float a, float b)
{
return a + b; // returns float
}

覆盖是指在派生类中具有与基类中相同的方法名称和签名。在这种情况下，我们说派生类会覆盖基类方法。运行哪种方法取决于哪个实例调用方法

e.g。

public class Shape
    {
        public virtual void Draw() { }

    }

    public class Square : Shape
    {
        public override void Draw()
        {
            // Code to draw square
        }
    }

    public class Circle : Shape
    {
        public override void Draw()
        {
            // Code to draw circle
        }
    }

隐藏或封装是指声明成员变量和类私有方法，以便任何其他类都无法访问它们，甚至是派生类

E.g。

private int onlyICanAccess;

private void OnlyICanExecute()
{
  // ...
}

Answer 6

重载是多形态的一个例子，你可以在两个方法之间传递overloa数，数据类型和参数序列。

覆盖（与虚拟不同）意味着存在一些已定义的功能，但您可以在继承时提供更清晰的想法

隐藏意味着隐藏内部功能并代表基本功能，这是OOP概念的一个特性

GOOGLe获取信息

超载，覆盖和隐藏？

6 个答案: