Encapsulation et modificateurs d’accès

Bienvenue dans la prochaine leçon ! Vous allez découvrir l’encapsulation, un concept essentiel de la POO, ainsi que la manière dont les modificateurs d’accès contrôlent la visibilité des membres d’une classe en C#. Commençons !

Qu’est-ce que l’encapsulation ?

L’encapsulation consiste à regrouper les données (champs) et le comportement (méthodes) dans une seule unité (classe), tout en limitant l’accès direct à certains composants. Elle permet de protéger l’intégrité des données et de faire respecter les règles d’accès à celles-ci.

Point clé : L’encapsulation vous permet de masquer les détails d’implémentation et d’exposer uniquement les fonctionnalités nécessaires.

Pourquoi l’encapsulation est-elle importante ?

L’encapsulation offre plusieurs avantages :

• Protection des données : Empêcher les accès non autorisés ou incorrects aux champs d’une classe.
• Facilité de maintenance du code : Les modifications de l’implémentation interne n’affectent pas le code externe.
• Modularité améliorée : Garder le code organisé et facile à comprendre.

Exemple : Une classe avec des champs privés et des méthodes publiques pour gérer ces champs illustre l’encapsulation.

Comprendre les modificateurs d’accès

Les modificateurs d’accès en C# définissent la portée de l’accessibilité des membres d’une classe :

• public : Accessible depuis n’importe où.
• private : Accessible uniquement au sein de la même classe.
• protected : Accessible au sein de la même classe et des classes dérivées.
• internal : Accessible au sein du même assemblage.
• protected internal : Accessible au sein du même assemblage ou des classes dérivées.

Point clé : Utilisez les modificateurs d’accès pour appliquer l’encapsulation.

Exemple : encapsulation avec des champs privés

Voici un exemple d’encapsulation utilisant des champs privés et des méthodes publiques :

Point clé : Utilisez des champs privés pour limiter l’accès direct et des méthodes publiques pour exposer des fonctionnalités contrôlées.

using System;

class BankAccount {
    private decimal balance; // Private field

    public void Deposit(decimal amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            Console.WriteLine("Deposit amount must be positive.");
        }
    }

    public decimal GetBalance() {
        return balance; // Access balance through a method
    }
}

class Program {
    static void Main() {
        BankAccount account = new BankAccount();
        account.Deposit(100.50m); // Deposit money
        Console.WriteLine("Balance: $" + account.GetBalance()); // Get balance
    }
}

Encapsulation avec des propriétés

Les propriétés offrent une manière plus claire d’encapsuler les champs tout en permettant d’y intégrer une logique de validation. Exemple :

Conseil : Utilisez des propriétés plutôt que des accesseurs de lecture et d’écriture bruts pour améliorer la lisibilité.

using System;

class BankAccount {
    private decimal balance; // Private field

    public decimal Balance { // Property with validation
        get { return balance; }
        set {
            if (value >= 0) {
                balance = value;
            } else {
                Console.WriteLine("Balance cannot be negative.");
            }
        }
    }
}

class Program {
    static void Main() {
        BankAccount account = new BankAccount();
        account.Balance = 200; // Set balance
        Console.WriteLine("Balance: $" + account.Balance); // Get balance
    }
}

Défi pratique

Créez une classe appelée Student avec les champs privés Name et Age. Utilisez des propriétés pour encapsuler ces champs et garantir que l’âge est toujours positif. Exemple :

using System;

class Student {
    private string name;
    private int age;

    public string Name {
        get { return name; }
        set { name = value; }
    }

    public int Age {
        get { return age; }
        set {
            if (value > 0) {
                age = value;
            } else {
                Console.WriteLine("Age must be positive.");
            }
        }
    }
}

class Program {
    static void Main() {
        Student student = new Student();
        student.Name = "Alice";
        student.Age = 20;

        Console.WriteLine("Name: " + student.Name);
        Console.WriteLine("Age: " + student.Age);
    }
}

Bonnes pratiques pour l’encapsulation

Voici quelques bonnes pratiques :

• Utilisez toujours des champs privés pour les données sensibles.
• Utilisez des propriétés ou des méthodes pour valider et contrôler l’accès aux champs.
• Associez l’encapsulation aux modificateurs d’accès pour protéger votre code.

Conseil : L’encapsulation vous aide à créer des applications sécurisées et faciles à maintenir.

Excellent travail !

Félicitations ! Vous avez appris à utiliser l’encapsulation et les modificateurs d’accès pour protéger et organiser vos données. Dans la prochaine leçon, nous découvrirons l’héritage et apprendrons à réutiliser efficacement le code. Continuons à coder !