Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Design Patterns

Design Patterns

Facilitez l’évolution de vos logiciels : découvrez quand séparer, envelopper, partager ou déléguer les responsabilités.
par Erich Gamma 1994 416 pages
4.20
11 000+ évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Nommer les problèmes de conception récurrents pour que les équipes réutilisent leur jugement, pas seulement le code

Les patrons préservent les choix durement acquis. Les concepteurs chevronnés ne résolvent pas chaque problème en repartant de zéro. Ils reconnaissent les situations récurrentes et réutilisent des agencements qui ont déjà fait leurs preuves. Un patron de conception consigne un tel agencement sous une forme que d’autres peuvent comprendre et adapter. Le livre présente 23 patrons issus d’usages répétés dans des systèmes orientés objet, et non des astuces spéculatives ou des blocs de code prêts à l’emploi.

Un patron explique ses compromis. Il cerne le problème et son contexte, décrit les objets concernés et leurs relations, puis précise quand cette approche convient et ce qu’elle coûte. Nommer un patron donne à une équipe un raccourci pour discuter d’une conception. Ce nom n’est utile que si tout le monde comprend le problème auquel il répond et les compromis qu’il implique.

Analyse

Le nom d’un patron fonctionne comme un modèle condensé : il permet à une équipe de discuter de toute une famille de décisions de conception sans redessiner chaque relation entre les classes. Ce vocabulaire partagé peut accélérer le raisonnement architectural et mettre au jour des présupposés qui seraient autrement restés implicites. Cette concision comporte toutefois un risque. Une étiquette peut sonner comme un verdict et inciter à ne plus se demander si le problème correspond réellement au patron. Le meilleur usage d’un nom de patron consiste à amorcer une discussion de conception, non à la conclure.

Faire pointer les dépendances vers des interfaces, et non vers des classes concrètes

Les clients ont besoin de contrats, pas de détails internes. Une interface décrit les requêtes auxquelles un objet peut répondre, tandis que sa classe détermine comment elles sont mises en œuvre. Si le code client dépend d’une classe concrète particulière, modifier cette implémentation peut entraîner des changements dans tout le système. S’il dépend plutôt d’une interface, un autre objet peut la remplacer, à condition de respecter le même contrat.

La création est une source fréquente de dépendances. Un client qui construit directement un bouton propre à une plateforme s’engage envers cette plateforme. Les patrons de création comme la fabrique abstraite (Abstract Factory) et la méthode fabrique déplacent ce choix derrière un mécanisme de création distinct. L’application peut alors utiliser une interface abstraite de composant graphique ou de produit, tandis qu’une fabrique sélectionne la classe concrète. C’est le principe de conception central du livre: programmer en fonction d’une interface, et non d’une implémentation.

Analyse

Ce principe est une manière de maîtriser les dépendances. Une interface stable sert de frontière qui permet de contenir les changements d’implémentation, un peu comme un protocole soigneusement défini entre des organisations. Son utilité dépend de sa pertinence : une abstraction qui comporte trop de cas particuliers risque de dissimuler le couplage au lieu de le supprimer. La question pratique n’est pas de savoir si chaque classe a besoin d’une interface, mais si un changement probable doit pouvoir franchir cette frontière.

Composer les comportements à l’exécution avant de multiplier les sous-classes

L’héritage fixe les choix trop tôt. Une sous-classe hérite de l’implémentation de sa classe parente, ce qui est pratique, mais peut lier la conception à des détails dont elle ne devrait pas dépendre. Si chaque combinaison de fonctionnalités a sa propre sous-classe, le nombre de classes augmente rapidement. Une vue de texte avec bordure et défilement, par exemple, peut nécessiter une classe distincte pour chaque combinaison de comportements de bordure et de défilement.

La composition permet de remplacer les composants. La composition d’objets construit un comportement en reliant des objets par des interfaces. Une fenêtre peut contenir une forme et lui déléguer les opérations qui la concernent, plutôt que d’être elle-même une sorte de forme. L’objet contenu peut être remplacé à l’exécution par un autre objet qui prend en charge la même interface. Cette approche tend à préserver l’encapsulation et à mieux circonscrire la responsabilité des classes, même si les nombreuses interactions entre objets peuvent être plus difficiles à suivre et ajouter une indirection à l’exécution.

Analyse

Ce choix rappelle un compromis plus général entre structure statique et configurabilité à l’exécution. La composition rend les variations locales et réversibles, ce qui est précieux lorsque les exigences évoluent réellement. Mais la souplesse a un prix : chaque délégation ajoute une relation que les lecteurs doivent suivre, et une conception peut se transformer en réseau complexe de petits objets. Il faut se demander si les variations attendues justifient le coût d’explication. Des comportements stables se prêtent souvent mieux à un héritage plus simple ou à des appels directs.

Choisir un patron de création en fonction de ce qui doit varier

Cinq patrons masquent les choix de construction. La fabrique abstraite (Abstract Factory) crée des familles de produits apparentés, par exemple un ensemble cohérent de composants d’interface. Le constructeur sépare les étapes de construction d’un objet complexe de la forme qu’il prend. La méthode fabrique permet aux sous-classes de choisir quelle classe de produit instancier. Le prototype crée des produits en copiant des objets exemples. Le singleton contrôle l’accès à une instance unique.

Leur souplesse varie. Dans un jeu de labyrinthe, une fabrique peut produire des pièces, des murs et des portes d’un même type cohérent; un constructeur peut assembler pas à pas différentes représentations du labyrinthe; et une fabrique fondée sur des prototypes peut cloner différents exemples de composants. La méthode fabrique est souvent plus simple au départ, tandis que les fabriques fondées sur des objets et les prototypes offrent davantage de façons de faire varier la construction. Chacun de ces patrons ajoute une structure: utilisez-en un lorsque le choix de classe ou le processus de construction est susceptible d’évoluer.

Analyse

Ces patrons séparent deux décisions souvent entremêlées : ce qu’il faut créer et qui doit décider de la façon de le créer. Cette distinction aide à trouver la plus petite abstraction utile. Une fabrique couvrant toute une famille est précieuse lorsque les produits doivent rester compatibles, tandis qu’un constructeur justifie sa complexité lorsque les étapes de construction ont un sens. Le singleton est le choix le plus restrictif et mérite un examen particulièrement attentif, car un accès global pratique peut également créer des dépendances cachées.

Construire des arbres, puis traiter les feuilles et les groupes de la même façon

Le composite donne une interface uniforme à une hiérarchie. Il représente une structure partie-tout sous la forme d’un arbre dont les éléments simples et les groupes partagent une interface commune. Dans l’éditeur de documents Lexi, les caractères, les images, les lignes et les colonnes sont tous des glyphes. Une ligne peut dessiner ses enfants, tandis qu’un caractère se dessine lui-même. Le code client peut travailler avec l’un ou l’autre sans vérifier constamment s’il a affaire à un élément primitif ou à un groupe.

Le partage permet de maîtriser le coût. Des objets fins peuvent rendre une conception souple, mais consommer beaucoup de mémoire. Le poids mouche (Flyweight) réduit les doublons en partageant les objets qui contiennent des informations indépendantes du contexte, tandis que les détails propres au contexte, comme la position, sont fournis au besoin. Dans l’exemple de l’éditeur Doc, un document de 180 000 caractères n’utilisait que 480 objets caractère. Le partage ne convient pas lorsque l’identité est importante ou que la majeure partie de l’état est propre à chaque occurrence.

Analyse

Le composite exprime une symétrie utile : un groupe peut participer aux mêmes opérations que ses composants, de sorte que la complexité peut croître sans obliger chaque client à connaître l’arbre. Le poids mouche s’attaque au coût correspondant de faire de chaque élément un objet. Ensemble, ces patrons montrent que l’abstraction et l’efficacité ne sont pas nécessairement contradictoires, à condition de séparer clairement l’état partagé du contexte local. La frontière peut être délicate : dès lors que le contexte est externalisé, les appelants doivent le fournir de manière fiable.

Choisir le patron structurel en fonction de la frontière recherchée

Des enveloppes similaires répondent à des problèmes différents. L’adaptateur traduit l’interface d’une classe existante dans celle qu’attend un client, comme lorsqu’une classe de boîte à outils pour vues textuelles est rendue utilisable en tant que forme dans un éditeur graphique. Le pont sépare une abstraction de son implémentation propre à une plateforme afin que les deux puissent évoluer. Le décorateur conserve l’interface du composant tout en y ajoutant des responsabilités, comme des bordures ou le défilement. Le proxy conserve une interface similaire tout en contrôlant l’accès, par exemple en ne chargeant une grande image qu’au moment de la dessiner.

La façade simplifie un sous-système. Elle offre aux clients ordinaires un point d’entrée de plus haut niveau vers un ensemble de classes détaillées, comme un objet compilateur qui coordonne l’analyse lexicale, l’analyse syntaxique et la génération de code. Tous ces patrons ajoutent une indirection, mais pour des raisons distinctes: traduire, faire varier, enrichir, contrôler ou simplifier. Choisir en fonction de l’objectif évite de prendre une structure familière pour la bonne solution.

Analyse

Ces distinctions comptent, car la ressemblance structurelle peut induire en erreur. Un proxy et un décorateur peuvent tous deux transmettre des appels, mais le premier contrôle l’accès tandis que le second étend le comportement. Un adaptateur corrige une incompatibilité déjà présente ; un pont anticipe des variations indépendantes. Cela rappelle utilement que l’architecture tient autant à l’intention qu’aux diagrammes. L’indirection se justifie lorsqu’elle protège une frontière précise, et non simplement parce qu’un catalogue de patrons lui donne un nom.

Déplacer les algorithmes et les états évolutifs hors des conditionnelles tentaculaires

La stratégie rend les algorithmes interchangeables. Lexi délègue le découpage des lignes à un compositeur. Ainsi, une méthode de mise en page rapide ou une autre plus élaborée peut formater le même document sans modifier ses glyphes. La méthode modèle suit une autre voie: une classe parente fixe l’ordre des étapes d’un algorithme, tandis que les sous-classes en définissent certaines. La stratégie délègue l’algorithme; la méthode modèle fait varier des parties d’une procédure héritée.

L’état fait dépendre le comportement d’un objet. Une connexion réseau peut déléguer les requêtes à un objet représentant son état actuel, ouvert ou fermé par exemple, plutôt que de répéter des vérifications d’état dans de nombreuses méthodes. L’interpréteur représente la grammaire d’un petit langage par des classes d’expressions et évalue un arbre syntaxique à l’aide de celles-ci. Cette approche peut convenir élégamment aux grammaires simples, mais une grammaire volumineuse entraîne la création de nombreuses classes; des outils de génération d’analyseurs peuvent alors être préférables.

Analyse

Ces patrons transforment des embranchements cachés en choix de conception explicites. Cela peut faciliter la localisation des changements et rendre le comportement plus lisible pour les responsables de la maintenance. En contrepartie, le nombre de classes et d’objets augmente, et la logique de décision ne disparaît pas : elle est simplement déplacée. La stratégie est particulièrement adaptée lorsque les clients doivent choisir parmi plusieurs algorithmes ; l’état convient au comportement lié à un cycle de vie évolutif ; la méthode modèle correspond à une séquence stable qui ne comporte que quelques étapes variables.

Découpler les collaborateurs en choisissant comment les requêtes circulent

L’observateur diffuse les changements. Un sujet avertit les observateurs inscrits lorsque son état change, ce qui permet, par exemple, à une feuille de calcul et à un graphique de refléter les mêmes données sous-jacentes sans faire référence l’un à l’autre. Le médiateur coordonne plutôt un groupe de collègues par l’intermédiaire d’un objet central. Dans une boîte de dialogue, un directeur peut réagir à la sélection d’un élément dans une liste en mettant à jour un champ de texte et en activant des boutons.

La chaîne de responsabilité recherche un gestionnaire. Une requête passe par des objets susceptibles de la traiter jusqu’à ce que l’un d’eux s’en charge. Une demande d’aide peut passer d’un bouton à sa boîte de dialogue, puis à l’application, afin que l’explication la plus spécifique parmi celles qui sont disponibles puisse répondre. Ces mécanismes réduisent les dépendances directes, mais leurs flux diffèrent. L’observateur distribue les notifications, le médiateur centralise la coordination, et la chaîne rend conditionnel le choix du destinataire final.

Analyse

Ces patrons proposent différentes manières de gérer la complexité des interactions au sein d’un logiciel. L’observateur convient à de nombreux abonnés indépendants, tandis que le médiateur rend visibles les règles de coordination en un seul endroit. Une chaîne est utile lorsque la responsabilité dépend du contexte ou qu’un mécanisme de repli est nécessaire. Chacun remplace les liens directs par un chemin de contrôle moins évident. Le débogage suppose donc de documenter les abonnements, les règles du médiateur ou l’ordre de la chaîne, plutôt que de croire qu’une réduction du couplage rend automatiquement un système plus facile à comprendre.

Représenter les requêtes sous forme d’objets pour permettre l’annulation et le rétablissement

La commande transforme une action en données. Un élément de menu peut contenir un objet commande sans savoir quel objet de l’application exécutera l’action. La même commande peut être associée à un bouton, mise en file d’attente ou enregistrée. Pour permettre l’annulation, une commande stocke les informations nécessaires à l’inversion de ses effets; un historique de commandes peut être parcouru en arrière pour annuler et en avant pour rétablir. Il est également possible de regrouper plusieurs commandes dans une commande plus vaste.

Le mémento (Memento) préserve l’état caché. Certaines opérations modifient des structures internes qu’il est impossible de reconstituer de façon fiable en appliquant simplement l’action inverse. Dans un éditeur graphique, le déplacement d’une forme connectée peut amener un solveur de contraintes à réorganiser d’autres objets. Un mémento stocke un instantané privé que le solveur peut lui-même restaurer, sans exposer ses détails internes au système d’annulation. Les instantanés peuvent être coûteux: l’état sauvegardé ne devrait donc pas dépasser ce qu’exige la tâche.

Analyse

La commande rend explicite l’historique des actions, ce qui constitue une base pour l’annulation, l’audit et l’exécution différée. Le mémento la complète lorsque l’annulation exige de restaurer davantage que la simple opération inverse. Ensemble, ils distinguent l’enregistrement d’une opération de l’état protégé nécessaire à la restauration de ses effets. Cette conception met également en lumière une décision produit : l’annulation n’est pas qu’un bouton. Elle suppose de définir quelles actions comptent, quel état doit être conservé et avec quelle fiabilité la restauration doit s’effectuer.

Séparer le parcours des opérations lorsque les structures restent stables

L’itérateur masque le parcours des données. Il permet aux clients de visiter les éléments séquentiellement sans savoir si une collection utilise un tableau, une liste chaînée ou une autre représentation. Sa propre position permet de parcourir simultanément la même structure de plusieurs façons. Différents itérateurs peuvent prendre en charge différents ordres de parcours, mais toute modification d’une collection pendant le parcours exige de la prudence.

Le visiteur sépare les opérations des éléments. Dans un compilateur, un visiteur peut effectuer la vérification des types ou la génération de code sur les nœuds d’un arbre syntaxique sans intégrer chaque opération à chaque classe de nœud. Cette approche fonctionne particulièrement bien lorsque la structure des nœuds est relativement stable et que de nouvelles opérations sont fréquentes. Le coût se manifeste à l’ajout d’une classe de nœud: chaque interface de visiteur peut alors nécessiter une opération de visite correspondante. L’itérateur abstrait la manière d’atteindre les éléments; le visiteur organise les opérations à effectuer sur eux.

Analyse

Ces deux patrons répondent à des axes de changement distincts. L’itérateur protège les clients contre les changements de représentation d’une collection, tandis que le visiteur évite que les classes d’éléments accumulent des opérations sans rapport entre elles. Leurs limites découlent de ces choix : l’itération peut devenir fragile en cas de modifications structurelles concurrentes, et les visiteurs rendent coûteux l’élargissement de la taxonomie des éléments. La question de conception est de savoir quel côté évoluera le plus souvent. Prendre le côté stable comme fondation permet à l’autre de s’adapter plus facilement.

Voir l’éditeur à huit patrons de Lexi comme une carte, non comme un plan à suivre

Un même éditeur rend le catalogue concret. Lexi est un éditeur de documents WYSIWYG fictif dont les problèmes de conception consistent notamment à représenter du texte et des graphiques imbriqués, à formater les lignes, à prendre en charge divers styles d’interface et systèmes de fenêtrage, et à mettre en œuvre des actions utilisateur annulables. Son document est un composite de glyphes; la mise en forme utilise la stratégie; les bordures et le défilement utilisent le décorateur; les familles de composants d’interface utilisent la fabrique abstraite (Abstract Factory); et les fenêtres propres à une plateforme utilisent le pont.

L’analyse ajoute deux autres patrons. L’itérateur parcourt la structure des glyphes sans en révéler le mode de stockage, tandis que le visiteur permet la vérification orthographique et la césure sans intégrer ces opérations à chaque classe de glyphe. Ensemble, ces huit patrons isolent différentes sources de changement. Il ne s’agit pas de les installer tous par défaut. Il faut d’abord déterminer les changements probables, puis examiner l’applicabilité de chaque patron et ses conséquences. La souplesse est utile lorsque le besoin se présente, pas simplement parce qu’elle est possible.

Analyse

L’intérêt de Lexi tient à ce que les patrons y coopèrent au sein d’une même application, plutôt qu’à la présentation de 23 définitions isolées. Chaque patron protège un point de jonction différent et, ensemble, ils facilitent l’évolution de l’éditeur. Cela rappelle la conception des systèmes en couches : les décisions locales sont plus sûres lorsque les composants voisins communiquent par des contrats délibérés. Pourtant, chaque point de jonction ajoute des concepts qu’une personne chargée de la maintenance devra apprendre. L’étude de cas défend donc à la fois la modularité et la retenue, en particulier lorsqu’une exigence a peu de chances d’évoluer.

Analyse

La contribution durable du livre tient moins à un ensemble de recettes orientées objet qu’à une manière de raisonner sur le changement. Ses patrons invitent les concepteurs à cerner ce qui est instable, à donner une frontière à cette variation et à faire dépendre le code voisin de cette frontière plutôt que de l’implémentation volatile. Le catalogue constitue ainsi une théorie pratique de la modularité: chaque patron propose une répartition particulière des responsabilités, avec un coût explicite en indirections, en classes ou en complexité.

La classification en trois catégories — création, structure et comportement — est une première carte utile pour s’orienter, mais elle n’explique pas complètement un patron. La question organisatrice, plus profonde, est de savoir ce qui doit pouvoir varier indépendamment. La fabrique abstraite gère le choix d’une famille de produits; le pont sépare une interface de son implémentation; l’observateur répond à la notification d’un changement d’état à plusieurs destinataires. Le même objectif architectural — réduire les dépendances inutiles — prend des formes différentes parce que les problèmes sous-jacents diffèrent.

L’étude de cas de Lexi est particulièrement efficace, car elle transforme le catalogue en récit de conception. La structure du document, sa mise en forme, l’interface utilisateur, la prise en charge des plateformes, les commandes et l’analyse du texte créent chacune une pression différente. Les patrons ne sont pas des ornements ajoutés après coup: ils répondent à des pressions précises. Dans le même temps, le livre avertit que la souplesse peut rendre les logiciels plus difficiles à comprendre. Cet avertissement empêche que son principe central se réduise à l’abstraction pour l’abstraction.

Les patrons sont ancrés dans les langages et les systèmes orientés objet de leur époque. Lorsque les langages prennent directement en charge les fermetures, les génériques ou une répartition plus riche, certains mécanismes peuvent s’exprimer autrement. Cela n’efface pas les questions de conception sous-jacentes, mais signifie que le nom du patron ne doit pas imposer l’implémentation. La pratique la plus durable consiste à étudier le problème, à comparer les compromis et à choisir la structure la plus simple qui protège un changement probable.

Résumé en 30 secondes
Les problèmes de conception récurrents peuvent être abordés à l’aide d’agencements réutilisables qui clarifient les responsabilités et les compromis. Appuyez-vous sur des interfaces pour rendre les implémentations remplaçables, et combinez des objets pour faire varier le comportement sans multiplier les sous-classes. Choisissez les structures en fonction de ce qui doit changer : la création, l’accès, la communication, les algorithmes ou l’état. Un catalogue de 23 patrons comprend des objets caractères partagés qui représentaient 180 000 caractères d’un document avec seulement 480 instances. La flexibilité supplémentaire a un coût en indirection et en complexité : utilisez-la là où une évolution est probable.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.20 sur 5
Moyenne de 11 000+ évaluations de Goodreads et Amazon.

Design Patterns est largement considéré comme un ouvrage fondateur du génie logiciel, qui a introduit le concept de patrons de conception afin d’améliorer la réutilisabilité et la maintenabilité du code. Si certains lecteurs le trouvent aride et dépassé, beaucoup saluent son catalogue exhaustif de patrons et de leurs applications. Le livre est considéré comme une lecture essentielle pour les programmeurs orientés objet et propose des éclairages précieux sur la résolution des problèmes de conception courants. Les critiques soulignent que certains patrons sont peut-être moins pertinents dans les langages modernes, mais que les principes généraux restent importants. L’impact du livre sur les pratiques de développement logiciel est largement reconnu.

Votre note :
4.63
299 évaluations
Envie de lire le livre complet ?

Glossaire

patron de conception

Solution de conception réutilisable

Un patron de conception décrit un problème récurrent de conception orientée objet, l’agencement général des objets et des classes utilisé pour le résoudre, ainsi que les conséquences du choix de cet agencement. Ce n’est pas du code fini à copier tel quel. Les concepteurs l’adaptent à un contexte, un langage et un ensemble de contraintes particuliers.

Programmer en fonction d’une interface, et non d’une implémentation

S’appuyer sur des contrats de comportement

Un principe de conception qui indique aux clients de s’appuyer sur les opérations qu’un objet peut effectuer plutôt que sur sa classe concrète ou son implémentation interne. Différentes classes peuvent alors servir le même client si elles respectent la même interface. Cela réduit les dépendances à l’implémentation et facilite la substitution.

composition d’objets

Combiner des objets qui collaborent

Une technique de réutilisation qui assemble des objets dotés d’interfaces définies afin de créer des comportements plus complexes. Contrairement à l’héritage, qui fixe les relations entre les classes à la compilation, la composition permet de relier ou de remplacer des objets à l’exécution. Elle tend à préserver l’encapsulation, mais le réseau de relations qui en résulte peut être plus difficile à comprendre.

fabrique abstraite (Abstract Factory)

Créer des familles de produits compatibles

Un patron de création qui fournit une interface permettant de produire des objets apparentés sans nommer leurs classes concrètes. Le client choisit une fabrique concrète, qui crée une famille cohérente, par exemple des composants d’interface partageant un même style visuel. L’ajout d’un type de produit entièrement nouveau peut nécessiter de modifier l’interface de la fabrique et ses implémentations.

composite

Unifier les éléments et les groupes

Un patron structurel qui représente les hiérarchies partie-tout sous forme d’arbres. Les objets élémentaires et les groupes partagent une interface commune, ce qui permet aux clients de les traiter uniformément. Un composite transmet généralement les opérations à ses enfants. Cela simplifie les clients, mais peut rendre difficile la limitation des types d’enfants qu’un groupe accepte.

décorateur

Ajouter des responsabilités par encapsulation

Un patron structurel qui enveloppe un objet dans un autre objet partageant la même interface. L’enveloppe transmet les requêtes et peut ajouter un comportement avant ou après leur transmission. Les décorateurs peuvent être imbriqués ou retirés à l’exécution, offrant une solution de remplacement aux sous-classes pour des fonctionnalités facultatives comme les bordures ou le défilement.

pont

Séparer l’abstraction de l’implémentation

Un patron structurel qui sépare l’abstraction de son implémentation en deux hiérarchies de classes distinctes, reliées par composition. L’abstraction fournit l’interface utilisée par les clients, tandis que l’implémentation fournit les opérations de plus bas niveau, souvent spécifiques à une plateforme. Il est possible d’étendre chaque hiérarchie sans multiplier les sous-classes dans les deux.

stratégie

Rendre les algorithmes interchangeables

Un patron comportemental qui place chaque algorithme dans un objet distinct derrière une interface commune. Un contexte délègue le travail concerné à la stratégie qu’il a sélectionnée. Cela permet aux algorithmes de varier indépendamment des clients qui les utilisent et peut remplacer de longues chaînes de conditions, au prix d’objets et de décisions de sélection supplémentaires.

commande

Représenter une requête sous forme d’objet

Un patron comportemental qui encapsule une requête afin qu’elle puisse être transmise, stockée, mise en file, consignée ou exécutée ultérieurement. Une commande peut relier un objet déclencheur, tel qu’un élément de menu, à un destinataire qui sait comment effectuer l’action. Des états supplémentaires et des opérations d’annulation peuvent permettre l’annulation et le rétablissement.

mémento (Memento)

Enregistrer un état privé restaurable

Un patron comportemental qui stocke un instantané de l’état d’un objet sans rendre publique sa représentation interne. L’objet qui crée le mémento est chargé d’en lire et d’en restaurer le contenu ; un autre objet peut conserver l’instantané et le restituer au besoin. La copie d’états volumineux peut être coûteuse.

observateur

Notifier les objets dépendants

Un patron comportemental qui établit une relation un-à-plusieurs entre un sujet et ses observateurs. Lorsque le sujet change, il en informe les observateurs, qui peuvent se mettre à jour à partir des informations du sujet. Cela permet d’avoir différentes vues indépendantes de données partagées sans obliger le sujet à connaître leurs classes concrètes.

itérateur

Parcourir sans exposer le stockage

Un patron comportemental qui fournit un objet distinct pour accéder séquentiellement aux éléments. L’itérateur suit sa propre position, tandis que l’agrégat masque sa représentation interne. Différents itérateurs peuvent prendre en charge différents ordres de parcours, et plusieurs parcours peuvent s’effectuer indépendamment.

visiteur

Ajouter des opérations à des structures stables

Un patron comportemental qui place les opérations portant sur une structure d’objets dans des objets visiteurs distincts. Chaque élément accepte un visiteur et le redirige vers l’opération correspondant à sa classe. Cela facilite l’ajout de nouvelles opérations lorsque les classes d’éléments sont stables, mais l’ajout d’une nouvelle classe d’éléments nécessite souvent de mettre à jour chaque visiteur.

poids mouche (Flyweight)

Partager des objets pour économiser la mémoire

Un patron structurel qui réduit le coût d’un grand nombre d’objets fins en partageant des instances. Chaque objet partagé stocke un état intrinsèque, indépendant de l’endroit où il est utilisé ; les clients fournissent l’état extrinsèque, dépendant du contexte, au moment des requêtes. Cette approche économise de l’espace de stockage, mais peut ajouter des coûts de recherche et de transmission d’état.

FAQ

1. De quoi parle Design Patterns: Elements of Reusable Object-Oriented Software d’Erich Gamma ?

  • Un catalogue exhaustif de patrons de conception : Le livre nomme, explique et justifie systématiquement 23 patrons généraux qui répondent à des problèmes récurrents du développement logiciel orienté objet.
  • L’accent sur la conception orientée objet : Il met en avant l’utilisation des objets, de l’héritage et du polymorphisme pour créer des architectures logicielles flexibles, réutilisables et faciles à maintenir.
  • Des solutions réutilisables : Les patrons sont présentés comme des agencements éprouvés et généraux de classes et d’objets, adaptables à des problèmes de conception précis dans différents contextes.
  • Des exemples pratiques et des études de cas : Le livre comprend des exemples concrets et une étude de cas (l’éditeur Lexi) qui illustrent l’application des patrons dans la pratique.

2. Pourquoi lire Design Patterns d’Erich Gamma et de ses collaborateurs ?

  • Un vocabulaire commun de conception : Le livre fournit aux concepteurs de logiciels un langage commun qui facilite la communication, la documentation et la discussion de conceptions de systèmes complexes.
  • La transmission d’un savoir-faire expert : Il rassemble et synthétise l’expérience de spécialistes de la conception, aidant les débutants comme les programmeurs chevronnés à améliorer plus rapidement leurs compétences.
  • Facilite la réutilisation et la refactorisation des logiciels : Les patrons guident la création de composants logiciels réutilisables et servent de cibles de refactorisation, favorisant l’évolution des logiciels.
  • Une ressource largement saluée : Le livre est apprécié pour sa clarté, sa valeur pratique et son influence durable dans le domaine du génie logiciel.

3. Quels sont les principaux enseignements de Design Patterns: Elements of Reusable Object-Oriented Software ?

  • Les patrons comme solutions réutilisables : Les patrons de conception offrent des solutions élégantes et éprouvées à des problèmes de conception courants, favorisant la réutilisation du code et la flexibilité.
  • Trois grandes catégories de patrons : Les patrons sont répartis entre les catégories créationnelle, structurelle et comportementale, qui répondent chacune à des aspects différents de la conception logicielle.
  • Concevoir pour le changement : Le livre préconise de concevoir des systèmes faciles à étendre et à maintenir, en encapsulant la variabilité et en réduisant le couplage.
  • Des principes plutôt que des recettes : Au lieu de proposer des modèles rigides, le livre enseigne des principes et des compromis, et encourage une application réfléchie des patrons.

4. Que sont les patrons de conception selon Design Patterns d’Erich Gamma et de ses coauteurs ?

  • Définition et objectif : Un patron de conception décrit un problème récurrent dans un contexte donné et l’essentiel de sa solution, permettant de réutiliser cette dernière sans duplication.
  • Quatre éléments essentiels : Chaque patron comprend un nom, une description du problème, une esquisse de solution (abstraite, et non concrète) et les conséquences (compromis et résultats).
  • Capitaliser sur l’expérience en conception : Les patrons synthétisent les aspects clés des conceptions réussies, notamment les rôles des classes, leurs collaborations et leurs responsabilités, afin de faciliter la conception orientée objet réutilisable.

5. Comment les patrons de conception sont-ils organisés dans Design Patterns: Elements of Reusable Object-Oriented Software ?

  • Trois grandes catégories : Les patrons sont classés comme créationnels (création d’objets), structurels (composition de classes et d’objets) et comportementaux (communication entre objets).
  • Portée de la classe ou de l’objet : Les patrons sont également distingués selon qu’ils s’appliquent aux classes (statiquement, à la compilation) ou aux objets (dynamiquement, à l’exécution).
  • Un catalogue de patrons liés entre eux : Le livre propose des renvois et des diagrammes qui montrent les relations entre les patrons, leurs combinaisons possibles et les cas où ils peuvent se remplacer.

6. Quels sont les principaux patrons créationnels, structurels et comportementaux dans Design Patterns d’Erich Gamma ?

  • Patrons créationnels : Abstract Factory, Builder, Factory Method, Prototype et Singleton portent sur les mécanismes de création d’objets.
  • Patrons structurels : Adapter, Bridge, Composite, Decorator, Facade, Flyweight et Proxy portent sur la composition des classes et des objets.
  • Patrons comportementaux : Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method et Visitor portent sur la communication et la répartition des responsabilités entre objets.
  • Rôle des catégories : Chaque catégorie répond à un ensemble différent de difficultés récurrentes de conception dans les logiciels orientés objet.

7. Que signifie le principe « programmer en fonction d’une interface, et non d’une implémentation » dans Design Patterns d’Erich Gamma ?

  • L’interface plutôt que l’implémentation : Les clients devraient dépendre d’interfaces abstraites (souvent définies par des classes abstraites) plutôt que d’implémentations concrètes, afin de maximiser la flexibilité.
  • Permet le polymorphisme : Ce principe permet d’utiliser de façon interchangeable des objets de différentes classes s’ils partagent la même interface.
  • Favorise le découplage : Il réduit les dépendances entre les composants et facilite l’extension et la modification des systèmes.
  • Soutenu par les patrons de création : Des patrons comme Abstract Factory et Factory Method permettent d’instancier des objets sans lier les clients à des classes spécifiques.

8. Quelle différence y a-t-il entre l’héritage et la composition comme mécanismes de réutilisation dans Design Patterns d’Erich Gamma ?

  • Héritage (réutilisation en boîte blanche) : Il partage l’implémentation par le biais des sous-classes, mais expose celles-ci aux détails internes de la classe parente, ce qui peut compromettre l’encapsulation et limiter la flexibilité.
  • Composition (réutilisation en boîte noire) : Elle assemble dynamiquement des objets au moyen d’interfaces bien définies, préserve l’encapsulation et permet au comportement de varier à l’exécution.
  • Recommandation de conception : Le livre recommande de privilégier la composition d’objets plutôt que l’héritage de classes afin de conserver des conceptions flexibles, ciblées et réutilisables.
  • Exemples de patrons : De nombreux patrons, tels que Decorator et Strategy, exploitent la composition pour une plus grande adaptabilité.

9. Comment fonctionne la délégation dans Design Patterns: Elements of Reusable Object-Oriented Software et quels patrons l’utilisent ?

  • Principe de la délégation : Un objet traite une requête en la déléguant à un autre objet, de façon comparable à la manière dont les sous-classes s’en remettent aux classes parentes dans l’héritage.
  • Permet un comportement dynamique : La délégation permet de composer dynamiquement les comportements à l’exécution, ce qui accroît la flexibilité.
  • Utilisation dans les patrons : Parmi les principaux patrons qui utilisent la délégation figurent State, Strategy, Visitor, Mediator, Chain of Responsibility et Bridge.
  • Avantages : La délégation favorise l’encapsulation et facilite la modification ou l’extension du comportement des objets sans modifier le code existant.

10. Comment Design Patterns d’Erich Gamma illustre-t-il l’utilisation des patrons dans une application réelle ?

  • Étude de cas Lexi : Le livre présente Lexi, un éditeur de documents WYSIWYG, comme exemple complet de l’application des patrons.
  • Plusieurs patrons à l’œuvre : Des patrons tels que Composite, Strategy, Decorator, Abstract Factory, Bridge, Command, Iterator et Visitor servent à résoudre des problèmes pratiques de conception.
  • Illustration de l’interaction entre patrons : L’étude de cas montre comment les patrons peuvent se combiner et interagir au sein d’un système complexe.
  • Apprendre par l’exemple : Ce scénario concret aide les lecteurs à comprendre la valeur pratique des patrons de conception et leur mise en œuvre.

11. Quels sont quelques patrons structurels importants dans Design Patterns d’Erich Gamma et comment fonctionnent-ils ?

  • Decorator : Ajoute dynamiquement des responsabilités aux objets en les enveloppant, évitant la prolifération des sous-classes et permettant de combiner les fonctionnalités avec souplesse.
  • Facade : Fournit une interface unifiée et simplifiée à un sous-système complexe, réduisant les dépendances et facilitant l’utilisation des systèmes.
  • Flyweight : Partage efficacement des objets fins en séparant l’état intrinsèque (partagé) de l’état extrinsèque (dépendant du contexte), ce qui réduit l’utilisation de la mémoire.
  • Proxy : Sert de substitut ou de mandataire à un autre objet, en contrôlant l’accès, en différant sa création ou en ajoutant des fonctionnalités de manière transparente.

12. Comment les patrons comportementaux comme Observer, State et Visitor fonctionnent-ils dans Design Patterns d’Erich Gamma ?

  • Observer : Établit une dépendance un-à-plusieurs, de sorte que lorsqu’un objet change d’état, toutes ses dépendances sont automatiquement informées et mises à jour, ce qui favorise un couplage faible.
  • State : Encapsule dans des objets distincts les comportements propres à chaque état, permettant à un objet de modifier son comportement lorsque son état interne change et remplaçant les conditions complexes.
  • Visitor : Sépare les opérations de la structure d’objets et permet d’ajouter de nouvelles opérations sans modifier les classes d’éléments, grâce à la double répartition qui apporte de la flexibilité.
  • Compromis des patrons : Ces patrons simplifient la communication, la gestion des états et l’ajout d’opérations, mais peuvent introduire de la complexité ou rendre plus difficile l’ajout de nouveaux types d’éléments.

À propos de l'auteur

Erich Gamma est un éminent informaticien suisse, surtout connu pour avoir coécrit l’ouvrage influent « Design Patterns: Elements of Reusable Object-Oriented Software ». Souvent désigné comme le livre du « Gang of Four », cet ouvrage a révolutionné le génie logiciel en introduisant et en répertoriant les patrons de conception. Les contributions de Gamma ont profondément marqué les pratiques modernes de programmation orientée objet et l’architecture logicielle. Son travail a été largement adopté dans l’industrie et est enseigné dans les cursus d’informatique du monde entier. Gamma a également participé au développement d’autres projets logiciels remarquables et n’a cessé d’influencer le génie logiciel tout au long de sa carrière.

Télécharger le PDF

Pour garder le résumé de Design Patterns pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Design Patterns sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
600,000+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...