Détail des principes SOLID en Java

Les principes SOLID permettent de structurer le code pour qu'il soit propre, évolutif et facilement maintenable. Voici un aperçu des principes avec des exemples :

1. Principe de Responsabilité Unique (SRP : Single Responsibility Principle)

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 :

• User pour les données utilisateur,
• UserRepository pour la gestion des données,
• EmailService pour l'envoi d'emails.

2. Principe Ouvert/Fermé (OCP Open/Closed Principle)

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 Liskov Substitution Principle)

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 Interface Segregation Principle)

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 Dependency Inversion Principle)

Les modules de haut niveau (logique métier) ne doivent pas dépendre des modules de bas niveau (détails d'implémentation), mais des abstractions (interfaces ou classes abstraites).

Les détails d'implémentation font référence aux aspects spécifiques d'un composant ou d'une classe qui définissent son comportement exact, mais qui ne sont pas directement liés à la logique métier ou à l'architecture globale du système.

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.