Mon parcours React : jour 15

Programmation Orientée Objet (POO)
La programmation orientée objet est un paradigme de programmation basé sur le concept d'objets.

Principes clés de la POO
1.Encapsulation :

• Regroupe les variables et fonctions associées dans un objet.
• Encourage moins de paramètres dans les fonctions, réduisant ainsi la complexité. Exemple:

function Circle(radius) {
    this.radius = radius;
    this.draw = function() {
        console.log('draw');
    };
}
const circle = new Circle(5);
console.log(circle.radius); // Access encapsulated property
circle.draw(); // Call encapsulated method

2.Abstraction :

Cache les détails et la complexité, n'exposant que les parties nécessaires d'un objet.
Simplifie l'interface et réduit l'impact des modifications dans le code sous-jacent.
Exemple : Abstraction des méthodes tout en masquant la logique interne.

3.Héritage :

Permet à une classe (enfant) d'hériter des propriétés et des méthodes d'une autre classe (parent).
Réduit le code redondant.
Exemple :

class Animal {
    eat() {
        console.log("This animal is eating.");
    }
}
class Dog extends Animal {
    bark() {
        console.log("The dog is barking.");
    }
}
const dog = new Dog();
dog.eat(); // Inherited from Animal
dog.bark();

4.Polymorphisme :

Fait référence à des objets prenant de nombreuses formes.
Permet une interface unifiée pour différents types d'objets, permettant la réutilisation du code et la flexibilité.
Exemple :

class Animal {
    sound() {
        console.log("This animal makes a sound.");
    }
}
class Dog extends Animal {
    sound() {
        console.log("The dog barks.");
    }
}
const animal = new Animal();
const dog = new Dog();
animal.sound(); // Output: This animal makes a sound.
dog.sound();    // Output: The dog barks.

Importance de la POO

• Encapsulation : réduit la complexité et améliore la réutilisabilité.
• Abstraction : masque les détails de l'implémentation, simplifiant ainsi l'interaction.
• Héritage : élimine la duplication de code et favorise la réutilisation.
• Polymorphisme : permet une flexibilité et des structures de code rationalisées.

Exemples pratiques
Classes et constructeurs

• Une manière structurée et propre de créer des objets.
• Exemple :

class Product {
    constructor(name, price) {
        this.name = name;
        this.price = price;
    }

    displayProduct() {
        console.log(`Product: ${this.name}`);
        console.log(`Price: $${this.price.toFixed(2)}`);
    }

    calculateTotal(salesTax) {
        return this.price + this.price * salesTax;
    }
}

const product1 = new Product("Laptop", 1200);
product1.displayProduct();
console.log(`Total Price: $${product1.calculateTotal(0.1).toFixed(2)}`);

Héritage avec les animaux

• Démontre la réutilisabilité et le remplacement de méthode.
• Exemple :

class Animal {
    eat() {
        console.log("This animal eats food.");
    }
}

class Bird extends Animal {
    fly() {
        console.log("This bird can fly.");
    }
}

const bird = new Bird();
bird.eat();
bird.fly();

Réflexion
Ce que j'ai appris :

• Principes fondamentaux de la POO : encapsulation, abstraction, héritage, polymorphisme.
• Cas d'utilisation pratiques pour réduire la complexité du code et améliorer la réutilisabilité.
• Application de constructeurs, de méthodes et d'héritage pour résoudre des problèmes du monde réel.

La POO est un autre niveau.

On y retourne demain !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!