多态性简单来说就是“多种形式”。

它不需要继承来实现…作为接口实现，它根本不是继承，服务于多态需求。可以说，接口实现比继承更能满足多态需求。

例如，你会创建一个超类来描述所有会飞的东西吗?我不这么认为。你最好创建一个描述飞行的界面，然后就这样吧。

因此，由于接口描述行为，而方法名描述行为(对程序员来说)，将方法重载视为一种较小形式的多态性并不过分。

表达多态性最清晰的方法是通过抽象基类(或接口)

public abstract class Human{
   ...
   public abstract void goPee();
}

这个类是抽象的，因为goPee()方法对人类是不可定义的。它只对子类Male和Female可定义。此外，人是一个抽象的概念——你不能创造一个既不是男性也不是女性的人。一定是两者之一。

因此，我们通过使用抽象类来延迟实现。

public class Male extends Human{
...
    @Override
    public void goPee(){
        System.out.println("Stand Up");
    }
}

and

public class Female extends Human{
...
    @Override
    public void goPee(){
        System.out.println("Sit Down");
    }
}

现在我们可以让一屋子的人去尿尿了。

public static void main(String[] args){
    ArrayList<Human> group = new ArrayList<Human>();
    group.add(new Male());
    group.add(new Female());
    // ... add more...

    // tell the class to take a pee break
    for (Human person : group) person.goPee();
}

运行该命令会得到:

Stand Up
Sit Down
...

下面是伪c# /Java中的多态性示例:

class Animal
{
    abstract string MakeNoise ();
}

class Cat : Animal {
    string MakeNoise () {
        return "Meow";
    }
}

class Dog : Animal {
    string MakeNoise () {
        return "Bark";
    }
}

Main () {
   Animal animal = Zoo.GetAnimal ();
   Console.WriteLine (animal.MakeNoise ());
}

Main函数不知道动物的类型，并且依赖于MakeNoise()方法的特定实现的行为。

编辑:看来布莱恩先我一步了。有趣的是我们用了同样的例子。但是上面的代码应该有助于阐明概念。

具体地说重载或重写并没有给出全貌。多态性就是对象根据其类型专门化其行为的能力。

我不同意这里的一些答案，因为重载是一种多态形式(参数多态)，在这种情况下，具有相同名称的方法可以具有不同的行为，给出不同的参数类型。一个很好的例子是操作符重载。您可以定义“+”来接受不同类型的参数——例如字符串或int型——并且基于这些类型，“+”将具有不同的行为。

多态性还包括继承和重写方法，尽管它们在基类型中可以是抽象的或虚拟的。在基于继承的多态性方面，Java只支持单个类继承，将其多态行为限制为单个基类型链。Java支持多个接口的实现，这是另一种形式的多态行为。

重写和重载都用于实现多态性。

你可以在一个类中有一个方法 它在或中被覆盖 更多的子类。这个方法可以 不同的东西取决于哪个 类用于实例化对象。

    abstract class Beverage {
       boolean isAcceptableTemperature();
    }

    class Coffee extends Beverage {
       boolean isAcceptableTemperature() { 
           return temperature > 70;
       }
    }

    class Wine extends Beverage {
       boolean isAcceptableTemperature() { 
           return temperature < 10;
       }
    }

你也可以有一种方法 用两组或多组参数重载。这个方法可以 不同的东西基于 传递的参数类型。

    class Server {
        public void pour (Coffee liquid) {
            new Cup().fillToTopWith(liquid);
        }

        public void pour (Wine liquid) {
            new WineGlass().fillHalfwayWith(liquid);
        }

        public void pour (Lemonade liquid, boolean ice) {
            Glass glass = new Glass();
            if (ice) {
                glass.fillToTopWith(new Ice());
            }
            glass.fillToTopWith(liquid);
        }
    }

重写更像是通过声明一个与上层方法(超级方法)具有相同名称和签名的方法来隐藏一个继承的方法，这为类添加了多态行为。 换句话说，选择要调用的级别方法的决定将在运行时而不是在编译时做出。 这就引出了接口和实现的概念。