Qu'est-ce que le polymorphisme ?

En Python, len("hello") renvoie 5, len([4, 8, 15]) renvoie 3, et len({"a": 1}) renvoie 1. C'est un seul nom de fonction utilisé sur trois types, et chaque type compte à sa façon : une chaîne compte ses caractères, une liste ses éléments, un dictionnaire ses clés. Le mot vient du grec : poly, plusieurs, et morphê, forme. Un seul appel, plusieurs formes de comportement.

Comment fonctionne le polymorphisme

Le code appelle une méthode par son nom, comme shape.area(). Quand cette ligne s'exécute, le langage regarde l'objet réel et cherche area dans la classe propre de cet objet. Cette recherche s'appelle la liaison dynamique (dynamic dispatch), et c'est elle qui permet à une seule ligne de faire un travail différent pour des objets différents :

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 trouve la méthode en cherchant d'abord dans la classe de l'objet, puis dans ses classes parentes selon un ordre fixe appelé ordre de résolution des méthodes (method resolution order). Si Square n'avait pas son propre area(), la recherche atteindrait Shape.area() et lèverait NotImplementedError, un signal que chaque sous-classe doit en fournir un.

La boucle ne vérifie jamais quel genre de forme elle contient. Pour ajouter un triangle, tu écris une classe Triangle avec son propre area(), et la boucle fonctionne sans changement. Sans polymorphisme, la boucle aurait besoin d'une branche if isinstance(...) pour chaque forme, à modifier chaque fois qu'une nouvelle apparaît.

Les types de polymorphisme

Quand on parle de « polymorphisme » en programmation orientée objet sans plus de précision, on veut presque toujours dire la première ligne : le polymorphisme par sous-typage, via la redéfinition.

Python a les trois à sa manière. La redéfinition fonctionne comme dans l'exemple des formes. Les opérateurs comme + relèvent du polymorphisme ad hoc. Des fonctions comme max() et sorted() sont paramétriques dans l'esprit : elles acceptent une liste de nombres, de chaînes ou de dates, tant que les éléments peuvent être comparés, et des annotations de type comme list[int] ou un TypeVar peuvent l'indiquer explicitement.

Polymorphisme statique et dynamique en Java

Java a les deux sortes, et les questions d'entretien portent souvent sur la différence :

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

La variable pet a le type Animal, et pourtant c'est la version de Dog qui s'exécute, car le choix dépend de l'objet, pas de la variable. Les deux méthodes add relèvent de la surcharge : le compilateur en choisit une d'après les types des arguments, avant que le programme ne s'exécute. Les interfaces donnent le même comportement à l'exécution sans partager de code : toute classe qui implémente Comparable peut être triée par Collections.sort. Le C++ fonctionne de la même façon, à une différence près : une méthode n'a de liaison dynamique que si elle est déclarée virtual. Voir le polymorphisme en Java, la surcharge de méthodes et les fonctions virtuelles en C++.

Le polymorphisme en Python : duck typing et opérateurs

Python n'exige pas de classe parente commune. Si un objet a la méthode que le code appelle, ça marche : « si ça marche comme un canard et que ça cancane comme un canard, c'est un canard ». Les opérateurs sont eux aussi polymorphes. Écrire a + b appelle a.__add__(b), donc tes propres classes peuvent prendre en charge +, len() et print() :

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

L'héritage est un moyen d'obtenir du polymorphisme, pas une obligation. Vector n'hérite de rien de particulier, et pourtant len() et + le traitent comme un type intégré. La documentation Python sur l'héritage montre la voie des sous-classes.

Erreurs fréquentes

Croire que Python surcharge selon la signature. Un second def avec le même nom remplace le premier sans rien dire :

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'

Utilise plutôt un argument par défaut : def greet(first, last="").

Oublier virtual en C++. Sans lui, appeler une méthode via un pointeur vers la classe de base exécute la version de base, même quand l'objet est une sous-classe.

Des redéfinitions qui changent le sens. Si area() renvoie le périmètre dans une sous-classe, chaque appelant qui fait confiance à area() se retrouve cassé. Une redéfinition doit tenir la promesse faite par le parent ; cette règle s'appelle le principe de substitution de Liskov.

Des vérifications de type partout. Une chaîne de branches if type(x) == ... est généralement le signe que chaque type devrait plutôt porter sa propre méthode.

Pour aller plus loin

Le polymorphisme fonctionne avec l'encapsulation, qui protège les données de chaque objet, et l'abstraction, qui définit l'interface commune que les types implémentent. Entraîne-toi à la redéfinition avec la documentation Python sur les classes, ou essaie le cours Java, où surcharge et redéfinition apparaissent côte à côte.