Des méthodes abstraites
Une signature suivie d’un point-virgule, sans corps. Elles sont implicitement public1.
Programmation · Prog 9 · Les contrats
Un contrat de méthodes : ce qu’un objet doit savoir faire, sans dire comment.
Déjà à l'aise ? Aller directement au quizÀ la caisse, le terminal ne demande pas qui a fabriqué ta carte.
Carte, téléphone, montre : il exige seulement qu’ils sachent payer.
Une interface, c’est ce contrat.
Elle liste ce qu’un objet doit savoir faire, sans dire comment. Toute classe qui remplit le contrat peut être utilisée à sa place.
Le contrat d’abord, le code ensuite.
Les trois ? Ils ont tous des ailes.
Des méthodes promises, pas encore codées
Dans la vraie vie
Une prise murale ne connaît pas l’appareil qu’on y branche.
Lampe, chargeur, bouilloire : tout appareil qui a la bonne fiche se branche.
implements
L’interface Volant est la prise : elle exige decoller() et atterrir(), sans en écrire le contenu. Une classe qui déclare implements Volant s’engage à coder les deux.
Une prise donne du courant.
Là s’arrête l’image : une interface classique ne fournit ni code ni attribut d’instance. Tout le travail est fait par la classe qui la remplit. Les méthodes default, plus loin, seront l’exception.
Trois classes essaient de se brancher sur Volant : un canard, un avion, un pingouin. Fais défiler.
Le contrat : Volant exige decoller() et atterrir(). Il ne dit pas comment : ses méthodes n'ont pas de corps.
decoller(). Le contrat ne se négocie pas.Même s’il a des ailes ?
decoller(), pas de Volant.Une signature suivie d’un point-virgule, sans corps. Elles sont implicitement public1.
Des méthodes default et static depuis Java 8 (chapitre 4), et des méthodes private depuis Java 9.
Un champ d’interface est implicitement public static final. Pas d’attribut d’instance, pas de constructeur.
On ne crée pas d’objet d’une interface : new Volant() donne « Volant is abstract; cannot be instantiated ».
Piège
Oublier public dans la classe : void decoller() { … } ne compile pas.
javacerror: decoller() in Canard cannot implement decoller() in Volant
attempting to assign weaker access privileges; was public
La méthode de l’interface est publique : son implémentation doit l’être aussi.
Java, Python, TypeScript et Go : touche un langage pour voir le même contrat Volant.
interface Volant {
void decoller(); // pas de corps : une promesse
void atterrir();
}
class Canard implements Volant {
public void decoller() {
System.out.println("Le canard bat des ailes.");
}
public void atterrir() {
System.out.println("Le canard se pose sur le lac.");
}
}
class Avion implements Volant {
public void decoller() {
System.out.println("L'avion accélère sur la piste.");
}
public void atterrir() {
System.out.println("L'avion sort son train.");
}
}
// Accepte tout objet qui remplit le contrat
static void faireVoler(Volant v) {
v.decoller();
v.atterrir();
}from abc import ABC, abstractmethod
# Python n'a pas de mot-clé interface :
# une classe abstraite en joue le rôle
class Volant(ABC):
@abstractmethod
def decoller(self): ...
@abstractmethod
def atterrir(self): ...
class Canard(Volant):
def decoller(self):
print("Le canard bat des ailes.")
def atterrir(self):
print("Le canard se pose sur le lac.")
def faire_voler(v: Volant):
v.decoller()
v.atterrir()
faire_voler(Canard())interface Volant {
decoller(): void;
atterrir(): void;
}
class Canard implements Volant {
decoller(): void {
console.log("Le canard bat des ailes.");
}
atterrir(): void {
console.log("Le canard se pose sur le lac.");
}
}
function faireVoler(v: Volant): void {
v.decoller();
v.atterrir();
}type Volant interface {
Decoller()
Atterrir()
}
// Aucun « implements » : avoir les méthodes suffit
type Canard struct{}
func (c Canard) Decoller() { fmt.Println("Le canard bat des ailes.") }
func (c Canard) Atterrir() { fmt.Println("Le canard se pose sur le lac.") }
func faireVoler(v Volant) {
v.Decoller()
v.Atterrir()
}L'interface est interface Volant { void decoller(); void atterrir(); }.
class Drone implements Volant {
public void decoller() { }
}class Drone implements Volant {
void decoller() { }
void atterrir() { }
}Volant v = new Volant();Une caisse qui accepte tous les paiements
Dans la vraie vie
Pour louer une voiture, on te demande ton permis, pas ton nom de famille.
L’agence est faite pour « un conducteur », pas pour toi en particulier : quiconque a le permis peut louer.
programmer pour l’interface
La fonction encaisser fait pareil : elle reçoit un Paiement, pas une carte ni un TWINT en particulier. Elle ne connaît que le contrat : payer(centimes).
Les montants sont en centimes, des entiers, pour éviter les arrondis des nombres à virgule (Prog 2).
Différence avec l’agence.
Le guichetier vérifie ton permis devant toi. En Java, le compilateur vérifie le contrat avant même que le programme tourne.
Quatre clients passent à la caisse : une carte, TWINT, une carte au-dessus de son plafond, puis un bon cadeau tout neuf.
encaisser ne connaît qu'une chose : l'objet reçu sait payer(centimes). Qui il est vraiment ne l'intéresse pas.
Le même principe en Python : un bon cadeau de 50 francs passe deux fois à la caisse. Les valeurs s’affichent à côté du code, comme dans un débogueur.
from abc import ABC, abstractmethodclass Paiement(ABC): @abstractmethod def payer(self, centimes): ... class BonCadeau(Paiement): def __init__(self, solde): self.solde = solde def payer(self, centimes): if centimes > self.solde: return False self.solde -= centimes return True def encaisser(p, centimes): ok = p.payer(centimes) print("accepté" if ok else "refusé") bon = BonCadeau(5000)encaisser(bon, 3000)encaisser(bon, 3000)
Un contrat, une classe qui le remplit, une fonction qui ne connaît que le contrat. Suivons un bon cadeau de 50 francs.
Lignes 2 à 4 : le contrat. Paiement exige payer(centimes), sans la coder. Python n’a pas de mot-clé interface : une classe abstraite en joue le rôle.
Lignes 6 à 13 : BonCadeau remplit le contrat. Il garde un solde et code payer() à sa façon : refuser si le montant dépasse le solde.
Ligne 19 : un bon de 5000 centimes, 50 francs. Le constructeur range le solde dans l’objet.
Ligne 20 : encaisser(bon, 3000). encaisser appelle p.payer(3000) sans savoir que p est un bon. 3000 ne dépasse pas 5000 : le solde passe à 2000.
Ligne 21 : la même ligne, un autre résultat. 3000 dépasse 2000 : payer renvoie False, le solde ne bouge pas.
encaisser n’a jamais su qu’il parlait à un bon cadeau. Une carte ou TWINT passeraient par la même ligne 16.
Java, TypeScript et Python : touche un langage pour voir le même contrat Paiement.
interface Paiement {
String nom();
boolean payer(int centimes);
}
class Carte implements Paiement {
public String nom() { return "Carte"; }
public boolean payer(int centimes) {
return centimes <= 50000; // plafond : 500 CHF
}
}
class Twint implements Paiement {
public String nom() { return "TWINT"; }
public boolean payer(int centimes) { return true; }
}
static void encaisser(Paiement p, int centimes) {
boolean ok = p.payer(centimes);
System.out.println(p.nom() + " : " + (ok ? "accepté" : "refusé"));
}
encaisser(new Carte(), 9990); // 99,90 CHF
encaisser(new Twint(), 9990);
encaisser(new Carte(), 80000); // 800 CHFinterface Paiement {
nom: string;
payer(centimes: number): boolean;
}
class Carte implements Paiement {
nom = "Carte";
payer(centimes: number): boolean {
return centimes <= 50000;
}
}
function encaisser(p: Paiement, centimes: number): void {
const ok = p.payer(centimes);
console.log(`${p.nom} : ${ok ? "accepté" : "refusé"}`);
}
encaisser(new Carte(), 9990);from typing import Protocol
class Paiement(Protocol):
nom: str
def payer(self, centimes: int) -> bool: ...
class Carte: # n'hérite de rien
nom = "Carte"
def payer(self, centimes):
return centimes <= 50000
def encaisser(p: Paiement, centimes: int):
ok = p.payer(centimes)
print(p.nom, ":", "accepté" if ok else "refusé")
encaisser(Carte(), 9990)Carte : accepté TWINT : accepté Carte : refusé
Pourquoi c’est si utile ?
Ajouter un moyen de paiement, c’est écrire une nouvelle classe : encaisser ne change pas, ni les tests déjà écrits. On peut même lui passer un faux paiement, un mock, pour tester sans vraie banque.
Remets les lignes dans l'ordre pour qu'un bon cadeau de 50 CHF respecte le contrat Paiement.
Un objet, plusieurs étiquettes
Dans la vraie vie
Léa est élève, nageuse au club et lectrice à la bibliothèque.
Au bassin, on ne regarde que sa carte du club. Chaque guichet ne voit qu’une facette de la même personne.
implements A, B
En Java, une classe n’hérite que d’une seule classe, mais elle implémente autant d’interfaces qu’elle veut. Selon le type de la variable, on voit une facette ou une autre du même objet.
Le même canard, vu par trois variables : Canard, Volant, Nageur. Fais défiler.
Canard c : avec le type de la classe, les quatre méthodes sont accessibles.
C’est la règle de Prog 8 : le type déclaré décide de ce que le compilateur accepte ; l’objet, lui, ne change pas. Une interface peut même en étendre plusieurs1.
Range chaque classe selon les interfaces qu'elle devrait implémenter.
Ajouter une méthode sans tout casser
Dans la vraie vie
Une mise à jour ajoute la fonction « réveil » à tous les téléphones.
Chacun reçoit une sonnerie par défaut. Qui veut la sienne la change ; les autres n’ont rien à faire.
default
Ajouter une méthode abstraite à une interface déjà utilisée casserait toutes les classes qui l’implémentent. Depuis Java 8, une méthode default apporte un corps par défaut : les anciennes classes continuent de fonctionner, et chacune peut la redéfinir2.
Volant ajoute presenter() avec un corps ; Avion la redéfinit, les autres classes gardent la version par défaut.
interface Volant {
void decoller();
void atterrir();
default String presenter() { // corps par défaut
return "Je sais voler.";
}
}
class Avion implements Volant {
public void decoller() { }
public void atterrir() { }
@Override
public String presenter() { // redéfinition facultative
return "Je vole avec des moteurs.";
}
}Là s’arrête la sonnerie.
Une méthode default ne peut lire aucun attribut d’instance : une interface n’en a pas. Elle s’appuie sur les autres méthodes du contrat.
Piège
Deux interfaces fournissent chacune un default String salut(). Java refuse de choisir au hasard.
javacclass C inherits unrelated defaults for salut() from types A and B
La classe redéfinit salut() et peut appeler une version précise avec A.super.salut().
Interface ou classe abstraite ?
Dans la vraie vie
On n’a qu’une famille, mais on peut collectionner les brevets.
La famille transmet un nom et des recettes. Un brevet certifie seulement ce que tu sais faire.
Depuis les méthodes default, la différence ne tient plus au code : elle tient à l’état (les attributs) et au nombre de parents possibles.
interfaceconstantes seulement (public static final)
classe abstraiteattributs d’instance possibles
interfacedefault, static, private
classe abstraitetoutes sortes
interfacepubliques (sauf private)
classe abstraitepublic, protected, private
interfacenon
classe abstraiteoui (appelé par les sous-classes)
interfaceautant qu’on veut
classe abstraiteune seule (extends)
La documentation Java résume : une classe abstraite pour partager du code entre classes proches ; une interface quand des classes sans lien doivent offrir un même comportement, ou pour cumuler plusieurs types3.
Touche la meilleure solution pour chaque situation.
Chien et Chat doivent partager un attribut nom et une méthode manger() déjà codée.
Oiseau, Avion et Drone, trois classes sans rapport, doivent tous pouvoir decoller().
Canard doit être à la fois un Volant et un Nageur.
Déclarer, ou avoir la forme ?
Dans la vraie vie
Trois façons d’entrer au tournoi de foot du gymnase.
Être inscrit sur la liste, avoir le bon équipement, ou simplement savoir jouer quand le ballon arrive.
nominal ou structurel
Une classe Especes possède une méthode payer(), mais ne déclare aucun contrat. Java exige la liste : implements. TypeScript et Go regardent la forme. Python appelle la méthode, et on voit.
La classe Especes devant quatre langages : Java, TypeScript, Go et Python rendent leur verdict.
Especes a la bonne méthode, payer(), mais ne déclare pas implements Paiement. La caisse l'acceptera-t-elle ?
Le nom compte : une classe n’est un Paiement que si elle le déclare avec implements.
La forme compte. En TypeScript, implements ne fait que vérifier la classe5 ; en Go, il n’y a même pas de mot-clé6.
Le « duck typing » : seul compte le fait que l’objet ait la méthode appelée. Un Protocol décrit une forme que mypy ou Pyright vérifient sans héritage4.
Et en Python, qui vérifie ?
La fiche en six cartes
Une interface liste des méthodes à coder, sans attribut d’instance ni constructeur. On ne l’instancie pas.
La classe s’engage à coder toutes les méthodes abstraites, en public ; sinon, erreur de compilation.
Une fonction qui reçoit un Paiement accepte toutes les classes, présentes et futures, qui le respectent.
Un seul parent, autant d’interfaces qu’on veut ; le type de la variable choisit la facette visible.
Les méthodes default (Java 8) ajoutent du code à une interface sans casser les classes existantes.
Classe abstraite pour partager état et code entre classes proches ; interface pour un comportement commun à des classes sans lien.
Dix questions, zéro faute
Dix questions tirées au hasard, de plus en plus difficiles. À la première erreur, la partie s’arrête : lis l’explication, puis relance.
10 questions · zéro faute · chronomètre
Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Extraits exécutés : Java 21, Python 3.14, TypeScript 5.9 ; l'extrait Go a été relu (pas de compilateur Go disponible).