Ir al contenido

03. Orientation objet

Object-Oriented Programming (OOP) is a paradigm that is based on the development of programs in the creation and management of elements...

0vues

La programmation orientée objet (POO) est un paradigme qui repose sur le développement de programmes par la création et la gestion d'éléments indépendants appelés « objets », simulant des objets du monde réel. Chaque objet est responsable de tâches spécifiques et, par la création d'objets et l'interaction entre eux, l'exécution du programme progresse.

Actuellement, JavaScript prend en charge la POO aussi bien avec le système traditionnel de « prototypes » qu'avec la syntaxe moderne des classes introduite dans l'ES6.

La programmation orientée objet (POO) est un paradigme de programmation qui repose sur le développement de programmes basé sur la création et la gestion d'éléments indépendants appelés « objets », qui simulent des entités du monde réel. Chaque objet est responsable de tâches spécifiques et, grâce à l'interaction entre eux, l'exécution du programme progresse.

En JavaScript, la POO peut être appliquée de deux manières :

  • Le système de prototypes, où nous créons un littéral d'objet (Object Literal) prototype et les autres héritent de ce prototype.
  • La syntaxe de classe moderne (introduite en ES6), plus proche d'autres langages et que nous recommandons.

C'est la capacité de représenter une entité du monde réel sous une forme simplifiée dans le code. Cela est réalisé en définissant des classes qui modélisent les caractéristiques (propriétés) et les comportements (méthodes) des objets, tout en masquant les détails inutiles ou complexes.

C'est un modèle qui permet de créer des objets. Il définit la structure de l'objet en définissant des caractéristiques et des comportements.

C'est une instance d'une classe (un élément créé à partir d'une classe). Elle représente une entité du monde réel et dispose de caractéristiques (propriétés) et de comportements (méthodes) associés. Chaque objet peut avoir des valeurs de propriétés différentes, mais ils partagent les mêmes méthodes définies dans la classe.

C'est le mécanisme permettant de masquer les détails internes d'un objet (propriétés et méthodes), en n'exposant qu'une interface pour interagir avec lui. Grâce à des méthodes et des propriétés privées, nous contrôlons l'accès aux propriétés et aux méthodes d'un objet. L'encapsulation garantit l'intégrité des données et permet de masquer son implémentation (le code) de son utilisation externe.

Il permet de définir de nouvelles classes à partir de classes existantes (superclasse). Les nouvelles classes (sous-classes) héritent des propriétés et des méthodes de la classe parente. Elles peuvent également ajouter de nouvelles fonctionnalités ou modifier le comportement hérité. L'héritage est utile pour la réutilisation du code et l'établissement d'une hiérarchie de classes.

C'est la capacité d'un objet à répondre ou à se comporter différemment face à une même action ou méthode (en fonction du contexte). Cela permet à une méthode portant le même nom d'accomplir différentes tâches selon la classe qui l'implémente. Ce processus est mis en œuvre par l'héritage et la possibilité de redéfinir des méthodes dans les sous-classes.

Méthode constructeur : C'est une méthode spéciale qui s'exécute automatiquement lors de la création d'un objet. Elle sert à initialiser les propriétés de l'objet.

Propriétés: Variables qui représentent les caractéristiques ou l'état d'un objet. Elles peuvent être de types de données tels que des nombres, des booléens, des chaînes, des tableaux, d'autres objets, etc.

Méthodes: Fonctions qui définissent le comportement d'un objet. Elles peuvent recevoir des paramètres d'entrée, retourner des résultats et manipuler les propriétés de l'objet.

// Declaració d'una classe
class Jugador {
constructor(nom, vides) { // mètode constructor
this.nom = nom; // propietat
this.vides = vides;
this.posicio = 100;
this.punts = 0;
}
moureJugador() { // mètode públic
this.posicio += 5;
}
}

Nous exécuterons le code pour instancier et gérer des objets.

// Instanciació d'una classe
const jugador1 = new Jugador('Pepet', 3);
const jugador2 = new Jugador('Lucky', 5);
// Accés a propietats i ús de mètodes
console.log(`Nom Jugador 1:${jugador1.nom}`);
console.log(`Nom Jugador 2:${jugador2.nom}`);
jugador1.moureJugador();
jugador1.vides--;
for (let i = 0; i < 5; i++) {
jugador2.moureJugador();
}
console.log(`Vides Jugador 1:${jugador1.vides}`);
console.log(`Posicio Jugador 2:${jugador2.posicio}`);

Nous établirons l'héritage et le polymorphisme dans nos classes.

// Classe base que representa un personatge del joc
class Entitat {
constructor(nom, vides, posicio) {
this.nom = nom;
this.vides = vides;
this.posicio = posicio;
}
moure() {
this.posicio.x += 1;
this.posicio.y += 1;
}
}
// Herència: Jugador hereta propietats i mètodes d'Entitat
class Jugador extends Entitat {
constructor(nom, vides, posicio) {
super(nom, vides, posicio); // crida al constructor de la classe base
this.punts = 0; // propietat específica de Jugador
}
// Polimorfisme: Jugador redefineix el mètode moure() de la classe base
moure() {
this.posicio.y += 1; // Moviment vertical
}
// Mètode propi del Jugador
sumarPunts(enemic) {
this.punts += 10;
enemic.vides--;
}
}
// Herència: Enemic hereta propietats i mètodes d'Entitat
class Enemic extends Entitat {
constructor(nom, vides, nivell) {
super(nom, vides);
this.nivell = nivell; // propietat específica de Enemic
}
// Polimorfisme: Enemic redefineix el mètode moure() de la classe base
moure() {
this.posicio.x -= 1; // Moviment horitzontal
}
// Mètode propi de l'Enemic
atacar(jugador) {
jugador.vides--;
jugador.punts = jugador.punts - this.nivell;
}
}
const jugador = new Jugador('Jugador1', 3, { x: 100, y: 100 });
const enemic = new Enemic('Enemic1', 2, { x: 300, y: 500 }, 1);
jugador.moure();
enemic.moure();
jugador.sumarPunts(enemic);
enemic.atacar(jugador);
console.log(`Vides Jugador: ${jugador.vides} i Posició: ${jugador.posicio.y}`);
console.log(`Vides Enemic: ${enemic.vides} i Posició: ${enemic.posicio.x}`);