Classe
Le plan, écrit une seule fois : class Chien:
Programmation · Prog 7 · Les objets
Un plan écrit une fois, des objets fabriqués à volonté : chacun avec ses données et ses gestes.
Déjà à l'aise ? Aller directement au quizDans la vraie vie
Un architecte dessine le plan d’une maison une seule fois. Avec ce plan, on peut bâtir tout un quartier.
Même forme pour toutes ; chaque maison a sa couleur, ses habitants, son adresse.
Une classe, c’est ce plan. Un objet, c’est une maison.
La classe décrit les données (les attributs). Chaque objet fabriqué avec elle a ses propres valeurs.
Où l’image s’arrête
Un plan de maison ne sait rien faire. Une classe, si : elle range aussi des méthodes, des fonctions que tous ses objets partagent.
Un plan. Autant d’objets que tu veux.
Neuf variables pour trois personnages
Dans la vraie vie
Autour d’une table de jeu de rôle, chaque joueur tient la fiche de son personnage : un nom, des points de vie, une attaque.
Neuf post-it en vrac sur la table, et plus personne ne sait qui a combien de points de vie.
Sans classe, c’est le vrac.
Chaque donnée vit dans sa propre variable : joueur1_nom, joueur1_pv, joueur1_atk… Rien ne les relie, et rien n’empêche de mélanger le nom de l’un avec les points de vie de l’autre.
Les neuf variables se rangent : en groupes, puis en objets, puis sous une seule classe.
En vrac. Neuf variables pour trois personnages. Pour deux cents ennemis, il en faudrait six cents.
Où sont les valeurs, alors ?
Sans classe, les données et la fonction qui les manipule sont séparées :
joueur1_nom = "Link"
joueur1_pv = 100
joueur1_atk = 25
joueur2_nom = "Ganon"
joueur2_pv = 200
joueur2_atk = 40
def attaquer(atk, pv_cible):
return pv_cible - atk
joueur2_pv = attaquer(joueur1_atk,
joueur2_pv)Il faut passer chaque valeur à la main, et renvoyer le résultat dans la bonne variable.
Avec une classe, chaque objet transporte ses données et sait agir sur elles :
class Personnage:
def __init__(self, nom, pv, atk):
self.nom = nom
self.pv = pv
self.atk = atk
def attaquer(self, cible):
cible.pv -= self.atk
link = Personnage("Link", 100, 25)
ganon = Personnage("Ganon", 200, 40)
link.attaquer(ganon) # ganon.pv : 175Deux cents ennemis ? Deux cents appels à Personnage(...), souvent dans une boucle.
C’est la programmation orientée objet.
On organise le programme autour d’objets qui regroupent des données et les fonctions qui les manipulent. Python, Java, C#, JavaScript, Kotlin ou Swift permettent tous d’écrire des classes.
En Java, tout le code vit dans des classes, même main ; depuis Java 25, un petit programme peut omettre la déclaration de classe : le compilateur en crée une implicitement6.
Une classe, autant d’objets qu’on veut
Une classe, puis deux objets créés dans le tas. Les lignes s’allument au fil du défilement.
1. Python lit la classe. Il crée l'objet classe Chien, avec sa méthode __init__. Aucun chien n'existe encore.
2. Chien("Rex", 3), à droite du =. Appeler la classe crée un objet vide, de type Chien, dans le tas.
3. Python appelle __init__. self désigne le nouvel objet ; les paramètres nom et age reçoivent les arguments "Rex" et 3.
4. self.nom = nom, puis self.age = age. Les attributs sont créés dans l'objet ; les paramètres disparaîtront à la fin de l'appel.
5. Fin de __init__, qui ne renvoie rien. a reçoit une référence vers l'objet (la flèche), pas une copie.
6. b = Chien("Luna", 5). Un second objet, avec ses valeurs. __init__ reste rangée une seule fois, dans la classe.
Le plan, écrit une seule fois : class Chien:
Un exemplaire fabriqué avec ce plan : Chien("Rex", 3). Les deux mots désignent la même chose.
Une donnée rangée dans l’objet : nom, age. Chaque objet a ses propres valeurs.
Une fonction définie dans la classe, qui agit sur l’objet : anniversaire().
Ce que contient la variable a : le moyen de retrouver l’objet dans le tas, pas l’objet lui-même.
Les noms ont leurs conventions : PascalCase pour les classes, en Python comme en Java. Pour les attributs et les méthodes : snake_case en Python, camelCase en Java et en JavaScript.
Une classe CompteBancaire. Fais glisser chaque étiquette dans sa case (ou touche l'étiquette, puis la case).
Démonter un objet
Dans la vraie vie
Chez le vétérinaire, Rex a une puce avec un numéro unique, une espèce, un âge et un poids.
Et il sait aboyer, comme tous les chiens.
La documentation de Python le dit en une phrase : chaque objet a une identité, un type et une valeur, son état2.
Et le geste « aboyer » ? Il est rangé ailleurs. Démontons rex pour le voir.
Il se démonte en quatre pièces, puis se remonte.
Un seul objet… mais plusieurs pièces. Fais défiler pour le démonter.
Python permet de voir ces pièces :
rex = Chien("Rex", 3)
print(id(rex))
print(type(rex))
print(rex.__dict__)4372816976
<class '__main__.Chien'>
{'nom': 'Rex', 'age': 3}Le premier nombre n’est qu’un exemple : il change d’une exécution à l’autre. __dict__ ne contient que l’état.
Où l’image s’arrête
Un vrai chien porte ses gestes en lui. Un objet, non.
Ses méthodes sont rangées une seule fois, dans la classe, et tous les chiens les partagent.
is compare les identités.
a is b vaut True seulement si a et b désignent le même objet. On s’en sert au chapitre 6.
Chaque objet naît rempli
Dans la vraie vie
À la sortie de l’usine, chaque voiture reçoit sa marque, sa couleur, et un compteur à zéro.
Toutes passent par la même étape ; chacune en sort avec ses réglages.
Le constructeur fait ce travail : il remplit les attributs d’un nouvel objet avec les valeurs données à la création. En Python, c’est __init__ ; en Java et en JavaScript, le constructeur.
class Voiture:
def __init__(self, marque, couleur):
self.marque = marque
self.couleur = couleur
self.vitesse = 0
ma_voiture = Voiture("Tesla", "rouge")Trois attributs : deux viennent des arguments, le troisième démarre à 0.
Paramètres dans la définition, arguments dans l’appel, transmis dans l’ordre4. En Python, self reçoit l’objet tout seul : on ne l’écrit pas dans l’appel.
Python, Java, JavaScript, C# et C++ : la même classe, la même sortie.
class Voiture:
def __init__(self, marque, couleur):
# trois attributs, dont un qui part de 0
self.marque = marque
self.couleur = couleur
self.vitesse = 0
def accelerer(self, kmh):
self.vitesse += kmh
return f"Vitesse : {self.vitesse} km/h"
ma_voiture = Voiture("Tesla", "rouge")
print(ma_voiture.marque)
print(ma_voiture.accelerer(50))public class Voiture {
private String marque;
private String couleur;
private int vitesse = 0;
// Constructeur : nom de la classe,
// pas de type de retour
public Voiture(String marque, String couleur) {
this.marque = marque;
this.couleur = couleur;
}
public String accelerer(int kmh) {
this.vitesse += kmh;
return "Vitesse : " + vitesse + " km/h";
}
public String getMarque() {
return marque;
}
}
// Ailleurs, par exemple dans main :
Voiture maVoiture = new Voiture("Tesla", "rouge");
System.out.println(maVoiture.getMarque());
System.out.println(maVoiture.accelerer(50));class Voiture {
constructor(marque, couleur) {
this.marque = marque;
this.couleur = couleur;
this.vitesse = 0;
}
accelerer(kmh) {
this.vitesse += kmh;
return `Vitesse : ${this.vitesse} km/h`;
}
}
const maVoiture = new Voiture("Tesla", "rouge");
console.log(maVoiture.marque);
console.log(maVoiture.accelerer(50));public class Voiture {
// Propriétés
public string Marque { get; set; }
public string Couleur { get; set; }
public int Vitesse { get; private set; } = 0;
public Voiture(string marque, string couleur) {
Marque = marque;
Couleur = couleur;
}
public string Accelerer(int kmh) {
Vitesse += kmh;
return $"Vitesse : {Vitesse} km/h";
}
}
// Ailleurs, par exemple dans Main :
var maVoiture = new Voiture("Tesla", "rouge");
Console.WriteLine(maVoiture.Marque);
Console.WriteLine(maVoiture.Accelerer(50));class Voiture {
private:
std::string marque;
std::string couleur;
int vitesse = 0;
public:
Voiture(std::string m, std::string c)
: marque(m), couleur(c) {}
std::string accelerer(int kmh) {
vitesse += kmh;
return "Vitesse : " + std::to_string(vitesse) + " km/h";
}
std::string getMarque() const { return marque; }
};
// Ailleurs, par exemple dans main :
Voiture maVoiture("Tesla", "rouge");
std::cout << maVoiture.getMarque() << std::endl;
std::cout << maVoiture.accelerer(50) << std::endl;Tesla Vitesse : 50 km/h
On appelle la classe comme une fonction, sans new : Python crée l’objet, puis appelle __init__1, qui ne renvoie rien.
Le constructeur porte le nom de la classe, sans type de retour. new réserve la place de l’objet. Sans constructeur écrit, le compilateur en fournit un sans paramètre5.
La méthode constructor, une seule par classe, appelée par new.
Python et JavaScript donnent une valeur par défaut au niveau ; Java écrit un second constructeur.
class Joueur:
# niveau vaut 1 si on ne le donne pas
def __init__(self, nom, niveau=1):
self.nom = nom
self.niveau = niveau
self.pv = 100
self.inventaire = []
print(f"{nom} créé, niveau {niveau}")
hero = Joueur("Link")
boss = Joueur("Ganon", 50)public class Joueur {
private String nom;
private int niveau;
private int pv = 100;
public Joueur(String nom, int niveau) {
this.nom = nom;
this.niveau = niveau;
System.out.println(nom + " créé, niveau " + niveau);
}
// Second constructeur (surcharge) :
// il appelle le premier avec le niveau 1
public Joueur(String nom) {
this(nom, 1);
}
}
Joueur hero = new Joueur("Link");
Joueur boss = new Joueur("Ganon", 50);class Joueur {
constructor(nom, niveau = 1) {
this.nom = nom;
this.niveau = niveau;
this.pv = 100;
this.inventaire = [];
console.log(`${nom} créé, niveau ${niveau}`);
}
}
const hero = new Joueur("Link");
const boss = new Joueur("Ganon", 50);Link créé, niveau 1 Ganon créé, niveau 50
Piège : oublier un argument.
__init__ attend nom et age, mais l’appel ne donne qu’un nom :
rex = Chien("Rex")En Java, le programme ne compile même pas : aucun constructeur n’accepte un seul argument.
Touche la bonne réponse. L'explication s'affiche tout de suite.
Dans def __init__(self, nom, age):, que sont nom et age ?
Dans Chien("Luna", 5), que sont "Luna" et 5 ?
En Java, quelle ligne crée un objet ?
Que renvoie __init__ ?
Qui est self ?
Dans la vraie vie
Quand Léa dit « je », elle parle d’elle. Quand Tom dit « je », il parle de lui.
Le mot est le même ; la personne qu’il désigne dépend de celui qui parle.
self, c’est le « je » de l’objet. Dans une méthode, self désigne l’objet sur lequel on l’appelle.
En Java et en JavaScript, ce « je » s’appelle this.
a.anniversaire() se démonte : ce que Python exécute vraiment, puis ce que reçoit self.
Ce que tu écris. a.anniversaire() : on appelle la méthode sur l'objet désigné par a.
Premier paramètre de chaque méthode : a.anniversaire() équivaut à Chien.anniversaire(a)1. Le nom self n’est qu’une convention, que tout le monde suit.
this désigne l’objet sans figurer dans les paramètres. En Java, age++ veut dire this.age++ ; on écrit this.nom = nom; quand un paramètre porte le nom d’un attribut.
def anniversaire(): puis rex.anniversaire() : TypeError, 0 argument attendu, 1 reçu. Python a transmis l’objet, mais rien ne le reçoit.
Dans la méthode, age += 1 tout court désigne une variable locale qui n’existe pas : UnboundLocalError: cannot access local variable 'age'. Il faut self.age += 1.
subir_degats et gagner_xp modifient les attributs du joueur : en Python, en Java et en JavaScript.
class Joueur:
def __init__(self, nom):
self.nom = nom
self.pv = 100
self.xp = 0
def subir_degats(self, degats):
self.pv -= degats
if self.pv <= 0:
return f"{self.nom} est KO !"
return f"{self.nom} : {self.pv} PV restants"
def gagner_xp(self, points):
self.xp += points
return f"+{points} XP ! Total : {self.xp}"
hero = Joueur("Link")
print(hero.subir_degats(30))
print(hero.gagner_xp(100))public class Joueur {
private String nom;
private int pv = 100;
private int xp = 0;
public Joueur(String nom) {
this.nom = nom;
}
public String subirDegats(int degats) {
// pv veut dire this.pv
pv -= degats;
if (pv <= 0) {
return nom + " est KO !";
}
return nom + " : " + pv + " PV restants";
}
public String gagnerXp(int points) {
xp += points;
return "+" + points + " XP ! Total : " + xp;
}
}class Joueur {
constructor(nom) {
this.nom = nom;
this.pv = 100;
this.xp = 0;
}
subirDegats(degats) {
// en JavaScript, this est obligatoire
this.pv -= degats;
if (this.pv <= 0) {
return `${this.nom} est KO !`;
}
return `${this.nom} : ${this.pv} PV restants`;
}
gagnerXp(points) {
this.xp += points;
return `+${points} XP ! Total : ${this.xp}`;
}
}Link : 70 PV restants +100 XP ! Total : 100
Touche les lignes dans l'ordre pour écrire un programme qui fonctionne. Regarde aussi le décalage (l'indentation) : il dit à quel bloc appartient chaque ligne.
Que se passe-t-il à la dernière ligne ?
class Chien:
def __init__(self, nom):
self.nom = nom
def anniversaire():
print("Un an de plus !")
rex = Chien("Rex")
rex.anniversaire()Deux noms, un seul objet
L’ancienne valeur ?
Dans la vraie vie
Deux télécommandes pour une seule télé : change de chaîne avec l’une, l’écran change pour les deux.
Il n’y a pas deux télés, mais deux façons de joindre la même.
Une variable ne contient pas l’objet : elle contient une référence, le moyen de le retrouver dans le tas. Avec b = a, deux variables désignent le même objet.
Où l’image s’arrête : None, c’est une télécommande reliée à aucune télé. Appuyer sur un bouton provoque une erreur.
Quatre situations : alias, == ou is, passage à une fonction, None. Le code s’exécute ligne par ligne.
Et pour avoir un vrai double ?
copy.copy.Chien c = a; copie la référence, pas l’objet : même comportement qu’en Python.
== compare les références. equals() compare le contenu seulement si la classe le redéfinit. Pour les String, on compare toujours avec equals.
Java passe tout par valeur : pour un objet, la valeur copiée est la référence4. La méthode peut modifier l’objet, pas la variable de l’appelant. Python fait pareil : passage par affectation3.
Lire un attribut sur null lève une NullPointerException ; en Python, sur None, une AttributeError.
renommer modifie l’objet reçu ; remplacer ne change que sa variable locale.
def renommer(chien):
# modifie l'objet reçu
chien.nom = "Max"
def remplacer(chien):
# ne change que la variable locale
chien = Chien("Max", 1)
a = Chien("Rex", 3)
remplacer(a)
print(a.nom) # Rex
renommer(a)
print(a.nom) # Maxstatic void renommer(Chien chien) {
// modifie l'objet reçu
chien.nom = "Max";
}
static void remplacer(Chien chien) {
// ne change que la copie locale
chien = new Chien("Max", 1);
}
Chien a = new Chien("Rex", 3);
remplacer(a);
System.out.println(a.nom); // Rex
renommer(a);
System.out.println(a.nom); // MaxLa classe Chien est celle de la notion 2. Que va afficher chaque programme ?
a = Chien("Rex", 3)
b = a
b.age = 10
print(a.age)x = Chien("Rex", 3)
y = Chien("Rex", 3)
print(x == y, x is x)def vieillir(chien):
chien.age += 1
chien = Chien("Bébé", 0)
rex = Chien("Rex", 3)
vieillir(rex)
print(rex.nom, rex.age)Un seul exemplaire pour tous
Dans la vraie vie
À l’entrée d’un musée, un compteur au portique compte tous les visiteurs. Chaque visiteur, lui, a son propre billet.
Un compteur pour tout le monde, un billet par personne.
Un attribut de classe existe en un seul exemplaire, partagé par tous les objets : c’est le compteur. Un attribut d’instance existe en un exemplaire par objet : c’est le billet.
En Java, on le déclare static.
On crée deux chiens, puis on tombe dans le piège de self.nb.
nb est défini dans la classe. Il existe en un seul exemplaire, avant même qu'un chien soit créé.
Le même compteur, écrit dans les deux langages.
class Chien:
# attribut de classe : un seul exemplaire
nb = 0
def __init__(self, nom):
# attribut d'instance : un par objet
self.nom = nom
Chien.nb += 1
a = Chien("Rex")
b = Chien("Luna")
print(Chien.nb) # 2public class Chien {
// attribut de classe
static int nb = 0;
// attribut d'instance
String nom;
Chien(String nom) {
this.nom = nom;
nb++; // c'est Chien.nb
}
}
Chien a = new Chien("Rex");
Chien b = new Chien("Luna");
System.out.println(Chien.nb); // 2En Java, un attribut static appartient à la classe : tous les objets partagent le même, rangé à un seul endroit de la mémoire. On l’écrit de préférence Chien.nb, pour que ce soit clair.
Piège : une liste en attribut de classe.
Avec inventaire = [] écrit dans la classe, tous les joueurs partagent la même liste1.
Une liste propre à chaque objet se crée dans __init__ : self.inventaire = [].
Tout assembler
Dans la vraie vie
Au festival, chacun porte un badge : « Link, guerrier ». Sans badge, on ne verrait qu’un numéro de bracelet.
Le badge, c’est ce que la personne montre quand on lui demande qui elle est.
Par défaut, print(hero) affiche quelque chose comme <__main__.Personnage object at 0x…> : le type et une adresse. Pour un affichage lisible, la classe définit __str__ en Python, toString() en Java et en JavaScript.
Un petit combat : un héros frappe un monstre. Suis-le ligne par ligne, et regarde qui est self.
class Personnage: def __init__(self, nom): self.nom = nom self.pv = 100 self.attaque = 10 def attaquer(self, cible): cible.subir_degats(self.attaque) def subir_degats(self, degats): self.pv = max(0, self.pv - degats) def __str__(self): return f"{self.nom} : {self.pv} PV" hero = Personnage("Link")monstre = Personnage("Gobelin")hero.attaquer(monstre)print(monstre)
Une classe, trois méthodes. attaquer agit sur une cible, subir_degats retire des points de vie, __str__ présente l’objet.
Deux objets. hero et monstre sortent du même plan, avec 100 points de vie chacun.
hero.attaquer(monstre). Dans attaquer, self désigne hero et cible désigne monstre.
cible.subir_degats(10). Nouvelle méthode, nouvel objet : ici, self désigne monstre. Ses points de vie passent à 90.
print(monstre). Python appelle __str__, avec self = monstre : la console affiche « Gobelin : 90 PV ».
Les deux personnages s’attaquent jusqu’à ce que l’un tombe : en Python et en JavaScript.
class Personnage:
def __init__(self, nom, classe):
self.nom = nom
self.classe = classe
self.pv = 100
self.attaque = 10
def attaquer(self, cible):
cible.subir_degats(self.attaque)
return f"{self.nom} attaque {cible.nom} !"
def subir_degats(self, degats):
self.pv = max(0, self.pv - degats)
def est_vivant(self):
return self.pv > 0
def __str__(self):
return f"{self.nom} ({self.classe}) : {self.pv} PV"
hero = Personnage("Link", "Guerrier")
monstre = Personnage("Gobelin", "Monstre")
while hero.est_vivant() and monstre.est_vivant():
print(hero.attaquer(monstre))
print(monstre)
if monstre.est_vivant():
print(monstre.attaquer(hero))
print(hero)class Personnage {
constructor(nom, classe) {
this.nom = nom;
this.classe = classe;
this.pv = 100;
this.attaque = 10;
}
attaquer(cible) {
cible.subirDegats(this.attaque);
return `${this.nom} attaque ${cible.nom} !`;
}
subirDegats(degats) {
this.pv = Math.max(0, this.pv - degats);
}
estVivant() {
return this.pv > 0;
}
toString() {
return `${this.nom} (${this.classe}) : ${this.pv} PV`;
}
}
const hero = new Personnage("Link", "Guerrier");
const monstre = new Personnage("Gobelin", "Monstre");
while (hero.estVivant() && monstre.estVivant()) {
console.log(hero.attaquer(monstre));
console.log(String(monstre));
if (monstre.estVivant()) {
console.log(monstre.attaquer(hero));
}
}
console.log(String(hero));Link attaque Gobelin ! Gobelin (Monstre) : 0 PV Link (Guerrier) : 10 PV
Dans le combat ci-dessus, pourquoi Link termine-t-il avec 10 PV ?
Et la suite ?
La fiche en six cartes
Une classe est un plan ; un objet (une instance) est un exemplaire de ce plan, avec ses propres valeurs.
Une identité, un type et un état (ses attributs). Les méthodes sont rangées une seule fois, dans la classe.
__init__ en Python initialise les attributs. Paramètres dans la définition, arguments dans l’appel.
a.methode() revient à Classe.methode(a) : self (this) désigne l’objet appelé.
Une variable contient une référence : b = a ne copie pas l’objet. is (et == en Java) compare les identités.
Partagé par tous les objets (static en Java). Une liste propre à chaque objet se crée dans le constructeur.
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 les objets pas à pas en Java et en Python.
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).