Encapsulation

L'encapsulation est un principe fondamental en programmation orientée objet (POO). Elle consiste à regrouper dans une même structure, souvent une classes (programmation), des données (les attributs) et des méthodes permettant de manipuler ces données. L'idée principale derrière l'encapsulation est de masquer les détails internes de l'implémentation d'un objet et de n'exposer qu'une interfaces contrôlée. Cela permet de réduire les interactions complexes entre les objets, de maintenir l'intégrité des données, et de faciliter la maintenance du code.

En TypeScript, qui est un sur-ensemble de JavaScript avec des types statiques, tu peux utiliser des classes pour mettre en œuvre l'encapsulation. Voici un exemple simple :

class CompteBancaire {
    // Déclaration d'un attribut privé
    private solde: number;

    // Constructeur de la classe
    constructor(soldeInitial: number) {
        this.solde = soldeInitial;
    }

    // Méthode publique pour accéder au solde
    public consulterSolde(): number {
        return this.solde;
    }

    // Méthode publique pour déposer de l'argent
    public deposer(montant: number): void {
        if (montant > 0) {
            this.solde += montant;
            console.log(`Dépôt de ${montant}€ réussi.`);
        } else {
            console.log("Le montant doit être positif.");
        }
    }

    // Méthode publique pour retirer de l'argent
    public retirer(montant: number): void {
        if (montant <= this.solde) {
            this.solde -= montant;
            console.log(`Retrait de ${montant}€ réussi.`);
        } else {
            console.log("Solde insuffisant pour ce retrait.");
        }
    }
}

// Utilisation de la classe
let monCompte = new CompteBancaire(100);
console.log(monCompte.consulterSolde()); // Affiche 100
monCompte.deposer(50);
console.log(monCompte.consulterSolde()); // Affiche 150
monCompte.retirer(20);
console.log(monCompte.consulterSolde()); // Affiche 130

Dans cet exemple :

• Le solde du compte est un attribut privé, ce qui signifie que tu ne peux pas y accéder directement de l'extérieur de la classe. Tu dois utiliser les méthodes consulterSolde, deposer et retirer pour interagir avec le solde.
• Les méthodes deposer et retirer permettent de modifier le solde tout en vérifiant les conditions nécessaires (par exemple, ne pas déposer un montant négatif ou ne pas retirer plus que le solde disponible).
• Cette encapsulation assure que le solde ne peut être modifié que de manière contrôlée, réduisant ainsi les risques d'erreurs ou de manipulations inappropriées des données.

L'encapsulation aide donc à protéger les données et à rendre le code plus sûr et plus facile à gérer.

Voici quelques notions avancées en programmation orientée objet et en TypeScript que tu pourrais explorer pour approfondir tes connaissances :

1. héritage : Permet à une classe de hériter des caractéristiques d'une autre classe, facilitant la réutilisation et l'extension du code.

2. polymorphisme : Capacité d'un objet à être traité comme un objet de sa classe parente, mais de répondre différemment selon la classe dérivée dont il est une instance.

3. abstraction (programmation) : Fournit un moyen de créer des classes qui ne peuvent être instanciées en elles-mêmes mais uniquement à travers des sous-classes, permettant de définir des méthodes sans implémentation spécifique.

4. Interfaces : Définit la syntaxe que d'autres classes doivent suivre, sans implémenter de logique. En TypeScript, les interfaces sont un outil puissant pour définir des contrats au sein de ton code.

5. classes abstraites : Similaires aux interfaces, mais peuvent contenir des implémentations de certaines méthodes. Les classes abstraites sont utilisées pour définir des templates pour d'autres classes.

6. généricité : Permet de créer des classes, des interfaces, et des méthodes avec un placeholder pour le type de données qu'elles peuvent traiter, augmentant la réutilisabilité du code.

7. Decorators : Fonctionnalités avancées de TypeScript pour ajouter des annotations et une méta-programmation syntaxique à la déclaration de classes et de membres de classe.

8. Principes SOLID : Ensemble de cinq principes de conception pour rendre les logiciels plus compréhensibles, flexibles et maintenables.

9. Gestion des erreurs et exceptions : Méthodes de traitement des erreurs dans le code de manière structurée sans arrêter complètement l'exécution des programmes.

10. Systèmes de types avancés : Explore les types conditionnels, les types mappés, et les types de lookup pour écrire des codes TypeScript plus robustes et flexibles.

Chacune de ces notions peut t'ouvrir de nouvelles perspectives sur la manière de structurer et de développer des applications robustes et maintenables.