Un objet, d'accord. Mais comment en faire mille ?
À la leçon précédente, on a vu qu'un objet regroupe des propriétés (ses données) et des méthodes (ce qu'il sait faire). Très bien pour un compte. Mais un vrai site en a des milliers, tous bâtis sur le même modèle. On ne va pas réécrire le code de zéro pour chaque client. Il nous faut un plan, un moule, qu'on réutilise autant de fois qu'on veut.
Ce moule, c'est la classe. Et chaque objet fabriqué à partir d'elle, c'est une instance.
La classe est le moule, l'objet est le gâteau
C'est la distinction qui bloque tout le monde au début, alors prenons une image qui ne te lâchera plus. Un moule à gâteau, ce n'est pas un gâteau : on ne peut pas le manger. C'est une forme, une description de ce que seront les gâteaux. Avec un seul moule, tu fais autant de gâteaux que tu veux, et chacun est distinct : celui-ci au chocolat, celui-là à la vanille, mais tous ont la même forme.
- La classe = le moule. Elle décrit les propriétés (quelles données) et les méthodes (quelles actions), une bonne fois. On l'écrit une seule fois.
- L'objet (ou instance) = le gâteau. C'est une chose concrète, fabriquée à partir de la classe, avec ses propres valeurs.
En code : définir la classe, créer les objets
En pseudo-code (valable presque partout) : on décrit la classe, puis le mot-clé new fabrique une instance. Le constructeur est la recette qui « remplit le moule » au moment de la création.
On crée compteAlice = new Compte("Alice") et compteBob = new Compte("Bob"), puis on fait compteAlice.deposer(120). Avant de dérouler : que valent compteAlice.solde et compteBob.solde juste après ? Et qu'est-ce qui empêche le dépôt d'Alice de toucher le solde de Bob ?
Voir la réponse
compteAlice.solde vaut 120, compteBob.solde vaut 0. Chaque new fabrique un objet indépendant, avec sa propre case solde en mémoire. Quand deposer écrit this.solde += montant, le this désigne l'objet sur lequel on a appelé la méthode : ici Alice. L'objet de Bob n'est jamais touché, son solde reste à sa valeur de départ. C'est exactement ce qu'un seul objet réutilisé ne saurait pas faire.
classe Compte:
propriété titulaire
propriété solde
constructeur(titulaire): // appelé par "new", remplit l'objet
this.titulaire = titulaire
this.solde = 0
méthode deposer(montant):
this.solde = this.solde + montant
// On fabrique des objets DISTINCTS à partir de la même classe :
compteAlice = new Compte("Alice")
compteBob = new Compte("Bob")
compteAlice.deposer(120)
// compteAlice.solde vaut 120 ; compteBob.solde vaut toujours 0Le mot this (ou self selon les langages) désigne l'objet en train d'être manipulé : « mon propre solde », pas celui du voisin. C'est ce qui fait que chaque compte est indépendant.
Le pseudo-code ci-dessus, en vrai JavaScript, se lance tel quel. Clique sur Run, vérifie ta prédiction, puis mets les mains dedans : change le montant, ajoute un compteCharlie, déclenche un dépôt sur lui et observe que les autres soldes ne bougent pas.
class Compte {
constructor(titulaire) {
this.titulaire = titulaire;
this.solde = 0;
}
deposer(montant) {
this.solde += montant;
}
}
const compteAlice = new Compte("Alice");
const compteBob = new Compte("Bob");
compteAlice.deposer(120);
console.log(compteAlice.titulaire, "→", compteAlice.solde); // Alice → 120
console.log(compteBob.titulaire, "→", compteBob.solde); // Bob → 0La fabrique d'objets (essaie !)
Voici une vraie classe qui tourne dans ton navigateur. Donne un nom, clique sur new Compte(...), et regarde : chaque objet créé est autonome, avec son propre solde. Une seule classe, autant d'objets que tu veux.
class Compte {
constructor(titulaire) {
this.titulaire = titulaire;
this.solde = 0;
}
deposer(m) { this.solde += m; }
retirer(m) { if (m <= this.solde) this.solde -= m; }
}
0 objet(s) créé(s) depuis la même classe
Une classe, mille objets indépendants
C'est tout l'intérêt : tu écris la logique une fois (dans la classe), et tu la réutilises pour des milliers d'objets, chacun avec son état. Déposer sur le compte d'Alice ne touche pas celui de Bob, parce que this.solde pointe vers cet objet-là. C'est aussi ce qui rend le code testable : on peut créer un objet isolé et vérifier qu'il se comporte bien.
Vocabulaire : « créer un objet à partir d'une classe » se dit instancier. Un objet est donc une instance de sa classe. Tu entendras les deux mots tout le temps. Maintenant tu sais que ça veut juste dire « un gâteau sorti du moule ».
An object, fine. But how do you make a thousand?
In the previous lesson, we saw that an object groups properties (its data) and methods (what it can do). Great for one account. But a real site has thousands, all built on the same model. We're not going to rewrite the code from scratch for each customer. We need a blueprint, a mold, that we reuse as many times as we want.
That mold is the class. And each object built from it is an instance.
The class is the mold, the object is the cake
This is the distinction that trips everyone up at first, so here's an image that will stick. A cake mold is not a cake: you can't eat it. It's a shape, a description of what the cakes will be. With a single mold, you bake as many cakes as you want, and each is distinct: this one chocolate, that one vanilla, but all share the same shape.
- The class = the mold. It describes the properties (which data) and the methods (which actions), once. You write it a single time.
- The object (or instance) = the cake. A concrete thing, built from the class, with its own values.
In code: define the class, create the objects
In pseudo-code (valid almost everywhere): you describe the class, then the keyword new builds an instance. The constructor is the recipe that "fills the mold" at creation time.
We create aliceAccount = new Account("Alice") and bobAccount = new Account("Bob"), then call aliceAccount.deposit(120). Before you expand: what are aliceAccount.balance and bobAccount.balance right after? And what stops Alice's deposit from touching Bob's balance?
See the answer
aliceAccount.balance is 120, bobAccount.balance is 0. Each new builds an independent object with its own balance slot in memory. When deposit runs this.balance += amount, this refers to the object the method was called on: here, Alice. Bob's object is never touched, so its balance stays at its starting value. That's exactly what a single reused object could never do.
class Account:
property owner
property balance
constructor(owner): // called by "new", fills the object
this.owner = owner
this.balance = 0
method deposit(amount):
this.balance = this.balance + amount
// We build DISTINCT objects from the same class:
aliceAccount = new Account("Alice")
bobAccount = new Account("Bob")
aliceAccount.deposit(120)
// aliceAccount.balance is 120 ; bobAccount.balance is still 0The word this (or self depending on the language) refers to the object currently being handled: "my own balance", not the neighbor's. That's what makes each account independent.
The pseudo-code above runs as is in real JavaScript. Hit Run, check your prediction, then get your hands dirty: change the amount, add a charlieAccount, trigger a deposit on it, and watch the other balances stay put.
class Account {
constructor(owner) {
this.owner = owner;
this.balance = 0;
}
deposit(amount) {
this.balance += amount;
}
}
const aliceAccount = new Account("Alice");
const bobAccount = new Account("Bob");
aliceAccount.deposit(120);
console.log(aliceAccount.owner, "→", aliceAccount.balance); // Alice → 120
console.log(bobAccount.owner, "→", bobAccount.balance); // Bob → 0The object factory (try it!)
Here's a real class running in your browser. Enter a name, click new Compte(...), and watch: each created object is independent, with its own balance. One class, as many objects as you want.
class Compte {
constructor(titulaire) {
this.titulaire = titulaire;
this.solde = 0;
}
deposer(m) { this.solde += m; }
retirer(m) { if (m <= this.solde) this.solde -= m; }
}
0 objects created from the same class
One class, a thousand independent objects
That's the whole point: you write the logic once (in the class), and reuse it for thousands of objects, each with its own state. Depositing into Alice's account doesn't touch Bob's, because this.balance points to that object. It also makes code testable: you can create an isolated object and check it behaves.
Vocabulary: "creating an object from a class" is called instantiating. An object is therefore an instance of its class. You'll hear both words constantly — now you know it just means "a cake out of the mold".
🎯 Pratique
S'entraîner (clique pour ouvrir) :
🧠 Rappel libre
Sans remonter dans la leçon : avec tes mots, quelle est la différence entre une classe et un objet (une instance) ? Et après new Compte("Alice"), à quoi sert this dans la méthode deposer() ?
new, avec ses propres valeurs. À partir d'une classe on instancie autant d'objets qu'on veut. Dans deposer(), this désigne l'objet sur lequel on appelle la méthode : this.solde c'est « le solde de CET objet-là ». C'est pour ça que déposer sur Alice ne touche pas Bob.⚖️ Juge le code de l'IA
Tu demandes à l'IA de gérer plusieurs clients. Elle te propose ce code. Ton rôle de relecteur : l'accepter tel quel ou le rejeter, et dire pourquoi.
// Un seul objet "compte" qu'on réutilise pour chaque client
const compte = { titulaire: "", solde: 0 };
function nouveauClient(nom, depot) {
compte.titulaire = nom; // on écrase l'ancien
compte.solde = depot;
return compte;
}
const alice = nouveauClient("Alice", 120);
const bob = nouveauClient("Bob", 0);
// alice et bob pointent vers le MÊME objet…nouveauClient("Bob"…) écrase les valeurs d'Alice, et alice comme bob pointent vers le même objet. Résultat : alice.solde vaut 0, le solde de Bob. Il manque la vraie instanciation. La bonne version : une class Compte et un new Compte(nom) par client, pour que chaque objet ait son propre état indépendant.new Compte("Alice") et new Compte("Bob"), si on dépose sur le compte d'Alice…class Joueur initialise this.score = 0 dans son constructeur. On crée j1 = new Joueur() et j2 = new Joueur(), puis on fait j1.score = 100. Que vaut j2.score, et pourquoi ?Tu sais fabriquer des objets à partir d'une classe. Mais dans la fabrique ci-dessus, rien n'empêche d'écrire compte.solde = 999999 directement, sans passer par deposer(). C'est exactement le problème que règle le prochain pilier : l'encapsulation.
Leçon 3 : L'encapsulation →