Responsabilité unique
Single Responsibility. Regrouper ce qui change pour les mêmes raisons, séparer ce qui change pour des raisons différentes.
Informatique · Qualité du code
Un nouveau moyen de paiement, un export CSV, une autre base de données : les principes SOLID font que chaque demande reste locale.
Déjà à l'aise ? Aller au quizLe problème
Ton programme marche. Puis arrive une demande : un nouveau moyen de paiement. Dans un code rigide, elle casse quelque chose ailleurs ; dans un code bien organisé, elle reste locale.
Même demande, deux codes : le changement se propage ou reste local.
Ça dépend ? Si elle marche, pourquoi la toucher ?
Après cette fiche, tu sais
Cinq lettres, une même idée
Notion 1 · Pourquoi des principes
Un programme qui marche aujourd'hui devra changer demain. Un code propre est un code où ces changements restent locaux : on modifie un endroit sans casser les autres.
Les cinq principes SOLID, réunis par Robert C. Martin, organisent les classes dans ce but.2
Single Responsibility. Regrouper ce qui change pour les mêmes raisons, séparer ce qui change pour des raisons différentes.
Open/Closed. Un module est ouvert à l'extension, fermé à la modification.
Liskov Substitution. Un sous-type doit pouvoir remplacer son type de base sans surprendre le code qui l'utilise.
Interface Segregation. De petites interfaces, pour que personne ne dépende de ce qu'il n'utilise pas.
Dependency Inversion. Dépendre dans le sens de l'abstraction : le code métier ne dépend pas des détails techniques.
Qui peut exiger un changement ?
Notion 2 · S comme responsabilité unique
Une classe ne doit avoir qu'une seule raison de changer. Ces raisons, ce sont des personnes : une classe ne devrait répondre qu'à un seul acteur, un groupe de personnes qui représente un même métier.1
Trois acteurs, trois raisons de changer la même classe.
Le test de l'acteur
Pour chaque méthode, demande-toi qui pourrait exiger qu'elle change. Si deux équipes différentes peuvent le demander, elle n'a pas sa place dans la même classe.
Fais défiler : une classe qui fait tout est découpée pas à pas. Surveille les étiquettes : chacune est un acteur qui peut exiger un changement.
User garde ses données, mais s'enregistre aussi en base, envoie des e-mails et produit son PDF. Une classe qui fait tout : une God Class.
L'équipe technique change de base, le marketing veut un autre e-mail, la comptabilité une autre mise en page : trois raisons de changer la même classe.
L'enregistrement part dans UserRepository. Changer de base de données ne touche plus User.
L'envoi part dans EmailService : le seul endroit que le marketing fera modifier.
La mise en page part dans PdfGenerator, l'affaire de la comptabilité.
User ne garde que ses données, et chaque classe répond à un seul acteur. Plus de classes, mais courtes, testables et indépendantes.
Donc ce ne sont pas les lignes qui comptent ?
class User {
saveToDatabase() { … }
sendEmail() { … }
generatePDF() { … }
}class User { name; email; }
class UserRepository { save(u) { … } }
class EmailService { send(u) { … } }
class PdfGenerator { render(u) { … } }Une classe Panier peut avoir dix méthodes (ajouter, retirer, calculer le total…) : elles changent toutes pour la même raison. Le principe ne découpe pas au hasard, il sépare ce qui change pour des raisons différentes.
Une forme de plus
Notion 3 · O comme ouvert/fermé
Un module doit être ouvert à l'extension, fermé à la modification : on ajoute un comportement en écrivant du code nouveau, sans rouvrir du code déjà testé.7
Le même programme, deux manières de grandir.
Le polymorphisme
Le moyen le plus courant est le polymorphisme : plusieurs classes réalisent la même interface, et le code qui s'en sert ne connaît que l'interface.7
Ajouter une forme, c'est ajouter une classe.
Un deuxième cas, pas un premier
Créer des interfaces « au cas où » alourdit le code pour rien (voir YAGNI plus bas). On ouvre un point d'extension quand un deuxième cas apparaît vraiment.
Fais défiler : on ajoute le triangle, le rectangle, puis le losange à deux versions du même programme. Compte ce qu'il faut rouvrir dans chacune.
Qui faut-il rouvrir pour une forme de plus ?
formes 2aire() rouverte 0 foisclasses rouvertes 0
function aire(forme) {
if (forme.type === 'cercle')
return Math.PI * forme.r ** 2;
if (forme.type === 'carre')
return forme.c ** 2;
// … un if de plus par forme
}interface Forme { aire(): number; }
class Cercle implements Forme {
constructor(private r: number) {}
aire() { return Math.PI * this.r ** 2; }
}
class Carre implements Forme {
constructor(private c: number) {}
aire() { return this.c ** 2; }
}Créer des interfaces « au cas où » alourdit le code pour rien (voir YAGNI plus bas). On ouvre un point d'extension quand un deuxième cas apparaît vraiment.
Un remplaçant sans surprise
Notion 4 · L comme substitution de Liskov
Barbara Liskov et Jeannette Wing l'ont formalisé en 1994 : toute propriété qu'on peut démontrer pour les objets d'un type doit rester vraie pour les objets de ses sous-types.3
En pratique, un code écrit pour la classe mère doit fonctionner, sans surprise, avec n'importe quelle classe fille.
class Oiseau { voler() { … } }
class Pingouin extends Oiseau {
voler() {
throw new Error("Je ne vole pas");
}
}
// oiseaux.forEach(o => o.voler())
// plante dès qu'il y a un pingouinclass Oiseau { manger() { … } }
class OiseauVolant extends Oiseau {
voler() { … }
}
class Pingouin extends Oiseau {
nager() { … }
}Le carré, en géométrie
L'exemple le plus célèbre est plus sournois : un carré est bien un rectangle en géométrie…
Mais est-ce un bon sous-type d'un rectangle qu'on peut redimensionner ?
Le contrat de la mère
Une sous-classe doit respecter le contrat de sa mère.
Elle ne doit ni exiger davantage, ni promettre moins, ni lever une erreur que la mère ne prévoit pas.
Fais défiler : le même test, écrit pour Rectangle, s'exécute ligne par ligne sur un rectangle et sur un carré.
Même test, deux objets
Rectangle 3 × 2 = 6Carré 3 × 3 = 9
Alors où est le problème ?
Forme font mieux l'affaire.Des interfaces taillées sur mesure
Notion 5 · I comme ségrégation des interfaces
Des interfaces petites et ciblées, pour qu'aucune classe ne soit forcée de dépendre de méthodes qu'elle n'utilise pas.2
Chaque rôle a sa propre interface.
Fais défiler : la grosse interface Travailleur se sépare en trois, et chaque classe ne garde que ce dont elle se sert.
Une interface, trois rôles
interfaces 1méthodes vides imposées à Robot 2
Le coût d'une grosse interface
Elle oblige chaque classe à tout implémenter, quitte à écrire des méthodes vides, et tout changement de l'interface touche tout le monde.2
Robot ne réalise que ce dont il se sert.
Personne ne doit dépendre de ce qu'il n'utilise pas.
interface Travailleur {
travailler(): void;
manger(): void;
dormir(): void;
}
class Robot implements Travailleur {
travailler() { … }
manger() { } // imposée, inutile
dormir() { } // imposée, inutile
}interface Travaillant { travailler(): void; }
interface Mangeant { manger(): void; }
interface Dormant { dormir(): void; }
class Robot implements Travaillant { … }
class Humain
implements Travaillant, Mangeant, Dormant { … }Le métier, au centre
Notion 6 · D comme inversion des dépendances
Deux règles : les modules de haut niveau (le métier) ne dépendent pas des modules de bas niveau (base de données, réseau) ; les deux dépendent d'abstractions.2
Les abstractions ne dépendent pas des détails : ce sont les détails qui dépendent des abstractions.
class OrderService {
private db = new MySQLDatabase();
save(order: Order) { this.db.insert(order); }
}class OrderService {
constructor(private db: Database) {}
save(order: Order) { this.db.insert(order); }
}
new OrderService(new MySQLDatabase());Injecter, c'est fournir
Le constructeur reçoit la base au lieu de la créer. La classe métier n'a plus à savoir quelle base la fait tourner.
L'injection de dépendances est la technique la plus courante pour appliquer le DIP.
Tester sans base
Pour tester, on remplace la vraie base par une fausse (un mock). Cela n'est possible que si la classe reçoit sa base de l'extérieur.
Fais défiler : on change deux fois de base de données, d'abord dans la version à couplage fort, puis dans la version inversée. Regarde quelle classe il faut modifier. Les boutons permettent de rejouer chaque cas.
Changer de base sans toucher au métier
Le DIP est un principe sur le sens des dépendances. L'injection de dépendances est une technique : on fournit à un objet ce dont il a besoin (ici, par le constructeur) au lieu qu'il le crée lui-même. C'est la façon la plus courante d'appliquer le DIP, et c'est elle qui permet de passer une fausse base (un mock) pendant les tests.
Huit situations tirées de vrais projets. Pour chacune, choisis la lettre de SOLID qui est enfreinte.
Des règles pour chaque ligne
Notion 7 · Le code propre au quotidien
SOLID organise les classes. Au niveau des lignes, quelques règles simples font la différence entre un code qu'on relit avec plaisir et un code qu'on n'ose plus toucher.6
Un bon nom évite un commentaire : getUserById() plutôt que g().
Des fonctions qui font une seule chose. Si on peut en extraire une partie et lui donner un nom clair, c'est qu'elle en faisait deux.
Dans Clean Code, Robert C. Martin juge l'idéal à zéro, puis un ou deux ; trois sont à éviter autant que possible, et au-delà il faut une très bonne raison. Sinon, on regroupe les paramètres dans un objet.6
Le code dit quoi ; le commentaire dit pourquoi (une contrainte du client, un contournement de bug).
DRY
DRY (Don't Repeat Yourself) : selon Hunt et Thomas, chaque connaissance doit avoir une représentation unique dans le système.5
Ce n'est pas seulement le copier-coller : un taux de TVA écrit en dur à dix endroits viole aussi DRY.
KISS
KISS (Keep It Simple, Stupid) : la solution la plus simple qui répond au besoin, pas la plus impressionnante.
Simple ne veut pas dire court : une ligne illisible n'est pas simple.
YAGNI
YAGNI (You Aren't Gonna Need It) : ne pas coder aujourd'hui une fonction « au cas où » on en aurait besoin un jour.
Quand le besoin arrive, on l'ajoute, avec ses tests.
Six situations, trois principes. Touche une situation, puis le principe qu'elle enfreint.
Sentir le problème
Notion 8 · Code smells et refactoring
Un code smell (expression de Kent Beck, popularisée par Martin Fowler) est un indice visible qui signale souvent un problème plus profond.4
Ce n'est pas un bug : le code marche, mais il sera pénible à faire évoluer.
Refactoring
Refactoring : modification de la structure interne d'un logiciel qui le rend plus facile à comprendre et moins cher à modifier, sans changer son comportement observable.4
Il se fait par petites étapes, chacune vérifiée par des tests.
Fais défiler : une petite fonction qui sent mauvais est remaniée en quatre étapes. Les tests sont relancés après chacune.
Le code marche : ses trois tests sont verts. Mais f, a et b ne disent rien, et 18 et 1 sont des nombres magiques.
peutSInscrire(age, statut) dit ce que fait la fonction. L'éditeur met à jour tous les appels, tests compris. On relance : vert.
AGE_MAJORITE et STATUT_ACTIF expliquent 18 et 1, et se modifient à un seul endroit. Tests : verts.
La condition vaut déjà true ou false : on la renvoie directement, sans if. Tests : verts.
Quatre petites étapes, des tests relancés après chacune, un comportement identique : c'est ça, un refactoring.
Les smells courants
Le tableau ci-dessous en donne six, avec le remède de chacun.
| Smell | Symptôme | Remède |
|---|---|---|
| God Class | une classe fait tout | extraire des classes (SRP) |
| Méthode longue | on défile pour la lire | extraire des fonctions bien nommées |
| Nombre magique | if (age >= 18) sans explication | constante nommée AGE_MAJORITE |
| Code dupliqué | le même bloc à plusieurs endroits | extraire une fonction commune (DRY) |
| Trop de paramètres | creer(n, p, a, v, t, e) | regrouper dans un objet |
| Code mort | jamais exécuté | le supprimer (Git le garde) |
Cinq smells relevés pendant une relecture de code. Choisis le refactoring qui les soigne.
Et maintenant, à toi
Bulletin calcule les moyennes des notes (de 1 à 6), les arrondit au demi-point, génère le PDF et l'envoie aux parents. Quels principes sont en jeu et comment découper ?Voir le corrigéViolation du SRP : le calcul (règlement de l'école), la mise en page et l'envoi changent pour des raisons différentes. On sépare CalculMoyennes, BulletinPdf et EnvoiParents. Si l'envoi se fait par e-mail aujourd'hui et par l'appli de l'école demain, une interface Notification reçue par le constructeur applique en plus le DIP et l'OCP.
function f(a, b, c, d, e) { if (a > 18 && b === 1) { … } }Voir le corrigéTrois smells : un nom vide de sens (f), trop de paramètres, des nombres magiques. Par exemple : function peutSInscrire(eleve), un objet eleve au lieu de cinq paramètres, et des constantes nommées pour 18 et 1. Attention à garder > (strictement plus de 18) : un refactoring ne change pas le comportement, à vérifier avec les tests existants.
Carre hérite de Rectangle. setLargeur(w) change aussi la hauteur du carré. Un test fait r.setLargeur(5); r.setHauteur(4); et attend une aire de 20. Que se passe-t-il avec un Carre ?Voir le corrigéAvec un Carre, setHauteur(4) remet aussi la largeur à 4 : l'aire vaut 16, pas 20. Le code écrit pour Rectangle est surpris : c'est l'exemple classique de violation du LSP. Un carré est un rectangle en géométrie, mais pas un bon sous-type d'un rectangle modifiable. Solution : ne pas les lier par héritage (deux classes qui réalisent une interface Forme).
Bulletin fait this.stockage = new StockageFichier(); dans son constructeur. Réécris-la pour appliquer le DIP et pouvoir la tester sans écrire de fichier.Voir le corrigéOn crée une abstraction, que le détail technique réalise, et on l'injecte par le constructeur :
interface Stockage { enregistrer(texte: string): void; }
class StockageFichier implements Stockage {
enregistrer(texte: string) { /* écrit un fichier */ }
}
class Bulletin {
constructor(private stockage: Stockage) {}
publier(texte: string) { this.stockage.enregistrer(texte); }
}
// en production : new Bulletin(new StockageFichier())
// en test : new Bulletin(new StockageMemoire())
Bulletin ne dépend plus que de Stockage. En test, une classe StockageMemoire qui garde le texte dans une variable suffit.
Fiche relue et sourcée en septembre 2026, refaite en récit en octobre 2026.