poo simple

La programmation orientée objet est un paradigme de programmation qui permet de modéliser des concepts du monde réel en utilisant des objets. Les objets sont des instances de classes, qui encapsulent des données et des méthodes qui manipulent ces données. En JavaScript, la POO est mise en œuvre à l’aide de prototypes, qui sont des objets qui servent de modèle pour créer d’autres objets.

Dans cet article, nous allons approfondir la programmation orientée objet en JavaScript en explorant les concepts de base de la POO, tels que l’encapsulation, l’héritage et la polymorphie, ainsi que des exemples pratiques pour illustrer ces concepts.

Encapsulation

L’encapsulation est un concept clé de la POO qui permet de cacher la complexité interne d’un objet et de ne montrer que son interface publique. En JavaScript, l’encapsulation est mise en œuvre à l’aide de fonctions constructrices et de la notation pointée.

function Person(name, age) {
 var _name = name;
 var _age = age; 

this.getName = function() {
 return _name;
 };

 this.getAge = function() {
 return _age; 
}; 

this.setAge = function(age) {
_age = age; }; 
}

 var john = new Person("John", 30);
 console.log(john.getName()); // affiche "John"
 console.log(john.getAge()); // affiche 30
 john.setAge(35);
 console.log(john.getAge()); // affiche 35 

Dans cet exemple, nous avons défini une fonction constructrice Person qui prend deux paramètres, name et age, et crée un objet qui a deux propriétés privées, _name et _age, ainsi que trois méthodes publiques, getName, getAge et setAge. Les méthodes getName et getAge permettent d’accéder aux propriétés privées _name et _age, respectivement, tandis que la méthode setAge permet de modifier la propriété _age.

L’héritage

L’héritage est un concept clé de la POO qui permet à une classe de dériver des propriétés et des méthodes d’une autre classe. En JavaScript, l’héritage est mis en œuvre à l’aide de prototypes et de la méthode Object.create().

function Animal(name) {
 this.name = name;
 } 

Animal.prototype.getName = function() { 
return this.name;
 };

function Dog(name, breed) {
 Animal.call(this, name); 
this.breed = breed; 
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.getBreed = function() { 
   return this.breed; 
};

var myDog = new Dog("Rufus", "Labrador");
 console.log(myDog.getName()); // affiche "Rufus" 
console.log(myDog.getBreed()); // affiche "Labrador" 

Dans cet exemple, nous avons défini deux fonctions constructrices, Animal et Dog. La fonction constructrice Animal crée un objet qui a une propriété name et une méthode getName. La fonction constructrice Dog dérive de la fonction constructrice Animal à l’aide de la méthode call() pour initialiser la propriété name de l’objet Dog, et ajoute une propriété breed et une méthode getBreed à l’objet Dog.

Pour mettre en œuvre l’héritage, nous avons utilisé la méthode Object.create() pour créer un nouvel objet qui a le prototype de la fonction constructrice Animal. Nous avons ensuite défini le prototype de la fonction constructrice Dog comme étant cet objet, afin que l’objet Dog hérite des propriétés et des méthodes définies dans l’objet Animal. Enfin, nous avons réinitialisé le prototype de la fonction constructrice Dog en lui assignant sa propre fonction constructrice, pour éviter que la propriété constructor de l’objet Dog ne pointe vers la fonction constructrice Animal.

La polymorphie

La polymorphie est un concept clé de la POO qui permet à des objets de même type d’avoir des comportements différents. En JavaScript, la polymorphie est mise en œuvre à l’aide de la redéfinition de méthodes.

function Animal(name) {
this.name = name;
}

Animal.prototype.makeSound = function() { 
console.log("Le son de l'animal est inconnu.");
};

function Dog(name) {
Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.makeSound = function() { 
console.log("Le chien aboie.");
 };

function Cat(name) { 
Animal.call(this, name);
}

Cat.prototype = Object.create(Animal.prototype); 
Cat.prototype.constructor = Cat;
Cat.prototype.makeSound = function() {
console.log("Le chat miaule.");
};

var myDog = new Dog("Rufus");
var myCat = new Cat("Minou");
var myAnimals = [myDog, myCat];

for (var i = 0; i < myAnimals.length; i++) { 
myAnimals[i].makeSound();
} 

Dans cet exemple, nous avons défini deux fonctions constructrices, Dog et Cat, qui dérivent de la fonction constructrice Animal. La fonction constructrice Animal crée un objet qui a une propriété name et une méthode makeSound qui affiche un message par défaut.

Les fonctions constructrices Dog et Cat redéfinissent la méthode makeSound pour afficher des messages spécifiques à chaque type d’animal.

Ensuite, nous avons créé deux objets, un chien et un chat, et les avons stockés dans un tableau d’animaux. Nous avons ensuite parcouru le tableau et appelé la méthode makeSound de chaque objet, qui a affiché le message spécifique à chaque type d’animal.

Conclusion

La programmation orientée objet est un paradigme de programmation puissant qui permet de modéliser des concepts du monde réel en utilisant des objets. En JavaScript, la POO est mise en œuvre à l’aide de prototypes, qui sont des objets qui servent de modèle pour créer d’autres objets.

Dans cet article, nous avons exploré les concepts de base de la POO en JavaScript, tels que l’encapsulation, l’héritage et la polymorphie. Nous avons également fourni des exemples pratiques pour illustrer ces concepts.

En utilisant la programmation orientée objet, les développeurs peuvent écrire du code plus modulaire, plus facile à maintenir et à réutiliser, ce qui peut réduire les coûts et les délais de développement. Par conséquent, il est important pour les développeurs de maîtriser la POO en JavaScript, afin de pouvoir écrire des applications de qualité supérieure et de répondre aux exigences du marché.

0 commentaires

Soumettre un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *