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.
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.
La 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 ».
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.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…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.
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.
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 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".
You know how to build objects from a class. But in the factory above, nothing stops you from writing account.solde = 999999 directly, bypassing deposer(). That's exactly the problem the next pillar solves: encapsulation.