Principes SOLID en Java

Les principes SOLID sont des bonnes pratiques en programmation orientée objet qui permettent d'avoir un code plus modulaire, maintenable et extensible.

1️⃣ S - Principe de Responsabilité Unique (Single Responsibility Principle - SRP)

Une classe ne doit avoir qu'une seule raison de changer.

❌ Mauvais exemple (Violation du SRP)

Une classe qui gère les informations du salarié et le calcul de la paie :

class Employe {
    private String nom;
    private double salaire;

    public Employe(String nom, double salaire) {
        this.nom = nom;
        this.salaire = salaire;
    }

    public void genererFichePaie() {
        System.out.println("Fiche de paie générée pour " + nom);
    }
}

✅ Bon exemple (Respect du SRP)

Séparer les responsabilités :

class Employe {
    private String nom;
    private double salaire;

    public Employe(String nom, double salaire) {
        this.nom = nom;
        this.salaire = salaire;
    }
}

class PaieService {
    public void genererFichePaie(Employe employe) {
        System.out.println("Fiche de paie générée pour " + employe.getNom());
    }
}

---

2️⃣ O - Principe Ouvert/Fermé (Open/Closed Principle - OCP)

Une classe doit être ouverte à l'extension mais fermée à la modification.

❌ Mauvais exemple

Ajouter une nouvelle réduction oblige à modifier le code existant :

class Facture {
    public double calculerRemise(double montant, String typeClient) {
        if (typeClient.equals("VIP")) {
            return montant * 0.9;
        } else if (typeClient.equals("Fidèle")) {
            return montant * 0.95;
        }
        return montant;
    }
}

✅ Bon exemple (Respect de l’OCP)

Utilisation du polymorphisme :

interface Remise {
    double appliquerRemise(double montant);
}

class RemiseVIP implements Remise {
    public double appliquerRemise(double montant) {
        return montant * 0.9;
    }
}

class Facture {
    public double appliquerRemise(double montant, Remise remise) {
        return remise.appliquerRemise(montant);
    }
}

---

3️⃣ L - Principe de Substitution de Liskov (Liskov Substitution Principle - LSP)

Une classe dérivée doit pouvoir remplacer sa classe mère sans effet indésirable.

❌ Mauvais exemple

Un carré est un rectangle qui a ses quatre côtés de même longueur.
Mais, un carré ne peut pas toujours remplacer un rectangle : un carré a un coté et un rectangle a une longueur et une largeur

class Rectangle {
    protected int largeur, longueur;

    public void setLargeur(int largeur) { this.largeur = largeur; }
    public void setLongueur(int longueur) { this.hauteur = longueur; }
}

class Carre extends Rectangle {
    @Override
    public void setLargeur(int largeur) {
        this.largeur = this.longueur = largeur;
    }
}

✅ Bon exemple

Utiliser des classes distinctes :

interface Forme {
    int getAire();
}

class Rectangle implements Forme {
    private int largeur, longueur;
    public int getAire() { return largeur * longueur; }
}

class Carre implements Forme {
    private int cote;
    public int getAire() { return cote * cote; }
}

---

4️⃣ I - Principe de Ségrégation des Interfaces (Interface Segregation Principle - ISP)

Une classe ne doit pas être forcée à implémenter des méthodes inutiles.

❌ Mauvais exemple

Une interface trop large :

interface Oiseau {
    void voler();
    void nager();
}

class Pingouin implements Oiseau {
    public void voler() { throw new UnsupportedOperationException(); }
    public void nager() { System.out.println("Le pingouin nage"); }
}

✅ Bon exemple

Créer plusieurs interfaces :

interface OiseauVolant { void voler(); }
interface OiseauMarin { void nager(); }

class Aigle implements OiseauVolant {
    public void voler() { System.out.println("L'aigle vole"); }
}

class Pingouin implements OiseauMarin {
    public void nager() { System.out.println("Le pingouin nage"); }
}

---

5️⃣ D - Principe d'Inversion des Dépendances (Dependency Inversion Principle - DIP)

Une classe doit dépendre d’abstractions et non d’implémentations concrètes.

❌ Mauvais exemple

Dépendance directe à une implémentation :

class MySQLDatabase {
    public void sauvegarderCommande(String commande) {
        System.out.println("Commande enregistrée en MySQL");
    }
}

class ServiceCommande {
    private MySQLDatabase db = new MySQLDatabase();
    public void traiterCommande(String commande) {
        db.sauvegarderCommande(commande);
    }
}

✅ Bon exemple

Utiliser une interface pour découpler :

interface BaseDeDonnees {
    void sauvegarderCommande(String commande);
}

class MySQLDatabase implements BaseDeDonnees {
    public void sauvegarderCommande(String commande) {
        System.out.println("Commande enregistrée en MySQL");
    }
}

class ServiceCommande {
    private BaseDeDonnees db;
    public ServiceCommande(BaseDeDonnees db) {
        this.db = db;
    }
    public void traiterCommande(String commande) {
        db.sauvegarderCommande(commande);
    }
}

---

🎯 Conclusion

Les principes SOLID en Java permettent d’avoir un code modulaire, maintenable et extensible. Respecter ces bonnes pratiques améliore la qualité du code et évite les problèmes à long terme ! 🚀