Détail des principes SOLID avec exemples
Les principes SOLID permettent de structurer le code pour qu'il soit propre, évolutif et facilement maintenable. Voici un aperçu détaillé des principes, complétés par des exemples concrets fournis dans l'article.
1. Principe de Responsabilité Unique (SRP)
Chaque classe doit se concentrer sur une seule responsabilité ou tâche. Cela évite les confusions et rend le code plus clair et facile à maintenir.
Violation : Une classe User combine à la fois la gestion de l'utilisateur (stockage) et l'envoi d'emails.
Solution : Divisez la logique en plusieurs classes :
Userpour les données utilisateur,UserRepositorypour la gestion des données,EmailServicepour l'envoi d'emails.
2. Principe Ouvert/Fermé (OCP)
Les entités logicielles doivent être ouvertes à l'extension, mais fermées à la modification.
Violation : Une classe AreaCalculator utilise des conditions pour calculer l’aire des formes.
Solution : Utilisez une interface Shape avec une méthode abstraite calculateArea(). Chaque forme implémente l’interface et fournit son propre calcul.
3. Principe de Substitution de Liskov (LSP)
Une sous-classe doit pouvoir remplacer une classe mère sans causer de dysfonctionnements.
Violation : La classe Penguin, une sous-classe de Bird, lance une exception dans la méthode fly().
Solution : Reconcevez Bird en une classe abstraite avec une méthode move().
4. Principe de Ségrégation des Interfaces (ISP)
Une interface ne doit contenir que les méthodes strictement nécessaires pour ses implémentations.
Violation : Une interface Worker avec les méthodes work() et eat() est implémentée par un Robot, mais un robot ne mange pas.
Solution : Divisez l’interface en deux : Workable pour work(), et Eatable pour eat().
5. Principe d’Inversion de Dépendance (DIP)
Les modules de haut niveau ne doivent pas dépendre des modules de bas niveau, mais des abstractions.
Violation : Une classe Switch dépend directement de LightBulb.
Solution : Introduisez une interface Switchable avec des méthodes turnOn() et turnOff().
Conclusion
Les principes SOLID offrent une méthode puissante pour organiser un code propre, modulaire et évolutif :
- SRP clarifie les responsabilités,
- OCP facilite l’ajout de fonctionnalités,
- LSP garantit la cohérence des sous-classes,
- ISP réduit les dépendances inutiles,
- DIP améliore la flexibilité du système.
Ces principes sont indispensables pour les développeurs cherchant à améliorer la qualité de leur code en Java ou dans tout autre langage orienté objet.