Python
super().__init__(nom) exécute le constructeur du parent. Rien ne l’impose, mais sans cet appel, self.nom n’existe jamais7.
Programmation · Prog 8 · Les quatre piliers
Écrire le commun une seule fois, puis laisser chaque objet répondre à sa façon.
Déjà à l'aise ? Aller directement au quizUn chien, un chat, un chiot. Une seule ligne de code : a.parler().
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.
Un moyen de s’en souvenir, pas une règle du langage. On les prend un par un.
Animal contient un Chien. Quel parler() s’exécute ?Celui d’Animal, puisque la variable est un Animal ?
Écrire le commun une seule fois
Dans la vraie vie
Chez un constructeur, chaque modèle part du précédent.
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().
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.
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.
Un seul objet. Mais d'où viennent ses attributs et ses méthodes ? Fais défiler pour le démonter.
Et pour rio.parler(), laquelle est prise ?
Le parent d’abord
Dans la vraie vie
Une maison se construit du bas vers le haut.
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.
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())
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. »
super().__init__(nom) exécute le constructeur du parent. Rien ne l’impose, mais sans cet appel, self.nom n’existe jamais7.
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.
Quelques instructions qui n’utilisent pas encore l’objet peuvent précéder super(...), par exemple pour vérifier un argument6.
Dans le constructeur d’une classe enfant, super(...) doit être appelé avant d’utiliser this, sinon ReferenceError.
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.
Python, rex.manger()AttributeError: 'Chien' object has no attribute 'nom'
Java, à la compilationerror: constructor Animal in class Animal cannot be applied to given types;
Touche Python, Java, JavaScript, C# ou C++ : l’idée reste la même, seule l’écriture change.
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 Chienclass 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.";
}
}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.`;
}
}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.";
}
}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.";
}
};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.
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.
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.
Le même Chiot qui réutilise la version de Chien : touche Python, Java ou JavaScript.
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)class Chien extends Animal {
@Override
public String parler() {
return "Wouf !";
}
}
class Chiot extends Chien {
@Override
public String parler() {
return super.parler() + " (petit)";
}
}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.
Dans la classe enfant, même nom et mêmes paramètres : la nouvelle version remplace celle du parent pour cet objet.
Même nom, paramètres différents : parler() et parler(int fois) coexistent (voir Prog 5).
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.
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 ! »
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.
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.
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.
parler() de Chien. Java part toujours de l’objet réel.Alors le type déclaré ne sert à rien ?
a reste un Animal, donc a.rapporter() est refusé.Le compilateur accepte a.rapporter() seulement si la classe Animal possède rapporter(). Sinon : erreur, même si l’objet est un Chien.
La machine virtuelle appelle la méthode de l’objet réellement désigné : c’est l’invocation virtuelle, ou liaison dynamique4.
On vérifie et on convertit d’abord : if (a instanceof Chien c) c.rapporter();
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 liste qui mélange quatre classes, et une seule ligne pour les faire 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.
Un guerrier et un mage héritent de Personnage et redéfinissent attaquer(). Touche Python ou JavaScript.
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")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`);
}Conan inflige 25 dégâts Gandalf inflige 40 dégâts
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.
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.
Un objet CompteBancaire et quatre tentatives, dont deux interdites. Fais défiler : chaque appel frappe à une porte.
Un compte, un solde privé. Trois méthodes publiques servent de guichets.
Le même compte bancaire dans les deux langages : touche Java ou Python.
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;
}
}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)) # FalseEn Java, quatre niveaux d’accès, du plus fermé au plus ouvert.
« Sous-classe ailleurs » : une sous-classe rangée dans un autre paquetage5.
privateRéservé à la classe elle-même. Même une sous-classe passe par une méthode comme getSolde().
(rien)Sans mot-clé : toutes les classes du même paquetage, y compris les sous-classes qui s’y trouvent.
protectedLe paquetage, plus les sous-classes rangées dans un autre paquetage.
publicAucune 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.
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.
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.
Fais défiler : on essaie de créer une Forme, puis un Rectangle, un Cercle et un Carré qui a oublié sa formule.
Forme déclare aire() sans la coder. Le point d'interrogation dit : « chaque sous-classe donnera sa formule ».
Une classe abstraite et ses sous-classes concrètes dans les deux langages.
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.57abstract 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.0Une 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.
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.
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.
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.
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())
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.
Range chaque paire dans la bonne case.
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.
La fiche en six cartes
L’enfant hérite du parent (class Chien(Animal), extends), ajoute ce qui lui est propre et redéfinit ce qu’il veut changer.
Appelle le parent : son constructeur (super().__init__, super(...)) ou une de ses méthodes.
Override : même signature, dans l’enfant. Overload : même nom, autres paramètres. @Override fait vérifier la redéfinition.
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.
private et des méthodes qui vérifient. En Python, _x et __x sont des conventions, pas des verrous.
Une classe abstraite ne s’instancie pas. Est un : héritage. A un : composition.
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
Les vidéos de Graven, en français, reprennent l’héritage pas à pas en Python et en Java.
object.__new__ et object.__init__), documentation Python 3, consultée en octobre 2026. docs.python.orgFiche 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).