Was ist Polymorphie?

In Python gibt len("hello") den Wert 5 zurück, len([4, 8, 15]) den Wert 3 und len({"a": 1}) den Wert 1. Es ist ein Funktionsname für drei Typen, und jeder Typ zählt auf seine Weise: Ein String zählt Zeichen, eine Liste Elemente, ein Dictionary Schlüssel. Das Wort kommt aus dem Griechischen: poly, viele, und morph, Form. Ein Aufruf, viele Formen von Verhalten.

Wie Polymorphie funktioniert

Code ruft eine Methode über ihren Namen auf, etwa shape.area(). Wenn diese Zeile läuft, sieht sich die Sprache das tatsächliche Objekt an und findet area in der Klasse dieses Objekts. Diese Suche heißt dynamische Bindung (Dynamic Dispatch), und sie ist der Grund, warum eine Zeile für verschiedene Objekte verschiedene Arbeit erledigen kann:

import math

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return math.pi * self.r ** 2

class Square(Shape):
    def __init__(self, side):
        self.side = side
    def area(self):
        return self.side ** 2

shapes = [Circle(1), Square(3), Circle(2)]
for shape in shapes:
    # One line of code, a different area() for each type
    print(type(shape).__name__, round(shape.area(), 2))

Circle 3.14
Square 9
Circle 12.57

Python findet die Methode, indem es zuerst die Klasse des Objekts durchsucht und dann ihre Elternklassen in einer festen Reihenfolge, der Method Resolution Order. Hätte Square kein eigenes area(), würde die Suche bei Shape.area() landen und NotImplementedError werfen, ein Signal, dass jede Unterklasse eine eigene Methode liefern muss.

Die Schleife prüft nie, welche Art Form sie gerade hat. Um ein Dreieck hinzuzufügen, schreibst du eine Klasse Triangle mit ihrem eigenen area(), und die Schleife funktioniert unverändert. Ohne Polymorphie bräuchte die Schleife für jede Form einen if isinstance(...)-Zweig, der bei jeder neuen Form angepasst werden müsste.

Arten von Polymorphie

Wer in der objektorientierten Programmierung ohne weitere Angaben von "Polymorphie" spricht, meint fast immer die erste Zeile: Subtyp-Polymorphie durch Überschreiben.

Python hat alle drei auf seine eigene Art. Überschreiben funktioniert wie im Beispiel mit den Formen. Operatoren wie + sind Ad-hoc-Polymorphie. Funktionen wie max() und sorted() sind dem Geist nach parametrisch: Sie akzeptieren eine Liste von Zahlen, Strings oder Datumswerten, solange sich die Elemente vergleichen lassen, und Type Hints wie list[int] oder eine TypeVar können das ausdrücklich festhalten.

Polymorphie zur Kompilierzeit und zur Laufzeit in Java

Java hat beide Arten, und in Vorstellungsgesprächen wird oft nach dem Unterschied gefragt:

class Animal { String sound() { return "..."; } }
class Dog extends Animal {
    @Override String sound() { return "Woof"; }
}

Animal pet = new Dog();
pet.sound();          // "Woof": chosen at run time from the object

int add(int a, int b)          { return a + b; }
double add(double a, double b) { return a + b; }
add(2, 3);            // int version, chosen by the compiler
add(2.5, 1.0);        // double version

Die Variable pet hat den Typ Animal, trotzdem läuft die Version von Dog, weil die Wahl vom Objekt abhängt, nicht von der Variablen. Die beiden add-Methoden sind Überladung: Der Compiler wählt eine anhand der Argumenttypen aus, bevor das Programm läuft. Interfaces liefern dasselbe Laufzeitverhalten, ohne Code zu teilen: Jede Klasse, die Comparable implementiert, lässt sich mit Collections.sort sortieren. C++ funktioniert genauso, mit einem Unterschied: Eine Methode bekommt nur dann dynamische Bindung, wenn sie als virtual deklariert ist. Siehe Polymorphie in Java, Überladen von Methoden und virtuelle Funktionen in C++.

Polymorphie in Python: Duck Typing und Operatoren

Python verlangt keine gemeinsame Elternklasse. Hat ein Objekt die Methode, die der Code aufruft, funktioniert es: "Wenn es läuft wie eine Ente und quakt wie eine Ente, ist es eine Ente". Auch Operatoren sind polymorph. a + b ruft a.__add__(b) auf, also können deine eigenen Klassen +, len() und print() unterstützen:

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __add__(self, other):          # called for v1 + v2
        return Vector(self.x + other.x, self.y + other.y)
    def __len__(self):                 # called for len(v)
        return 2
    def __repr__(self):                # called by print()
        return f"Vector({self.x}, {self.y})"

print(1 + 2, "ab" + "cd", [1] + [2])   # built-in types
print(Vector(1, 2) + Vector(10, 20))    # your own type
print(len("hello"), len([1, 2, 3]), len(Vector(0, 0)))

3 abcd [1, 2]
Vector(11, 22)
5 3 2

Vererbung ist ein Weg zur Polymorphie, keine Voraussetzung. Vector erbt von nichts Besonderem, und trotzdem behandeln len() und + die Klasse wie einen eingebauten Typ. Die Doku zur Vererbung in Python zeigt den Weg über Unterklassen.

Häufige Fehler

Erwarten, dass Python nach Signatur überlädt. Ein zweites def mit demselben Namen ersetzt das erste stillschweigend:

def greet(name):
    return "Hi " + name

def greet(first, last):          # replaces the first greet
    return "Hi " + first + " " + last

print(greet("Ana", "Silva"))
print(greet("Ana"))

Hi Ana Silva
Traceback (most recent call last):
  ...
TypeError: greet() missing 1 required positional argument: 'last'

Verwende stattdessen ein Standardargument: def greet(first, last="").

virtual in C++ vergessen. Ohne das Schlüsselwort führt ein Methodenaufruf über einen Zeiger auf die Basisklasse die Version der Basisklasse aus, selbst wenn das Objekt eine Unterklasse ist.

Überschreibungen, die die Bedeutung ändern. Gibt area() in einer Unterklasse den Umfang zurück, geht jeder Aufrufer kaputt, der sich auf area() verlässt. Eine Überschreibung muss das Versprechen der Elternklasse halten; diese Regel heißt Liskovsches Substitutionsprinzip.

Typprüfungen überall. Eine Kette von if type(x) == ...-Zweigen ist meist ein Zeichen, dass jeder Typ stattdessen seine eigene Methode mitbringen sollte.

Wie es weitergeht

Polymorphie arbeitet mit Kapselung zusammen, die die Daten jedes Objekts schützt, und mit Abstraktion, die die gemeinsame Schnittstelle festlegt, die die Typen umsetzen. Üb das Überschreiben mit der Doku zu Python-Klassen, oder probier den Java-Kurs, in dem Überladen und Überschreiben nebeneinander vorkommen.