L'encapsulation est un principe fondamental de la POO qui consiste à cacher les détails d'implémentation et à protéger les données. Cette section explique le principe et les avantages de l'encapsulation.

5.2Encapsulation

5.2.1 – Principe

L'encapsulation est un principe fondamental de la programmation orientée objet qui consiste à cacher les détails d'implémentation et à protéger les données en rendant les attributs privés et en fournissant des méthodes publiques (getters/setters) pour y accéder.

🔒 Concept de base

L'encapsulation repose sur deux principes :

Rendre les attributs privés : Les données internes ne sont pas directement accessibles depuis l'extérieur
Fournir des méthodes publiques : L'accès se fait uniquement via des méthodes contrôlées (getters/setters)

Exemple : Encapsulation de base

public class Personne {
    // Attributs privés : cachés de l'extérieur
    private String nom;  // Privé : pas d'accès direct
    private int age;     // Privé : pas d'accès direct
    
    // Méthodes publiques pour accéder et modifier
    public String getNom() {
        return nom;
    }
    
    public void setNom(String nom) {
        this.nom = nom;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

❌ Sans encapsulation (à éviter)

Exemple : Code sans encapsulation

public class Personne {
    // Attributs publics : accès direct (DANGEREUX)
    public String nom;
    public int age;
}

// Utilisation
Personne p = new Personne();
p.nom = "Jean";
p.age = -5;  // ❌ Problème : aucune validation possible

Problèmes :

Aucun contrôle sur les valeurs assignées
Impossible de valider les données
Code client dépendant de l'implémentation interne

✅ Avec encapsulation (recommandé)

Exemple : Code avec encapsulation

public class Personne {
    // Attributs privés : protégés
    private String nom;
    private int age;
    
    // Getters
    public String getNom() {
        return nom;
    }
    
    public int getAge() {
        return age;
    }
    
    // Setters avec validation
    public void setNom(String nom) {
        if (nom != null && !nom.trim().isEmpty()) {
            this.nom = nom;
        }
    }
    
    public void setAge(int age) {
        if (age >= 0 && age <= 150) {  // Validation
            this.age = age;
        } else {
            System.out.println("Âge invalide !");
        }
    }
}

// Utilisation
Personne p = new Personne();
p.setNom("Jean");
p.setAge(-5);  // ✅ Validation : l'âge invalide est rejeté

5.2.2 – Avantages

L'encapsulation offre de nombreux avantages qui améliorent la qualité, la maintenabilité et la sécurité du code.

🛡️ Protection des données

L'encapsulation permet de contrôler et valider les valeurs assignées aux attributs, garantissant l'intégrité des données.

Exemple : Validation dans le setter

public class CompteBancaire {
    private double solde;
    
    public void setSolde(double solde) {
        if (solde >= 0) {  // Validation : le solde ne peut pas être négatif
            this.solde = solde;
        } else {
            System.out.println("Erreur : le solde ne peut pas être négatif");
        }
    }
    
    public double getSolde() {
        return solde;
    }
}

🔄 Flexibilité et maintenabilité

L'encapsulation permet de modifier l'implémentation interne sans affecter le code client qui utilise la classe.

Exemple : Changement d'implémentation

// Version 1 : Stockage simple
public class Personne {
    private String nom;
    
    public String getNom() {
        return nom;
    }
}

// Version 2 : Changement d'implémentation (ajout de logique)
public class Personne {
    private String nom;
    private String prenom;
    
    // L'API publique reste la même !
    public String getNom() {
        return prenom + " " + nom;  // Retourne le nom complet
    }
    
    // Le code client n'a pas besoin de changer !
}

✅ Validation et contrôle

Les setters permettent d'ajouter de la logique de validation, de transformation ou de notification lors de la modification des données.

Exemple : Validation et logique supplémentaire

public class Personne {
    private String email;
    
    public void setEmail(String email) {
        // Validation : vérifier le format de l'email
        if (email != null && email.contains("@") && email.contains(".")) {
            this.email = email.toLowerCase();  // Normalisation
            System.out.println("Email mis à jour : " + email);
        } else {
            System.out.println("Format d'email invalide");
        }
    }
}

📊 Tableau de comparaison : Avec vs Sans encapsulation

Critère	Sans encapsulation (public)	Avec encapsulation (private + getters/setters)
Contrôle des données	❌ Aucun	✅ Validation possible
Flexibilité	❌ Code client dépendant	✅ Implémentation changeable
Sécurité	❌ Données vulnérables	✅ Données protégées
Maintenabilité	❌ Difficile	✅ Facile
Logique supplémentaire	❌ Impossible	✅ Logs, notifications, etc.

💡 Points clés à retenir

Principe : Rendre les attributs privés et utiliser des getters/setters publics
Protection : Contrôle et validation des données
Flexibilité : Possibilité de changer l'implémentation sans affecter le code client
Maintenabilité : Code plus facile à maintenir et à faire évoluer
Sécurité : Données protégées contre les accès non autorisés
Logique : Possibilité d'ajouter de la logique lors de l'accès aux données

Conseils pratiques :

Toujours rendre les attributs private (sauf cas très rares)
Utiliser des getters/setters pour tous les attributs qui doivent être accessibles
Ajouter de la validation dans les setters pour garantir l'intégrité des données
L'encapsulation est l'un des piliers de la POO : respectez-la !