为什么维基百科说“多态性与方法重载或方法重写不同。”

Question

我环顾四周，找不到任何类似的问题。

这是我从 Wikipedia 得到的段落：

多态性是不一样的作为方法重载或方法覆盖。多态性只涉及接口或更通用基类的特定实现的应用。方法重载是指同一个类中具有相同名称但不同签名的方法。方法重写是指子类替换其父类的一个或多个方法的实现。方法重载和方法重写本身都不是多态性的实现。

这里有人可以更清楚地解释一下吗，特别是“多态性与方法重写不同”部分？我现在很困惑。提前致谢。

Answer 1

多态性（非常简单地说）是在需要基类的情况下使用派生类的可能性：

class Base {

}

class Derived extends Base  {

}

Base v = new Derived(); // OK

另一方面，方法重写是 Wiki 所说的一种更改派生类中方法行为的方法：

class Shape  {
  void draw() { /* Nothing here, could be abstract*/ }
}

class Square extends Shape  {
  @Override
  void draw() { /* Draw the square here */ }
}

重载与继承无关，它允许定义更多具有相同名称的函数，这些函数仅在它们所采用的参数上有所不同。

Answer 2

您可以在不允许方法重写（甚至继承）的语言中拥有多态性。例如，让几个不同的对象实现相同的接口。多态性只是意味着同一个抽象接口可以有不同的具体实现。有些语言不鼓励或不允许继承，但本着抽象编程的精神允许这种多态性。

理论上，您还可以在不允许虚拟方法分派的语言中进行方法重写，而无需多态性。其效果是，您可以创建一个具有重写方法的新类，但无法使用它来代替父类。我不知道有任何主流语言可以做到这一点。

Answer 3

多态性并不是方法被覆盖；而是方法被覆盖。它是关于确定特定流程的实现的对象。一个简单的例子 - 但绝不是唯一的例子 - 是继承：

小说是书籍的一种类型。它具有大部分相同的方法，并且您可以对书籍进行的所有操作也可以对小说进行。因此，任何接受 Book 作为参数的方法也可以处理 Novel 作为参数。 （示例包括 .read()、.write()、.burn()）。这本身并不是指小说可以覆盖 Book 方法的事实。相反，它指的是抽象的一个特征。如果教授指定要阅读一本书，他/她并不关心你如何阅读它 - 只要你关心。同样，调用程序并不关心 Book 类型的对象如何被读取，只关心它本身就是这样。如果对象是小说，它将被作为小说阅读。如果它不是小说但仍然是一本书，那么它将被当作一本书来阅读。

书籍：

private void read(){

#Read the book.
}

小说：

private void read(){

#Read a book, and complain about how long it is, because it's a novel!

}

重载方法只是指具有相同名称但参数数量不同的两个方法。例子：

writeNovel(int numPages, String name)

writeNovel(String name)

Answer 4

重载是在同一个类中具有许多名称相同但参数不同的方法。

重写是在继承类中具有与基类相同的方法+参数。因此，根据对象的类，将调用基方法或继承的方法。

多态性是指，当作为参数给出时，继承类的实例可以替换基类的实例。

例如：

class Shape {
  public void draw() {
    //code here
  }
  public void draw(int size) {
    //this is overloading 
  }
}

class Square inherits Shape {
  public void draw() {
    //some other code : this is overriding
  }

  public void draw(color c) {
    //this is overloading too
  }
}

class Work {
  public myMethod(Shape s) {
    //using polymophism, you can give to this method
    //a Shape, but also a Square, because Square inherits Shape.
  }
}

看到了吗？
多态是指同一个对象可以用作其自己的类、其基类的实例，甚至可以用作接口。

Answer 5

多态性是指类型的实例可以像其任何超类型的任何实例一样对待。多态性意味着“多种形式”。

假设您有一个名为 Dog 的类型。然后您就有一个名为 Spaniel 的类型，它继承自 Dog。 Spaniel 的实例可以在任何使用 Dog 的地方使用 - 它可以像任何其他 Dog 实例一样对待。这就是多态性。

方法重写是子类可以对基类中的方法执行的操作。 Dog 可能包含 Bark 方法。 Spaniel 可以重写该方法以提供更具体的实现。重写方法不会影响多态性 - 事实上，您在 Spaniel 中重写了 Dog 方法并不能使您能够或阻止您像对待狗一样对待 Spaniel。

方法重载只是给不同的方法赋予不同的参数相同的名称。

我希望这有帮助。

Answer 6

坦率地说：

多态性是使用许多类型，这些类型在一个实现中具有特定的共同点，只需要共同的东西，而方法重载则使用一个 > 针对每种类型的实现。

Answer 7

当你重写一个方法时，你就改变了它的实现。多态性将使用您的实现或基本实现，具体取决于您的语言（是否支持虚拟方法？）以及您创建的类实例。

重载方法是另一回事，它意味着使用具有不同数量参数的相同方法。

这种（重写）的组合，加上使用基类或接口并仍然在链上某处调用重写方法的可能性，称为多态性。

例子：

interface IVehicle
{
    void Drive();
}

class Car : IVehicle
{
    public Drive() { /* drive a car */ }
}

class MotorBike : IVehicle
{
    public Drive() { /* drive a motorbike */ }
}

class Program
{
    public int Main()
    {
        var myCar = new Car();
        var myMotorBike = new MotorBike();
        this.DriveAVehicle(myCar);        // drive myCar
        this.DriveAVehicle(myMotorBike);  // drive a motobike
        this.DriveAVhehicle();            // drive a default car
    }

    // drive any vehicle that implements IVehicle
    // this is polymorphism in action
    public DriveAVehicle(IVehicle vehicle)
    {
       vehicle.Drive();
    }

    // overload, creates a default car and drives it
    // another part of OO, not directly related to polymorphism
    public DriveAVehicle()
    {
        // typically, overloads just perform shortcuts to the method
        // with the real implemenation, making it easier for users of the class
        this.DriveAVehicle(new Car());
    }
}