Classes en Programmation : Construire les Fondations de Votre Code
Salut HaWker ! Jeff Bruchado par ici.
C'est un autre article de notre serie d'articles qui va couvrir notre voyage pour Apprendre la Programmation depuis Zero.
Bon, les Classes dans le monde de la programmation sont comme les personnages principaux d'un film, chacune avec son propre ensemble de caracteristiques et de competences.
En JavaScript, une classe est comme un moule pour creer des objets. C'est une facon de definir des caracteristiques (proprietes) et des actions (methodes) qu'un certain type d'objet aura.
Pourquoi plonger dans le monde des Classes est une bonne idee ?
- Organisation : Les classes aident a organiser votre code. C'est comme avoir differents chapitres dans un livre, chacun racontant une partie de l'histoire.
- Reutilisation : Avec les classes, vous creez un modele une fois et le reutilisez pour creer autant d'objets que vous voulez. Comme faire plusieurs copies d'une cle passe-partout.
- Heritage : Les classes peuvent heriter des caracteristiques d'autres classes. Cela signifie moins de code repete et une structure plus claire.
- Encapsulation : Les classes permettent d'encapsuler les donnees, ce qui signifie que vous pouvez cacher les details internes et ne montrer que le necessaire pour l'utilisation externe.
Mais Jeff, comment fonctionnent les Classes en JavaScript ?
Definition
Vous commencez par definir une classe avec le mot-cle class, suivi du nom de la classe. A l'interieur, vous definissez les proprietes et les methodes.
Constructeur
A l'interieur d'une classe, vous pouvez avoir une methode speciale appelee constructor. Cette methode est appelee lorsque vous creez un nouvel objet de la classe. C'est-a-dire, elle est toujours appelee lors de l'instanciation d'une classe.
Instance d'Objets
Apres avoir defini une classe, vous pouvez creer des objets (instances) de cette classe en utilisant le mot-cle new.
Heritage
Avec extends, une classe peut heriter des proprietes et des methodes d'une autre classe. C'est-a-dire, vous pouvez creer des classes et les fusionner avec d'autres classes.
Par exemple :
class Animal {
constructor(nom) {
this.nom = nom;
}
parler() {
console.log(`${this.nom} fait un son.`);
}
}
class Chien extends Animal {
parler() {
console.log(`${this.nom} aboie.`);
}
}
let monChien = new Chien('Rex');
monChien.parler(); // Rex aboie.Dans cet exemple, Animal est une classe avec une methode parler(). Chien est une sous-classe de Animal et a sa propre version de la methode parler().
Alors, voyez :
Les classes sont comme des squelettes qui donnent forme et fonction aux objets dans votre code. Elles sont super utiles pour garder tout organise, reutilisable et facile a maintenir. C'est comme avoir un ensemble d'outils que vous personnalisez pour construire plusieurs choses differentes, mais toutes avec la meme base.
Genial, non ? Approfondissons davantage.
Classes
C'est une facon de definir un modele pour un objet, dans des explications plus anciennes, c'est basiquement l'abstraction d'entites du monde reel dans le monde virtuel.
C'est une facon de definir les proprietes et comportements (methodes) qu'un objet doit avoir, de maniere que vous puissiez creer plusieurs objets qui sont de la meme "categorie", avec les memes caracteristiques.
Voici un exemple de classe :
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
}Dans cet exemple, nous creons une classe appelee "Person", qui possede deux attributs (name et age) et une methode (greet).
La methode "constructor" est une methode speciale qui est appelee lorsque vous creez un nouvel objet a partir de cette classe. C'est-a-dire, cette methode va realiser la construction de votre Object.
Pour creer un nouvel objet a partir de cette classe, vous pouvez faire ainsi :
const person1 = new Person('Jefferson', 25);
const person2 = new Person('Lucas', 40);Avec cela, vous pouvez acceder aux proprietes et methodes de ces objets de la facon suivante :
console.log(person1.name); // Jefferson
console.log(person2.age); // 40
person1.greet(); // Hello, my name is Jeff and I am 25 years old.
person2.greet(); // Hello, my name is Lucas and I am 40 years old.En plus de la methode "constructor" que j'ai deja mentionnee, les classes peuvent aussi avoir d'autres methodes.
Par exemple :
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
incrementAge() {
this.age += 1;
}
}
const person1 = new Person('Jefferson', 25);
person1.incrementAge();
console.log(person1.age); // 26Dans cet exemple, nous creons une classe "Person" avec deux methodes : "greet" et "incrementAge". La methode "incrementAge" incremente l'age de la personne de 1.
Une autre chose importante a savoir est que les classes sont des "constructeurs", c'est-a-dire, vous pouvez les utiliser pour creer de nouveaux objets en utilisant le mot-cle "new".
Par exemple :
const person1 = new Person('Jeff', 25);
const person2 = new Person('John', 40);Ces objets crees a partir de la classe "Person" sont appeles "instances" de la classe.
Ils possedent toutes les proprietes et methodes definies dans la classe, mais chacun a ses propres valeurs pour ces proprietes.
De plus, il est possible de creer de nouvelles classes qui "etendent" d'autres classes.
Cela signifie que la nouvelle classe aura toutes les proprietes et methodes de la classe parente, et peut aussi avoir des proprietes et methodes supplementaires.
Par exemple :
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
incrementAge() {
this.age += 1;
}
}
class Student extends Person {
constructor(name, age, major) {
super(name, age); // appelle le constructeur de la classe parente
this.major = major;
}
study() {
console.log(`I am studying ${this.major}.`);
}
}
const student1 = new Student('Jeff', 25, 'Computer Science');
student1.greet(); // Hello, my name is Jeff and I am 25 years old.
student1.study(); // I am studying Computer Science.Dans cet exemple, nous creons une classe "Student" qui etend la classe "Person".
La classe "Student" a un nouvel attribut (major) et une nouvelle methode (study).
Dans le constructeur de la classe "Student", nous appelons le constructeur de la classe parente en utilisant le mot-cle "super".
Bon, precedemment j'ai mentionne le mot super, et ensuite nous allons comprendre plus en detail comment le super fonctionne.
Super
Le "super" est un mot-cle utilise a l'interieur d'une classe qui etend une autre classe (c'est-a-dire, qui est une "sous-classe").
Il se refere au constructeur de la classe parente (ou "superclasse").
Quand vous creez une sous-classe, il est courant qu'elle ait un constructeur propre, qui doit appeler le constructeur de la classe parente pour initialiser les proprietes de la sous-classe.
Pour faire cela, vous pouvez utiliser le "super" comme une methode, en passant les arguments necessaires.
Par exemple :
class Person {
constructor(name, age) {
this.name = name;
this.age = age;
}
greet() {
console.log(
`Hello, my name is ${this.name} and I am ${this.age} years old.`
);
}
}
class Student extends Person {
constructor(name, age, major) {
super(name, age); // appelle le constructeur de la classe parente
this.major = major;
}
study() {
console.log(`I am studying ${this.major}.`);
}
}
const student1 = new Student('Jeff', 25, 'Computer Science');
student1.greet(); // Hello, my name is Jeff and I am 25 years old.
student1.study(); // I am studying Computer Science.Dans cet exemple, la classe "Student" etend la classe "Person".
Dans le constructeur de la classe "Student", nous appelons le constructeur de la classe parente en utilisant "super(name, age)".
Cela initialise les proprietes "name" et "age" de la sous-classe.
En plus d'etre utilise dans le constructeur d'une sous-classe, "super" peut aussi etre utilise pour acceder aux methodes de la classe parente.
Par exemple :
class Person {
constructor(name) {
this.name = name;
}
greet() {
console.log(`Hello, my name is ${this.name}.`);
}
}
class FriendlyPerson extends Person {
greet() {
super.greet(); // appelle la methode greet de la classe parente
console.log("It's nice to meet you!");
}
}
const friendlyPerson1 = new FriendlyPerson('Jeff');
friendlyPerson1.greet();
// Output:
// Hello, my name is Jeff.
// It's nice to meet you!Dans cet exemple, la classe "FriendlyPerson" etend la classe "Person" et a une methode "greet" propre.
Cependant, la methode "greet" de la classe "FriendlyPerson" appelle aussi la methode "greet" de la classe parente en utilisant "super.greet()".
Cela permet a la classe "FriendlyPerson" d'heriter le comportement de la methode "greet" de la classe parente (Person) et d'ajouter un comportement supplementaire.
En plus d'etre utilise dans le constructeur et dans les methodes d'une sous-classe, "super" peut aussi etre utilise pour acceder aux proprietes de la classe parente.
Par exemple :
class Person {
constructor(name) {
this.name = name;
}
}
class Student extends Person {
constructor(name, major) {
super(name);
this.major = major;
}
getDescription() {
return `${super.name} is studying ${this.major}.`;
}
}
const student1 = new Student('Jeff', 'Computer Science');
console.log(student1.getDescription()); // Jeff is studying Computer Science.Dans cet exemple, la classe "Student" etend la classe "Person" et a une methode "getDescription" qui retourne une chaine avec le nom et la specialite de l'etudiant.
Dans la methode "getDescription", nous utilisons "super.name" pour acceder a la propriete "name" de la classe parente.
Conclusion
En resume, les classes sont un outil puissant pour le developpement parce qu'elles vous permettent de creer des objets qui possedent des proprietes et des methodes.
Elles fournissent une maniere d'organiser et de structurer votre code de facon plus claire et facile a comprendre. De plus, les classes permettent aussi de creer l'heritage, ce qui signifie que vous pouvez creer de nouvelles classes basees sur des classes existantes, en partageant leurs proprietes et methodes.
La connaissance des classes est importante parce qu'elle peut aider a rendre votre code plus organise et facile a comprendre.
Eh bien HaWker, nous arrivons a la fin d'un autre article.
Comme toujours, si vous avez une question ou voulez explorer un point plus en detail, repondez simplement avec votre question, dans cet email.
Et rappelez-vous, je suis la pour vous aider a vous ameliorer de 1% a chaque nouvel article !
Si vous etes arrive jusqu'ici, comme d'habitude, s'il vous plait, repondez a cet email avec "J'ai reussi a comprendre les Classes en Programmation".
Ainsi je saurai que cette serie d'articles vous est utile, et que vous suivez et profitez.
Comme vous le savez deja ! Seul un veritable HaWker arrive jusqu'a la fin.
Felicitations !
Je suis content de vous avoir ici.
A bientot.
C'est parti !
- Jeff Bruchado
Felicitations d'etre arrive jusqu'ici, HaWker !
A ce moment ou vous avez appris les classes en programmation, que diriez-vous de tester vos connaissances ? Participez au quiz ci-dessous et voyez combien vous avez absorbe de notre article.
C'est une excellente facon de consolider l'apprentissage et de vous preparer pour les prochaines etapes de votre voyage de programmation.
Bonne chance et amusez-vous !