Programmation · Prog 8 · Les quatre piliers

Héritage et polymorphisme

Écrire le commun une seule fois, puis laisser chaque objet répondre à sa façon.

Déjà à l'aise ? Aller directement au quiz

Un chien, un chat, un chiot. Une seule ligne de code : a.parler().

a.parler() ChienChatChiot Wouf !Miaou !Wouf ! (petit) le même appel, trois réponses

Trois réponses différentes. Comment le même appel peut-il donner trois résultats ?

Écrire trois fois le même code ? Non.

On écrit ce qui est commun une seule fois, dans une classe parente. Chaque classe enfant ne précise que sa différence.

Écrire une fois, hériter partout.

On résume souvent la programmation orientée objet en quatre piliers.

POO héritagepolymorphismeencapsulationabstraction

Un moyen de s’en souvenir, pas une règle du langage. On les prend un par un.

Au programme

  • 01hériter : écrire le commun une seule fois
  • 02super : construire le parent d’abord
  • 03redéfinir une méthode héritée
  • 04polymorphisme : qui répond à l’appel ?
  • 05encapsulation : protéger ses données
  • 06abstraction : un modèle sans objet
  • 07hériter ou composer ?
Question pour toi : en Java, une variable déclarée Animal contient un Chien. Quel parler() s’exécute ?

Celui d’Animal, puisque la variable est un Animal ?

Garde ta réponse en tête. La scène « Qui répond à l’appel ? » va trancher.

Écrire le commun une seule fois

Dans la vraie vie

Chez un constructeur, chaque modèle part du précédent.

Véhiculedéfinitrouler, faire le plein hérite de Voiturereçoit tout et ajoute+ ouvrir le coffre hérite de Voitureélectriquereçoit tout et redéfinitfaire le plein : recharger

Une voiture électrique est une voiture, qui est un véhicule : elle reçoit tout, ajoute ou change le reste.

extends

En code, c’est l’héritage. Animal définit ce que tous les animaux ont : un nom, manger(), parler(). Chien hérite d’Animal et ajoute rapporter().

Animal nommanger()parler() Chien + rapporter() hérite Pythonclass Chien(Animal): Javaclass Chien extends Animal

Mais rien n’est recopié.

Là s’arrête l’image du constructeur automobile : manger() reste écrite une seule fois, dans Animal. Appelée sur Rex, elle est cherchée dans Chien, puis dans le parent1.

Animal manger() Chienrapporter() rex.manger() ? pas dans Chien… trouvée dans Animal « Rex mange. »

L’objet rio, démonté

Un Chiot hérite de Chien, qui hérite d’Animal. Fais défiler : l’objet se sépare en trois étages, puis se remonte.

L'objet rio, un Chiotassemblé
L'objet rio et ses trois étages : Animal, Chien, Chiot

Un seul objet. Mais d'où viennent ses attributs et ses méthodes ? Fais défiler pour le démonter.

Retiens les trois cas : hérité (écrit dans le parent), ajouté (nouveau dans l’enfant), redéfini (réécrit dans l’enfant).

Et pour rio.parler(), laquelle est prise ?

La plus proche : on cherche d’abord dans Chiot, puis on remonte vers Chien et Animal. Tout le reste de la fiche en découle.

Le parent d’abord

Dans la vraie vie

Une maison se construit du bas vers le haut.

1d’abordrez-de-chaussée 2ensuiteétage

Le rez-de-chaussée d’abord, l’étage ensuite. Un étage posé dans le vide ne tient pas.

super

Dans le constructeur d’une classe enfant, super().__init__(nom) fait d’abord construire la partie du parent : c’est lui qui crée self.nom. L’enfant ajoute ensuite la sienne.

Lisons-le ligne par ligne, mémoire comprise.

animaux.pyPython
class Animal:    def __init__(self, nom):        self.nom = nom    def manger(self):        return f"{self.nom} mange." class Chien(Animal):    def __init__(self, nom, race):        super().__init__(nom)        self.race = race rex = Chien("Rex", "berger")print(rex.manger())
objet Chiennom = "Rex"race = "berger"(encore vide) appels sortie

Deux classes, un objet. Chien hérite d’Animal. Suivons la construction de rex, avec la mémoire et les appels en cours sous le code.

Ligne 12 : Chien("Rex", "berger"). Python crée un objet Chien vide, puis lance Chien.__init__. Dans ce constructeur, l’objet s’appelle self7.

Ligne 9 : super().__init__(nom). On monte dans le constructeur d’Animal, qui range nom = "Rex" dans l’objet. Le rez-de-chaussée est posé.

Ligne 10 : retour dans Chien. self.race = race pose l’étage : l’objet a maintenant ses deux attributs.

Constructeur terminé. Seulement maintenant, le nom rex désigne l’objet7.

Ligne 13 : rex.manger(). Chien n’a pas de manger() : Python remonte et trouve celle d’Animal1. Sortie : « Rex mange. »

Python

super().__init__(nom) exécute le constructeur du parent. Rien ne l’impose, mais sans cet appel, self.nom n’existe jamais7.

Java

super(nom); appelle le constructeur du parent. Sans cet appel, Java insère super() sans argument : si le parent n’a pas de constructeur sans paramètre, rien ne compile.

Depuis Java 25

Quelques instructions qui n’utilisent pas encore l’objet peuvent précéder super(...), par exemple pour vérifier un argument6.

JavaScript

Dans le constructeur d’une classe enfant, super(...) doit être appelé avant d’utiliser this, sinon ReferenceError.

Dans une méthode

super().parler() en Python, super.parler() en Java : on appelle la version du parent, puis on la complète.

Piège

Oublier l’appel au parent : l’étage flotte dans le vide.

pas de rez-de-chaussée self.race self.nom n’existe pas

Python, rex.manger()AttributeError: 'Chien' object has no attribute 'nom'

Java, à la compilationerror: constructor Animal in class Animal cannot be applied to given types;

La même classe, cinq langages

Touche Python, Java, JavaScript, C# ou C++ : l’idée reste la même, seule l’écriture change.

Pythonanimaux.py
class Animal:
    def __init__(self, nom):
        self.nom = nom

    def manger(self):
        return f"{self.nom} mange."

# Entre parenthèses : la classe parente
class Chien(Animal):
    def __init__(self, nom, race):
        super().__init__(nom)   # le parent crée nom
        self.race = race

    def rapporter(self):
        return f"{self.nom} rapporte la balle."

rex = Chien("Rex", "berger")
print(rex.manger())      # héritée d'Animal
print(rex.rapporter())   # ajoutée par Chien
JavaChien.java
class Animal {
    protected String nom;

    public Animal(String nom) {
        this.nom = nom;
    }

    public String manger() {
        return nom + " mange.";
    }
}

class Chien extends Animal {
    private String race;

    public Chien(String nom, String race) {
        super(nom);   // appelle le constructeur d'Animal
        this.race = race;
    }

    public String rapporter() {
        return nom + " rapporte la balle.";
    }
}
JavaScriptanimaux.js
class Animal {
    constructor(nom) {
        this.nom = nom;
    }
    manger() {
        return `${this.nom} mange.`;
    }
}

class Chien extends Animal {
    constructor(nom, race) {
        super(nom);   // obligatoire avant d'utiliser this
        this.race = race;
    }
    rapporter() {
        return `${this.nom} rapporte la balle.`;
    }
}
C#Chien.cs
class Animal {
    protected string nom;

    public Animal(string nom) {
        this.nom = nom;
    }

    public string Manger() {
        return $"{nom} mange.";
    }
}

// Les deux-points marquent l'héritage
class Chien : Animal {
    private string race;

    public Chien(string nom, string race) : base(nom) {
        this.race = race;
    }

    public string Rapporter() {
        return $"{nom} rapporte la balle.";
    }
}
C++chien.cpp
class Animal {
protected:
    std::string nom;
public:
    Animal(std::string n) : nom(n) {}
    std::string manger() { return nom + " mange."; }
};

// « : public Animal » marque l'héritage
class Chien : public Animal {
private:
    std::string race;
public:
    Chien(std::string n, std::string r)
        : Animal(n), race(r) {}
    std::string rapporter() {
        return nom + " rapporte la balle.";
    }
};
Sortie de la version Python
Rex mange.
Rex rapporte la balle.

Même nom, nouveau comportement

Dans la vraie vie

Au panneau du gymnase, on colle la nouvelle affiche sur l’ancienne, dans le même cadre.

Concertvendredi 20 haula du gymnase Concertsamedi 21 haula du gymnase COMPLET mêmecadre nouvelleaffiche bandeauajouté

Le cadre reste, l’affiche change. Et un bandeau peut compléter l’affiche sans la cacher.

override

Une classe enfant peut réécrire une méthode héritée : c’est la redéfinition. Même nom, mêmes paramètres : même cadre, nouvelle affiche.

chiot.pyPython
class Chiot(Chien):
    def parler(self):
        base = super().parler()
        return base + " (petit)"

super().parler() garde l’affiche du parent ; la ligne suivante colle le bandeau « (petit) ».

Rien n’est arraché.

Différence avec le panneau : la version d’Animal existe toujours. Un objet Animal dit encore « ... » ; seuls les Chien et les Chiot ont la nouvelle version.

Redéfinir, en trois langages

Le même Chiot qui réutilise la version de Chien : touche Python, Java ou JavaScript.

Pythonparler.py
class Animal:
    def parler(self):
        return "..."

class Chien(Animal):
    def parler(self):          # redéfinition
        return "Wouf !"

class Chiot(Chien):
    def parler(self):          # redéfinition qui réutilise le parent
        return super().parler() + " (petit)"

print(Chiot().parler())   # Wouf ! (petit)
JavaChiot.java
class Chien extends Animal {
    @Override
    public String parler() {
        return "Wouf !";
    }
}

class Chiot extends Chien {
    @Override
    public String parler() {
        return super.parler() + " (petit)";
    }
}
JavaScriptchiot.js
class Chien extends Animal {
    parler() {
        return "Wouf !";
    }
}

class Chiot extends Chien {
    parler() {
        return super.parler() + " (petit)";
    }
}

@Override

En Java, cette annotation n’est pas obligatoire, mais elle fait vérifier qu’une méthode du parent est bien redéfinie3. Une faute de frappe devient une erreur, au lieu d’une méthode ajoutée en silence.

Animalparler() Chat @Overrideparle() aucune méthode parle() à redéfinir erreur de compilation

Redéfinition (override)

Dans la classe enfant, même nom et mêmes paramètres : la nouvelle version remplace celle du parent pour cet objet.

Surcharge (overload)

Même nom, paramètres différents : parler() et parler(int fois) coexistent (voir Prog 5).

Attention au vocabulaire

La traduction française du tutoriel Python dit que les classes dérivées peuvent « surcharger » des méthodes : là, cela veut dire redéfinir1. Ici, « redéfinir » = override.

Exercice 1

Redéfinition ou surcharge ?

Chien hérite d'Animal, qui a une méthode String parler().

class Chien extends Animal {
    @Override
    String parler() { return "Wouf !"; }
}
class Chien extends Animal {
    String parler(int fois) {
        return "Wouf ! ".repeat(fois).trim();
    }
}
class Chat extends Animal {
    @Override
    String parle() { return "Miaou !"; }
}

Qui répond à l’appel ?

Dans la vraie vie

L’entraîneur crie une seule consigne : « En place ! »

GDA au butreculemonte « En place ! »

La gardienne file au but, le défenseur recule, l’attaquante monte. Chacun comprend la consigne selon son poste.

Mais il ne crie pas à « un joueur » quelconque : « Prends le ballon à la main ! ». Seule la gardienne en a le droit.

« Prends le ballon à la main ! » ?un joueur ? Gla gardienne refusé d’accord

Avant de demander ça, il doit savoir à qui il parle.

polymorphisme

En Java, une variable a un type déclaré (Animal a) et désigne un objet réel (new Chiot("Rio")). Le compilateur regarde le type ; à l’exécution, l’objet choisit sa méthode.

type déclaréAnimal a objet réel objet Chiotnom = "Rio" compilation : ce que permet le type déclaré exécution : la méthode de l’objet réel

Qui répond ?

Huit appels, un à chaque pas de défilement. Tu peux aussi toucher un morceau du code pour le changer et voir où Java cherche la méthode.

Qui répond ?appel 1/8
a = new;
a.;

Réponse à ma question du début : c’est le parler() de Chien. Java part toujours de l’objet réel.

Alors le type déclaré ne sert à rien ?

Si : il décide de ce que le compilateur accepte. Pour lui, a reste un Animal, donc a.rapporter() est refusé.

À la compilation : le type déclaré

Le compilateur accepte a.rapporter() seulement si la classe Animal possède rapporter(). Sinon : erreur, même si l’objet est un Chien.

À l’exécution : l’objet réel

La machine virtuelle appelle la méthode de l’objet réellement désigné : c’est l’invocation virtuelle, ou liaison dynamique4.

Pour appeler rapporter()

On vérifie et on convertit d’abord : if (a instanceof Chien c) c.rapporter();

Et en Python ?

Les variables n’ont pas de type déclaré : seul l’objet réel compte. Toutes les méthodes se comportent comme des méthodes « virtuelles »1.

Une boucle, quatre voix

Une liste qui mélange quatre classes, et une seule ligne pour les faire parler.

Une boucle, quatre voixavant la boucle
  1. animaux = [Chien("Rex"), Chat("Tom"),
  2. Animal("Bob"), Chiot("Rio")]
  3. for a in animaux:
  4. print(a.parler())

Une liste d'Animal qui contient quatre objets de classes différentes. Une seule ligne les fait parler.

Le vrai gain.

La boucle ne connaît aucune classe en particulier. Demain, une classe Vache avec son parler() : la boucle la fait parler sans qu’on y touche.

for a in animaux:print(a.parler()) aucune ligneà changer la même boucle, une classe de plus ChienChatChiot Vache Meuh !

Une équipe de jeu vidéo

Un guerrier et un mage héritent de Personnage et redéfinissent attaquer(). Touche Python ou JavaScript.

Pythonequipe.py
class Personnage:
    def __init__(self, nom, pv):
        self.nom = nom
        self.pv = pv

    def attaquer(self):
        return 10

class Guerrier(Personnage):
    def __init__(self, nom):
        super().__init__(nom, 150)

    def attaquer(self):
        return 25

class Mage(Personnage):
    def __init__(self, nom):
        super().__init__(nom, 80)
        self.mana = 100

    def attaquer(self):
        if self.mana >= 10:
            self.mana -= 10
            return 40
        return 5

equipe = [Guerrier("Conan"), Mage("Gandalf")]
for perso in equipe:
    print(f"{perso.nom} inflige {perso.attaquer()} dégâts")
JavaScriptequipe.js
class Personnage {
    constructor(nom, pv) {
        this.nom = nom;
        this.pv = pv;
    }
    attaquer() {
        return 10;
    }
}

class Guerrier extends Personnage {
    constructor(nom) {
        super(nom, 150);
    }
    attaquer() {
        return 25;
    }
}

class Mage extends Personnage {
    constructor(nom) {
        super(nom, 80);
        this.mana = 100;
    }
    attaquer() {
        if (this.mana >= 10) {
            this.mana -= 10;
            return 40;
        }
        return 5;
    }
}

const equipe = [new Guerrier("Conan"), new Mage("Gandalf")];
for (const perso of equipe) {
    console.log(`${perso.nom} inflige ${perso.attaquer()} dégâts`);
}
Sortie
Conan inflige 25 dégâts
Gandalf inflige 40 dégâts
Exercice 2

Prédis ce qui se passe

Les classes Animal, Chien, Chat et Chiot sont celles de la scène.

Animal a = new Chiot("Rio");
System.out.println(a.presenter());
Animal a = new Chien("Rex");
a.rapporter();

Un Mage frais (mana 100) attaque onze fois de suite. Que renvoie la onzième attaque ?

Un solde qu’on ne touche pas

Dans la vraie vie

Au bancomat, tu ne te sers pas dans le coffre : tu passes par le clavier, qui vérifie chaque demande.

toi coffrefermé Retrait :2000 CHF Soldeinsuffisant Retrait :50 CHF 50

2000 francs avec 1500 sur le compte ? Refusé. 50 francs ? Accordé.

encapsulation

En code, le solde est private : rangé à l’abri dans l’objet. Le reste du programme passe par deposer(), retirer() et getSolde(), qui vérifient chaque demande. C’est l’encapsulation.

Le coffre

Un objet CompteBancaire et quatre tentatives, dont deux interdites. Fais défiler : chaque appel frappe à une porte.

Le coffresolde = 1000
  1. compte = CompteBancaire(1000)
  2. compte.deposer(500)
  3. compte.retirer(2000)
  4. compte.solde = -1000000 // Java
  5. compte._CompteBancaire__solde # Python

Un compte, un solde privé. Trois méthodes publiques servent de guichets.

Le compte, en Java et en Python

Le même compte bancaire dans les deux langages : touche Java ou Python.

JavaCompteBancaire.java
public class CompteBancaire {
    private double solde;   // invisible hors de la classe

    public CompteBancaire(double solde) {
        this.solde = solde;
    }

    public double getSolde() {   // lecture contrôlée
        return solde;
    }

    public void deposer(double montant) {
        if (montant > 0) {
            solde += montant;
        }
    }

    public boolean retirer(double montant) {
        if (montant <= 0 || montant > solde) {
            return false;   // refusé
        }
        solde -= montant;
        return true;
    }
}
Pythoncompte.py
class CompteBancaire:
    def __init__(self, solde):
        self.__solde = solde    # nom transformé par Python

    def get_solde(self):
        return self.__solde

    def deposer(self, montant):
        if montant > 0:
            self.__solde += montant

    def retirer(self, montant):
        if 0 < montant <= self.__solde:
            self.__solde -= montant
            return True
        return False

compte = CompteBancaire(1000)
compte.deposer(500)
print(compte.get_solde())       # 1500
print(compte.retirer(2000))     # False

En Java, quatre niveaux d’accès, du plus fermé au plus ouvert.

partoutle paquetagela classe sous-classed’un autrepaquetage privatela classe seule(rien)+ le paquetage protected+ les sous-classes ailleurspublicpartout

« Sous-classe ailleurs » : une sous-classe rangée dans un autre paquetage5.

Qui voit quoi, en Java ?

private

  • la classeoui
  • le paquetagenon
  • une sous-classe ailleursnon
  • partoutnon

Réservé à la classe elle-même. Même une sous-classe passe par une méthode comme getSolde().

(rien)

  • la classeoui
  • le paquetageoui
  • une sous-classe ailleursnon
  • partoutnon

Sans mot-clé : toutes les classes du même paquetage, y compris les sous-classes qui s’y trouvent.

protected

  • la classeoui
  • le paquetageoui
  • une sous-classe ailleursoui
  • partoutnon

Le paquetage, plus les sous-classes rangées dans un autre paquetage.

public

  • la classeoui
  • le paquetageoui
  • une sous-classe ailleursoui
  • partoutoui

Aucune restriction : le niveau des méthodes qui servent de guichets, comme deposer().

Et Python ?

Pas de vrai private1. _solde veut dire « interne, n’y touche pas ». __solde est renommé _CompteBancaire__solde : une convention, pas un verrou.

__solde _CompteBancaire__solde renommé par Python compte.__solde → AttributeError compte._CompteBancaire__solde → 1500
Exercice 3

Qui a le droit ?

Touche la bonne réponse.

En Java, une sous-classe CompteEpargne peut-elle lire directement le private double solde de CompteBancaire ?

En Python, que donne print(compte.__solde) écrit hors de la classe ?

Pourquoi passer par retirer() plutôt que modifier le solde directement ?

Un modèle qu’on ne crée jamais

Dans la vraie vie

L’ardoise d’un restaurant annonce entrée, plat, dessert. Le service est fixé ; le plat, lui, n’est pas encore écrit.

MENU DU JOUR Entrée : salade verte Plat :? Dessert : meringues lundi : papet vaudois mardi : filets de perche

Personne ne peut commander le plat « ? ». Chaque jour écrit le sien.

abstract

Une classe abstraite est cette ardoise. Forme déclare aire() sans la coder ; decrire() est déjà écrite et appelle aire(). On ne crée jamais « une Forme », seulement un Rectangle ou un Cercle.

Plat : ?aire() : ? le service, fixédecrire(), écrite le plat du lundiRectangle.aire()

Forme, classe abstraite

Fais défiler : on essaie de créer une Forme, puis un Rectangle, un Cercle et un Carré qui a oublié sa formule.

Forme, classe abstraitele modèle

Forme déclare aire() sans la coder. Le point d'interrogation dit : « chaque sous-classe donnera sa formule ».

Des formes, en Python et en Java

Une classe abstraite et ses sous-classes concrètes dans les deux langages.

Pythonformes.py
from abc import ABC, abstractmethod
import math

class Forme(ABC):
    @abstractmethod
    def aire(self):
        ...

class Rectangle(Forme):
    def __init__(self, largeur, hauteur):
        self.largeur = largeur
        self.hauteur = hauteur

    def aire(self):
        return self.largeur * self.hauteur

class Cercle(Forme):
    def __init__(self, rayon):
        self.rayon = rayon

    def aire(self):
        return math.pi * self.rayon ** 2

for f in [Rectangle(5, 3), Cercle(2)]:
    print(round(f.aire(), 2))   # 15, puis 12.57
JavaFormes.java
abstract class Forme {
    abstract double aire();   // pas de corps

    String decrire() {        // méthode concrète, héritée
        return getClass().getSimpleName() + " d'aire " + aire();
    }
}

class Rectangle extends Forme {
    private final double largeur, hauteur;

    Rectangle(double l, double h) {
        largeur = l;
        hauteur = h;
    }

    @Override
    double aire() {
        return largeur * hauteur;
    }
}

// Forme f = new Forme();   // erreur : Forme is abstract
Forme f = new Rectangle(5, 3);
System.out.println(f.decrire());   // Rectangle d'aire 15.0

Pas d’objet direct

Une classe abstraite ne s’instancie pas, mais elle peut avoir des attributs et des méthodes concrètes, comme decrire(), que ses sous-classes héritent2.

Tout coder, ou rester abstraite

Une sous-classe doit coder toutes les méthodes abstraites. Sinon, Java refuse de la compiler si elle n’est pas déclarée abstract, et Python refuse de l’instancier.

En Python

Le module abc : une classe dérivée de ABC avec une méthode marquée @abstractmethod ne s’instancie pas tant que cette méthode n’est pas redéfinie.

Une interface décrit aussi ce qu’un objet sait faire, sans attributs d’instance. En Java, une classe n’hérite que d’une seule classe, mais peut implémenter plusieurs interfaces.

Comment être deux choses à la fois ? Réponse dans Prog 9.

Est un, ou a un ?

Dans la vraie vie

Une voiture électrique est une voiture. Mais une voiture a un moteur : elle n’est pas un moteur.

moteur a un moteur une voiture

Le moteur est une pièce : on peut le sortir, le changer, sans refaire toute la voiture.

composition

L’héritage ne se justifie que si l’enfant est un cas particulier du parent. Quand un objet a un autre objet, on le range dans un attribut : self.moteur = Moteur(chevaux). C’est la composition.

garage.pyPython
class Moteur:    def __init__(self, chevaux):        self.chevaux = chevaux    def demarrer(self):        return "Vroum" class Voiture:    def __init__(self, marque, chevaux):        self.marque = marque        self.moteur = Moteur(chevaux)    def demarrer(self):        bruit = self.moteur.demarrer()        return f"{self.marque} : {bruit}" ma_voiture = Voiture("Fiat", 70)print(ma_voiture.demarrer())
objet Voituremarque = "Fiat"moteurobjet Moteurchevaux = 70 appels sortie

Deux classes, aucun héritage. Voiture ne descend pas de Moteur : elle en contient un. Lisons-le.

Ligne 15 : Voiture("Fiat", 70). Python crée l’objet Voiture et lance son constructeur : self.marque = "Fiat".

Ligne 10, à droite du signe = : Moteur(chevaux). Un deuxième objet naît, un Moteur à 70 chevaux.

Ligne 10, le signe =. L’attribut moteur de la voiture désigne ce Moteur : voilà le « a un ». Le constructeur fini, ma_voiture désigne la voiture.

Ligne 16 : ma_voiture.demarrer(). La voiture ne sait pas faire « Vroum » : elle délègue à son moteur, ligne 12.

Ligne 13 : le résultat remonte. bruit vaut « Vroum », la voiture ajoute sa marque. Sortie : « Fiat : Vroum ».

Piège

Hériter pour récupérer du code. Si Voiture héritait de Moteur, la voiture aurait toutes les méthodes du moteur, et l’idée fausse qu’une voiture est un moteur.

« Un X est un Y » sonne faux ? Compose.

Exercice 4

Héritage ou composition ?

Range chaque paire dans la bonne case.

Est un : héritagel'un est un cas particulier de l'autre
A un : compositionl'un contient l'autre
Exercice 5

Écris la classe enfant

Remets les lignes dans l'ordre : Chat hérite d'Animal, laisse le parent gérer le nom et garde la couleur. Le programme doit afficher Tom gris.

  1. class Animal:
  2. def __init__(self, nom):
  3. self.nom = nom
  4. class Chat(Animal):
  5. def __init__(self, nom, couleur):
  6. super().__init__(nom)
  7. self.couleur = couleur
  8. tom = Chat("Tom", "gris")
  9. print(tom.nom, tom.couleur)

La fiche en six cartes

Hériter

L’enfant hérite du parent (class Chien(Animal), extends), ajoute ce qui lui est propre et redéfinit ce qu’il veut changer.

super

Appelle le parent : son constructeur (super().__init__, super(...)) ou une de ses méthodes.

Redéfinir ou surcharger

Override : même signature, dans l’enfant. Overload : même nom, autres paramètres. @Override fait vérifier la redéfinition.

Polymorphisme

La méthode exécutée est celle de l’objet réel ; en Java, le type déclaré décide de ce que le compilateur accepte.

Encapsulation

private et des méthodes qui vérifient. En Python, _x et __x sont des conventions, pas des verrous.

Abstraction, composition

Une classe abstraite ne s’instancie pas. Est un : héritage. A un : composition.

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.

Mon conseil : pour chaque appel de méthode, demande-toi d’abord si le compilateur l’accepte (type déclaré), puis quel objet le reçoit vraiment.

10 questions · zéro faute · chronomètre

Sources

  1. Python Software Foundation, Le tutoriel Python : Classes (héritage, variables privées), documentation Python 3, consultée en 2026. docs.python.org
  2. Oracle, The Java Tutorials : Abstract Methods and Classes, consulté en 2026. docs.oracle.com
  3. Oracle, The Java Tutorials : Overriding and Hiding Methods, consulté en 2026. docs.oracle.com
  4. Oracle, The Java Tutorials : Polymorphism, consulté en 2026. docs.oracle.com
  5. Oracle, The Java Tutorials : Controlling Access to Members of a Class, consulté en 2026. docs.oracle.com
  6. OpenJDK, JEP 513 : Flexible Constructor Bodies, livrée avec Java 25, 2025. openjdk.org
  7. Python Software Foundation, The Python Language Reference : Data model (object.__new__ et object.__init__), documentation Python 3, consultée en octobre 2026. docs.python.org

Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026. Les extraits de code ont été exécutés (Python 3.14, Java 21, Node 25, C++17).

Glisser pour continuer vers Prog 9 : Interfaces
Gymnase 3