B.4 Les interfaces : des contrats entre classes

1Situer

Une clinique de Casablanca a un logiciel qui gère des factures, des ordonnances et des rendez-vous. Ces trois choses n'ont rien en commun, et pourtant il faut toutes les imprimer, et certaines doivent être envoyées par e-mail. On ne peut pas leur donner une même classe mère « Document » qui aurait du sens. On leur donne plutôt des capacités : « imprimable », « envoyable ». Ce sont des interfaces.

2Comprendre

Les interfaces : des capacités qu'une classe s'engage à avoir

Deux interfaces décrivent des capacités : Imprimable exige imprimer(), Envoyable exige envoyer(email).

1 / 5

Une interface est un contrat : une liste de méthodes qu’une classe s’engage à fournir, sans aucun code. Elle décrit une capacité (« je sais m’imprimer ») plutôt qu’une famille.

Les interfaces en Python

Python n’a pas de mot-clé interface. On utilise une classe abstraite pure, qui ne contient que des méthodes abstraites :

class Imprimable(ABC):
    @abstractmethod
    def imprimer(self): ...

Une classe implémente l’interface en en héritant et en écrivant toutes ses méthodes. Elle peut en implémenter plusieurs : class Facture(Imprimable, Envoyable).

Exemple simple

Une interface Imprimable

Une interface est une classe abstraite qui ne contient que des méthodes à écrire, sans attributs ni code.

from abc import ABC, abstractmethod

class Imprimable(ABC):
    @abstractmethod
    def imprimer(self): ...

class Facture(Imprimable):
    def imprimer(self):
        print("Facture n°12 : 340 DH")

class Attestation(Imprimable):
    def imprimer(self):
        print("Attestation de stage")

for doc in [Facture(), Attestation()]:
    doc.imprimer()

Ce qui se passe

Imprimable dit seulement : « il faut une méthode imprimer() ».
Facture et Attestation n’ont rien d’autre en commun.

Utilité des interfaces

Découpler le code : imprimer_tout() ne connaît pas Facture ni Ordonnance, seulement Imprimable.
Réunir des classes sans lien de parenté autour d’une même capacité.
Remplacer une implémentation par une autre sans toucher au reste.

Exemple simple

Un objet, plusieurs contrats

Une classe peut signer plusieurs interfaces à la fois.

class Exportable(ABC):
    @abstractmethod
    def exporter_pdf(self): ...

class Facture(Imprimable, Exportable):
    def imprimer(self): print("impression")
    def exporter_pdf(self): print("facture.pdf créé")

Ce qui se passe

Facture respecte les deux contrats : on peut l’imprimer et l’exporter.
Le module d’impression ne connaît que Imprimable : il marche avec toute classe qui la signe.

Classe abstraite ou interface ?

	Classe abstraite	Interface
Contient	attributs, code, méthodes abstraites	seulement des méthodes abstraites
Représente	une famille (« est un »)	une capacité (« sait faire »)
Nombre par classe	une en général	plusieurs
Java / PHP	`abstract class` + `extends`	`interface` + `implements`

Pour aller plus loin

Python propose aussi typing.Protocol : une classe respecte le protocole dès qu’elle a les bonnes méthodes, sans hériter de rien. C’est la version officielle du duck typing : « si ça marche comme un canard et cancane comme un canard, c’est un canard ».

Exemple simple

La prise électrique

Une prise ne sait pas si vous branchez un chargeur, une lampe ou un fer à repasser. Elle exige seulement que la fiche ait la bonne forme. Une interface, c'est la forme de la prise ; chaque appareil l'implémente.

Exemple simple

Le permis de conduire

Le permis atteste que vous savez conduire, quel que soit votre métier. Un médecin et un boulanger peuvent tous deux « implémenter » l'interface Conducteur, et une personne peut avoir plusieurs permis.

class Imprimable(ABC):
    @abstractmethod
    def imprimer(self): ...

class Facture(Imprimable, Envoyable):   # deux interfaces
    ...

3Manipuler

Exécutez. La fonction imprimer_tout() accepte n'importe quel objet Imprimable. Faites implémenter l'interface Envoyable à la classe Ordonnance, puis ajoutez-la à la liste a_envoyer.

Pas à pas dans le lab ↗Python se charge au premier clic (environ 12 Mo, une seule fois).

from abc import ABC, abstractmethod

# Deux interfaces : uniquement des méthodes abstraites
class Imprimable(ABC):
    @abstractmethod
    def imprimer(self): ...

class Envoyable(ABC):
    @abstractmethod
    def envoyer(self, email): ...

class Facture(Imprimable, Envoyable):
    def __init__(self, numero, montant):
        self.numero, self.montant = numero, montant

def imprimer(self):
        print(f"FACTURE n°{self.numero} : {self.montant} DH")

def envoyer(self, email):
        print(f"Facture {self.numero} envoyée à {email}")

class Ordonnance(Imprimable):
    def __init__(self, patient, medicaments):
        self.patient, self.medicaments = patient, medicaments

def imprimer(self):
        print(f"ORDONNANCE de {self.patient} : {', '.join(self.medicaments)}")

def imprimer_tout(documents: list[Imprimable]):
    for d in documents:
        d.imprimer()

def envoyer_tout(documents: list[Envoyable], email):
    for d in documents:
        d.envoyer(email)

f = Facture(1042, 350)
o = Ordonnance("M. Alaoui", ["Doliprane", "Vitamine C"])

imprimer_tout([f, o])
a_envoyer = [f]
envoyer_tout(a_envoyer, "patient@exemple.ma")
print(isinstance(o, Envoyable))

Entrées pour input(), séparées par des virgules

Console

Mémoire : objets créés

Exécutez le code : les objets et leurs attributs s'afficheront ici.

4Pratiquer

Exercice 1 · L'interface Comparable

Écrivez une interface Mesurable avec une méthode abstraite taille(). Faites-la implémenter par une classe Fichier(nom, octets) et une classe Video(titre, minutes). Écrivez une fonction plus_grand(liste) qui renvoie l'objet de taille maximale.

Voir le corrigé

from abc import ABC, abstractmethod

class Mesurable(ABC):
    @abstractmethod
    def taille(self): ...

class Fichier(Mesurable):
    def __init__(self, nom, octets):
        self.nom, self.octets = nom, octets
    def taille(self):
        return self.octets

class Video(Mesurable):
    def __init__(self, titre, minutes):
        self.titre, self.minutes = titre, minutes
    def taille(self):
        return self.minutes * 60

def plus_grand(liste):
    return max(liste, key=lambda x: x.taille())

Exercice 2 · Classe abstraite ou interface ?

Expliquez la différence entre une classe abstraite et une interface, et donnez un cas pour chacune.

Voir le corrigé

Classe abstraite : une famille de classes proches qui partagent
des attributs et du code (Paiement → Carte, Livraison).
Interface : une capacité, sans code ni attribut, que des classes
sans lien peuvent avoir (Imprimable : Facture, Ordonnance).
Une classe hérite d'une seule famille en général, mais peut
implémenter plusieurs interfaces.

Exercice 3 · Le duck typing

En Python, imprimer_tout() fonctionnerait-elle avec un objet qui a une méthode imprimer() sans hériter de Imprimable ? Testez et expliquez.

Voir le corrigé

Oui. Python ne vérifie pas le type à l'appel : il cherche juste
une méthode imprimer(). C'est le « duck typing » : « si ça marche
comme un canard... ». L'interface ABC sert à rendre le contrat
explicite et à détecter les oublis dès la création de l'objet.

Les interfaces : des contrats entre classes

1Situer

2Comprendre

Les interfaces en Python

Utilité des interfaces

Classe abstraite ou interface ?

Pour aller plus loin

La prise électrique

Le permis de conduire

3Manipuler

4Pratiquer

Exercice 1 · L'interface Comparable

Exercice 2 · Classe abstraite ou interface ?

Exercice 3 · Le duck typing

5Vérifier