Programmation · Prog 9 · Les contrats

Interfaces

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.

CHF12,50 carte téléphone montre

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.

Au programme

  • 01le contrat : des méthodes promises, pas encore codées
  • 02programmer pour l’interface
  • 03un objet, plusieurs contrats
  • 04les méthodes default
  • 05interface ou classe abstraite ?
  • 06déclarer le contrat, ou avoir la forme ?
Un canard, un avion et un pingouin : lesquels peuvent être des « Volant » pour Java ?

Les trois ? Ils ont tous des ailes.

Le compilateur a un avis tranché. Réponse dans la première scène.

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.

lampechargeurbouilloireautre norme la prise exige une forme, pas une marque

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.

« interface »Volantdecoller();atterrir(); class Canarddecoller() {…}atterrir() {…} implements Volant : contrat rempli

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.

Brancher au contrat

Trois classes essaient de se brancher sur Volant : un canard, un avion, un pingouin. Fais défiler.

Brancher au contratle contrat

Le contrat : Volant exige decoller() et atterrir(). Il ne dit pas comment : ses méthodes n'ont pas de corps.

Réponse : le canard et l’avion, oui ; le pingouin, non, tant qu’il ne code pas decoller(). Le contrat ne se négocie pas.

Même s’il a des ailes ?

Le compilateur ne regarde pas les ailes, il regarde les méthodes. Pas de decoller(), pas de Volant.

Des méthodes abstraites

Une signature suivie d’un point-virgule, sans corps. Elles sont implicitement public1.

Des méthodes avec un corps

Des méthodes default et static depuis Java 8 (chapitre 4), et des méthodes private depuis Java 9.

Des constantes

Un champ d’interface est implicitement public static final. Pas d’attribut d’instance, pas de constructeur.

Aucun objet

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.

Le contrat, en quatre langages

Java, Python, TypeScript et Go : touche un langage pour voir le même contrat Volant.

JavaVol.java
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();
}
Pythonvol.py
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())
TypeScriptvol.ts
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();
}
Govol.go
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()
}
Exercice 1

Ça compile ?

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.

Location permis ? P P AlineMarcoTom pour « un conducteur »

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).

encaisser(Paiement p)p.payer(centimes) Paiement Cartepayer()TWINTpayer()Bon cadeaupayer() une seuleentrée

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.

La caisse

Quatre clients passent à la caisse : une carte, TWINT, une carte au-dessus de son plafond, puis un bon cadeau tout neuf.

La caisseen attente

encaisser ne connaît qu'une chose : l'objet reçu sait payer(centimes). Qui il est vraiment ne l'intéresse pas.

Le contrat en action, ligne par ligne

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.

caisse.pyPython
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)
solde sortie

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.

La caisse, en trois langages

Java, TypeScript et Python : touche un langage pour voir le même contrat Paiement.

JavaCaisse.java
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 CHF
TypeScriptcaisse.ts
interface 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);
Pythoncaisse.py
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)
Sortie de la version Java
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.

encaisser(p, 3000) vraie banque FauxPaiementpayer() → Trueun mock
Exercice 2

Écris le bon cadeau

Remets les lignes dans l'ordre pour qu'un bon cadeau de 50 CHF respecte le contrat Paiement.

  1. class BonCadeau implements Paiement {
  2. private int solde = 5000;
  3. public String nom() { return "Bon cadeau"; }
  4. public boolean payer(int centimes) {
  5. if (centimes > solde) return false;
  6. solde -= centimes;
  7. return true;
  8. }
  9. }

Un objet, plusieurs étiquettes

Dans la vraie vie

Léa est élève, nageuse au club et lectrice à la bibliothèque.

Léa élèveclub de natationbibliothèque au bassin à la biblio une personne, trois facettes

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.

« interface »Volantdecoller();atterrir(); « interface »Nageurnager(); class Canard class Canard implements Volant, Nageur

Trois points de vue

Le même canard, vu par trois variables : Canard, Volant, Nageur. Fais défiler.

Trois points de vueCanard c

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.

VolantNageurAmphibie interface Amphibie extends Volant, Nageur
Exercice 3

Quels contrats implémenter ?

Range chaque classe selon les interfaces qu'elle devrait implémenter.

Volantdecoller(), atterrir()
Nageurnager()
Les deuximplements Volant, Nageur

Ajouter une méthode sans tout casser

Dans la vraie vie

Une mise à jour ajoute la fonction « réveil » à tous les téléphones.

mise à jour : réveil par défautpar défautpar défautsa chanson

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.

Une méthode default

Volant ajoute presenter() avec un corps ; Avion la redéfinit, les autres classes gardent la version par défaut.

JavaVolant.java
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.

« interface »Adefault salut()« interface »Bdefault salut() class C salut() : lequel ? salut() redéfinie ? A.super.salut()

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.

famille Rossinom, recettes Sam une seule famille brevet de natation premiers secours permis de conduire autant qu’on veut

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.

la familleclasse abstraiteun seul extends, état et code les brevetsinterfacesautant qu’on veut, sans état

Interface ou classe abstraite, en Java

Attributs

interfaceconstantes seulement (public static final)

classe abstraiteattributs d’instance possibles

Méthodes avec code

interfacedefault, static, private

classe abstraitetoutes sortes

Visibilité des méthodes

interfacepubliques (sauf private)

classe abstraitepublic, protected, private

Constructeur

interfacenon

classe abstraiteoui (appelé par les sous-classes)

Combien par classe ?

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.

Que faut-il partager ? classes proches,état et code communsclasse abstraite classes sans lien, ouplusieurs typesinterface
Exercice 4

Que choisirais-tu ?

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.

liste d’inscritsJava, C# équipement exigéTypeScript, Go entrée librePython

Ê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.

Qui l’accepte ?

La classe Especes devant quatre langages : Java, TypeScript, Go et Python rendent leur verdict.

Qui l'accepte ?la question

Especes a la bonne méthode, payer(), mais ne déclare pas implements Paiement. La caisse l'acceptera-t-elle ?

Typage nominal : Java, C#

Le nom compte : une classe n’est un Paiement que si elle le déclare avec implements.

Typage structurel : TypeScript, Go

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.

Et Python ?

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.

Aucune famille n’a raison : Java te protège des accidents en exigeant une déclaration, TypeScript et Go te laissent plus libre.

Et en Python, qui vérifie ?

Personne avant l’appel : si la méthode manque, l’erreur arrive à ce moment-là. Avec un Protocol, mypy ou Pyright préviennent avant.

La fiche en six cartes

Le contrat

Une interface liste des méthodes à coder, sans attribut d’instance ni constructeur. On ne l’instancie pas.

implements

La classe s’engage à coder toutes les méthodes abstraites, en public ; sinon, erreur de compilation.

Programmer pour l’interface

Une fonction qui reçoit un Paiement accepte toutes les classes, présentes et futures, qui le respectent.

Plusieurs contrats

Un seul parent, autant d’interfaces qu’on veut ; le type de la variable choisit la facette visible.

default

Les méthodes default (Java 8) ajoutent du code à une interface sans casser les classes existantes.

Bien choisir

Classe abstraite pour partager état et code entre classes proches ; interface pour un comportement commun à des classes sans lien.

Dix questions, zéro faute

Mode survie

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.

Retiens la question à te poser : « qu’est-ce que le contrat promet, et qui le remplit ? ». Presque tout le quiz en découle.

10 questions · zéro faute · chronomètre

Sources

  1. Oracle, The Java Tutorials : Defining an Interface, consulté en 2026. docs.oracle.com
  2. Oracle, The Java Tutorials : Default Methods, consulté en 2026. docs.oracle.com
  3. Oracle, The Java Tutorials : Abstract Methods and Classes (comparaison avec les interfaces), consulté en 2026. docs.oracle.com
  4. Python Software Foundation, typing : Protocol, documentation Python 3, consultée en 2026. docs.python.org
  5. Microsoft, TypeScript Handbook : Classes (implements), consulté en 2026. typescriptlang.org
  6. The Go Authors, The Go Programming Language Specification : Interface types, consulté en 2026. go.dev

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).

Glisser pour continuer vers Prog 10 : Collections
Gymnase 3