<a href="/_slides/java/solid.html" target="_blank" class="doc-only slide">🎬 Aller sur la présentation</a>

# S O L I D

---

##  Introduction
SOLID est un ensemble de principes de conception pour une meilleure qualité de code.

---

## Principes

### S : Single Responsibility Principle (SRP)
Chaque classe doit avoir une seule responsabilité.  
Exemple :

```java linenums="1"
class CommandeService {
    public void traiterCommande(String typePaiement) {
        // Validation
        // Paiement
        // Notification
    }
}
```
Ici, `CommandeService` fait beaucoup trop. On peut découper en classes plus spécifiques.

---

### O : Open/Closed Principle (OCP)
Les classes doivent être ouvertes à l’extension mais fermées à la modification.  
Exemple :
```java
interface Paiement { void payer(); }
class PaiementCarte implements Paiement { ... }
class PaiementPayPal implements Paiement { ... }
```
Ajout de nouveaux types de paiement sans toucher au service de commande.

---

### L : Liskov Substitution Principle (LSP)
Les objets d’une classe dérivée doivent pouvoir remplacer ceux de la classe parente sans altérer le bon fonctionnement.

---
### I : Interface Segregation Principle (ISP)
Les interfaces doivent être spécifiques et non généralistes.  
Exemple :
```
interface Notification { void notifier(); }
class NotificationEmail implements Notification { ... }
```

---

### D : Dependency Inversion Principle (DIP)
Les modules de haut niveau ne doivent pas dépendre de modules de bas niveau, mais des abstractions.

---

## Remanier le code pour qu'il soit SOLID
### Sujet
Vous devez refactoriser une classe OrderManager qui gère les tâches suivantes : 
* Validation de la commande 
* Calcul des promotions 
* Envoi d’emails 
* Déclenchement de la livraison

Objectifs : 
1. Séparer ces responsabilités en différentes classes. 
2. Appliquer les principes SOLID, en particulier SRP, OCP et DIP.
3. Proposer un design modulaire, évolutif et testable.

---

### Remaniement de la classe `OrderManager`
#### Séparer les responsabilités (SRP)

```java
class OrderService {
    private ValidationService validationService;
    private PromotionService promotionService;
    private EmailService emailService;
    private DeliveryService deliveryService;
}
```

---

#### Ouverture à l’extension (OCP)
Ajout de nouveaux services comme `PaymentService` ou `DiscountService` sans modifier `OrderService`.

#### Injection de dépendances (DIP)

public OrderService(ValidationService validationService, PromotionService promotionService,
                        EmailService emailService, DeliveryService deliveryService) {
        this.validationService = validationService;
        this.promotionService = promotionService;
        this.emailService = emailService;
        this.deliveryService = deliveryService;
    }
}
```

---

### Checklist de Refactoring SOLID
Avant de valider votre refactoring, vérifiez que :
* SRP : Chaque classe a une seule responsabilité.
* OCP : Le code est ouvert à l’extension, mais fermé à la modification.  
* LSP : Les sous-classes peuvent être utilisées à la place de leurs classes parentes sans affecter le comportement.
* ISP : Les interfaces sont spécifiques et non générales.
* DIP : Le code dépend d’abstractions, et non de détails.

## Ressources Utiles
### Livres
* "Clean Code" de Robert C. Martin
* "Agile Software Development" de Robert C. Martin
### Vidéos et Tutos
* [Principes SOLID – Introduction vidéo](https://www.youtube.com/watch?v=vJYvjR7nNE0)
* [Tutoriel SOLID pour les débutants](https://www.youtube.com/watch?v=8tLviZfUiqY)