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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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é des avis
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.
Les lecteurs ont aussi lu
Glossaire
patron de conception
Solution de conception réutilisableUn 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 comportementUn 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 collaborentUne 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 compatiblesUn 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 groupesUn 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 encapsulationUn 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émentationUn 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 interchangeablesUn 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’objetUn 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é restaurableUn 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épendantsUn 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 stockageUn 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 stablesUn 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émoireUn 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.
Télécharger le PDF
Télécharger l'EPUB
.epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.