Points clés
Concevez en fonction des changements auxquels votre code est le plus susceptible d’être confronté.
Le changement est le véritable test. SimUDuck commence par un raccourci familier: placer le comportement de vol dans une superclasse Duck partagée afin que tous les canards puissent le réutiliser. Ce raccourci fait voler les canards en caoutchouc et signifie que chaque nouveau type de comportement de vol nécessite davantage de redéfinitions. L’erreur plus profonde consiste à traiter l’héritage comme une sagesse de conception automatique, au lieu de se demander ce qui varie et ce qui reste stable.
Séparez les variations probables. Extrayez le comportement susceptible de changer dans son propre composant, puis faites dépendre le reste du système d’un contrat stable. Les règles pratiques du livre sont d’encapsuler ce qui varie, de privilégier la composition plutôt que l’héritage et de programmer en fonction d’un supertype plutôt que d’une classe concrète. Ce sont des repères, pas des ordres d’abstraire chaque ligne de code.
Ce qui frappe, c’est que la mauvaise conception des canards échoue à cause d’un effet secondaire non local : une petite modification de la superclasse change le comportement de classes qui n’étaient pas censées voler. C’est une façon utile d’évaluer une architecture. La question essentielle n’est pas de savoir si l’héritage est élégant, mais si les effets d’un changement sont prévisibles. L’abstraction a toutefois un coût. Concevoir pour des avenirs imaginés peut rendre un code simple plus difficile à lire ; la direction probable des changements compte donc davantage qu’une flexibilité hypothétique.
Composez les comportements afin qu’un changement d’algorithme ne vous oblige pas à réécrire ses clients.
Donnez au comportement son propre type. Les canards repensés contiennent des références à des comportements de vol et de cancanement distincts. Un colvert peut voler grâce à ses ailes et cancaner normalement, tandis qu’un canard en caoutchouc peut couiner et rester au sol. Chaque comportement implémente une interface commune, et Duck lui délègue le travail au lieu de prendre en charge toutes les implémentations.
Remplacez les comportements délibérément. Puisque le canard contient un objet de comportement, on peut attribuer à un canard en modèle réduit un vol propulsé par fusée pendant l’exécution du programme. C’est le patron stratégie: une famille d’algorithmes est encapsulée derrière un type commun, de sorte que les clients peuvent utiliser des implémentations interchangeables. La composition permet également à des objets sans lien, comme un appeau à canard, de réutiliser le même comportement de cancanement.
Ce patron transforme le comportement en dépendance remplaçable : un changement puissant, qui consiste à ne plus classer les objets selon ce qu’ils sont, mais à les assembler à partir de ce qu’ils font. La variation à l’exécution devient ainsi simple et la réutilisation dépasse la hiérarchie d’origine. En contrepartie, il faut davantage d’objets et d’indirections. Si un algorithme est stable et trivial, une classe stratégie risque de n’être qu’un cérémonial plutôt qu’une source de flexibilité. Cette conception se justifie lorsque le comportement varie réellement indépendamment des clients qui l’appellent.
Laissez les objets intéressés s’abonner sans que le sujet connaisse leur identité.
Une source, plusieurs observateurs. Dans la station météo, WeatherData possède la température, l’humidité et la pression. Les objets d’affichage s’inscrivent comme observateurs, et WeatherData les avertit lorsque les mesures changent. Un affichage des conditions actuelles, un affichage des statistiques et un affichage des prévisions peuvent réagir différemment à la même mise à jour. De nouveaux affichages peuvent s’abonner ou se désabonner sans modifier l’implémentation du sujet.
Gardez le contrat de notification limité. Le patron observateur définit une dépendance de un à plusieurs: lorsqu’un sujet change, ses dépendants en sont avertis. L’exemple transmet d’abord toutes les mesures à chaque affichage, puis envisage une conception par interrogation, dans laquelle les observateurs utilisent des accesseurs pour récupérer les données dont ils ont besoin. La transmission directe est simple; l’interrogation peut éviter de fournir des données inutiles et s’adapte aux nouveaux champs ajoutés au sujet.
Cette conception permet l’extension par inscription plutôt que par modification. On la retrouve dans des interfaces comme les écouteurs de boutons, car une source d’événements n’a pas besoin de connaître le rôle de chaque écouteur. Le choix entre transmission directe et interrogation met également en lumière une question plus générale d’API : le producteur doit-il décider de ce dont les consommateurs ont besoin, ou chaque consommateur doit-il sélectionner sa propre vue de l’état ? Aucune option n’est toujours la meilleure. Dans les systèmes réels, l’ordre, le volume des événements et les attentes en matière de cohérence doivent être explicités.
Ajoutez des responsabilités en enveloppant les objets, plutôt qu’en multipliant les sous-classes.
Composez les commandes en couches. La première approche de Starbuzz crée une classe distincte pour chaque combinaison de boisson et de condiment. Avec plusieurs bases et garnitures, la liste des classes s’allonge à l’excès, et les changements de prix doivent être répercutés partout. Le patron décorateur consiste plutôt à envelopper une boisson avec des objets représentant les condiments. On peut envelopper un Dark Roast de deux doses de Mocha, puis de Whip; chaque couche ajoute sa description et son coût avant de déléguer à la couche intérieure.
Préservez le type du composant. Les décorateurs partagent l’interface des objets qu’ils enveloppent, si bien qu’une boisson décorée peut toujours être traitée comme une boisson. Les entrées-sorties Java reposent sur la même idée lorsqu’elles mettent des flux en mémoire tampon ou les décompressent. Cette approche a pour coûts un grand nombre de petites classes, une construction plus complexe et des problèmes possibles pour le code client qui dépend d’une classe concrète.
Le décorateur est particulièrement efficace lorsque des fonctionnalités facultatives se combinent selon de nombreuses configurations, car celles-ci sont assemblées à l’exécution au lieu d’être énumérées dans une hiérarchie de classes. L’exemple des boissons rend visibles les calculs comme la structure. Cette transparence reste toutefois conditionnelle : un client qui vérifie le type concret peut échouer lorsqu’un enveloppeur s’interpose. Avant d’adopter les décorateurs, il est donc utile de vérifier que les clients dépendent du contrat du composant et que la construction est suffisamment centralisée pour que les chaînes d’enveloppeurs restent compréhensibles.
Centralisez les règles de création, du choix des familles de produits à la garantie d’une instance unique.
Sortez les décisions du code client. La longue suite de conditions de la pizzeria connaît toutes les pizzas concrètes; ajouter un produit oblige donc à rouvrir ce code. Une Fabrique simple place le choix dans un objet de création. Le patron méthode fabrique va plus loin: une sous-classe de pizzeria fournit la pizza, tandis que la superclasse conserve le processus de commande. Le patron fabrique abstraite crée des familles de produits liés, comme la pâte, la sauce et le fromage propres à une région, sans faire dépendre la pizza de leurs types concrets.
Choisissez la garantie appropriée. Un singleton contrôle la création lorsqu’une classe doit n’avoir qu’une instance partagée, comme la chaudière à chocolat. La version classique à instanciation différée exige de la prudence en cas d’accès concurrent. Une création anticipée évite cette course; la synchronisation ou le verrouillage à double vérification sont d’autres possibilités. Le livre présente également les énumérations Java comme une manière concise d’implémenter un singleton.
Les fabriques et les singletons rendent tous deux explicites les règles de création, mais répondent à des problèmes différents. Les fabriques isolent les clients des choix de produits concrets ; un singleton limite le nombre d’instances. Les exemples de pizzerias montrent que le sens des dépendances compte autant que la construction des objets : la logique de commande de haut niveau peut s’appuyer sur des abstractions, tandis que les implémentations régionales fournissent les détails. Le singleton mérite davantage de scepticisme, car un accès global peut insidieusement devenir un couplage global. Réservez-le aux ressources qui exigent réellement une identité partagée.
Transformez les requêtes en objets pour bénéficier de l’annulation, des files d’attente et des journaux.
Séparez la personne qui demande de celle qui exécute. Une télécommande domestique possède des boutons génériques, tandis que les appareils de différents fabricants proposent des actions incompatibles, comme tamiser les lumières, ouvrir un garage ou régler le volume de la chaîne stéréo. Un objet commande associe une requête au récepteur capable de l’exécuter. La télécommande stocke les commandes dans des emplacements et invoque une méthode execute commune, sans connaître les étapes propres à chaque appareil.
Faites des actions des données réutilisables. Une commande peut être placée dans la file d’attente d’un thread de travail, enregistrée pour permettre une récupération, intégrée à une macro ou associée à une annulation. Annuler revient sur la dernière action; une commande de ventilateur de plafond doit mémoriser sa vitesse précédente. Une commande sans opération occupe les emplacements inutilisés et évite les tests de valeurs nulles. Ce patron peut entraîner la création de classes supplémentaires, mais les expressions lambda peuvent remplacer les objets commande simples lorsque l’interface ne comporte qu’une seule méthode abstraite.
Les objets commande rendent une action transportable : on peut la stocker, la différer, la composer ou l’annuler. Il ne s’agit pas seulement d’une astuce ingénieuse pour une télécommande ; cela sépare le moment où une requête est formulée de celui où le travail est effectué. L’annulation révèle également une limite importante : pour revenir en arrière, il faut disposer d’assez d’informations pour rétablir l’état antérieur, et certains effets ne peuvent pas être annulés proprement. Une interface commande fournit une structure, pas une réversibilité magique ; chaque opération nécessite donc une stratégie réaliste de récupération.
Utilisez des adaptateurs pour traduire les interfaces et des façades pour les simplifier.
Traduisez les contrats incompatibles. Un client conçu pour des canards ne peut pas appeler directement la méthode gobble d’une dinde. TurkeyAdapter implémente l’interface Duck attendue et transmet les demandes de quack à gobble. Le client peut alors utiliser la dinde sans connaître cette incompatibilité. La même idée permet d’adapter les objets Java Enumeration historiques au code qui attend un Iterator, bien que la suppression ne soit pas prise en charge et doive signaler une opération non prise en charge.
Offrez un point d’entrée utile à un sous-système. Le cinéma maison nécessite une suite d’appels à un projecteur, un amplificateur, un écran, des lumières, un lecteur et une machine à pop-corn. Une façade propose une opération simple pour regarder un film, tout en laissant les composants accessibles aux clients qui ont besoin d’un contrôle plus précis. Le Principe de moindre connaissance conseille aux objets de communiquer avec leurs collaborateurs proches plutôt que de parcourir des chaînes d’objets renvoyés.
Les deux patrons ajoutent une couche, mais leur intention les distingue. Un adaptateur préserve le contrat attendu par le client tout en traduisant un autre contrat. Une façade propose un chemin plus simple à travers un sous-système. La règle de moindre connaissance facilite le raisonnement sur les dépendances, mais appliquée mécaniquement, elle peut créer des couches de méthodes de redirection triviales. Il faut se demander si l’enveloppeur protège une véritable frontière ou s’il masque simplement un appel sans réduire un couplage significatif.
Fixez l’ordre d’un algorithme et laissez les sous-classes compléter certaines étapes.
Centralisez la recette. Le café et le thé suivent la même séquence: chauffer l’eau, extraire la boisson, la verser et ajouter les condiments. Le patron méthode gabarit place cette séquence dans une méthode de la superclasse, tandis que les sous-classes implémentent les étapes qui diffèrent, comme préparer le café ou faire infuser le thé. Cela évite de dupliquer la logique de la recette et en préserve l’ordre.
Utilisez des points d’extension pour les choix facultatifs. Un point d’extension est une méthode avec une implémentation par défaut qu’une sous-classe peut redéfinir. L’exemple des boissons en utilise un pour décider s’il faut ajouter des condiments. En Java, le tri fournit un exemple moins scolaire: Arrays contrôle l’algorithme de tri, mais s’appuie sur la méthode compareTo d’un objet pour déterminer l’ordre. Cette approche convient aux frameworks qui contrôlent le déroulement tout en autorisant certaines extensions.
Le patron méthode gabarit est un framework miniature : la classe de base contrôle la procédure et les sous-classes apportent des variations délimitées. C’est utile lorsque la séquence elle-même participe à la correction, comme dans une recette ou un cycle de vie. Le coût est un couplage fondé sur l’héritage. Trop d’étapes abstraites alourdissent chaque sous-classe, tandis que des points d’extension trop généraux rendent le comportement difficile à prévoir. Le meilleur gabarit n’expose que les points de variation qui ont un véritable sens dans le domaine.
Dissimulez le stockage des collections derrière des itérateurs, puis composez les collections en arbres.
Séparez le parcours du stockage. Le restaurant fusionné possède un menu fondé sur un tableau Array et un autre sur une ArrayList. Sans itérateurs, la serveuse doit utiliser des boucles différentes et connaître chaque représentation. Un Iterator fournit une manière commune de vérifier s’il reste un élément et de le récupérer. Les menus peuvent ainsi conserver leur mode de stockage tandis que le client les parcourt uniformément.
Traitez les éléments imbriqués comme un tout. Lorsque les menus s’enrichissent de sous-menus, une liste plate ne suffit plus. Le patron composite organise menus et articles en arbre, ce qui permet à la serveuse d’appeler print sur le menu de premier niveau et de laisser l’opération se propager à ses enfants. Le patron composite échange une part de sûreté contre de la transparence: des opérations communes simplifient le code client, mais un article de menu peut hériter d’opérations qui n’ont aucun sens pour lui.
L’itérateur et le patron composite résolvent des problèmes voisins, mais distincts. Le premier dissimule la manière dont une collection est parcourue ; le second permet d’utiliser une hiérarchie de collections et d’éléments au moyen d’une interface commune. Ensemble, ils transforment le client : au lieu de gérer des structures de données, il utilise des capacités. Le choix de la conduite à tenir pour les opérations non prises en charge a des conséquences importantes : l’uniformité réduit les embranchements, tandis que des interfaces plus strictes empêchent les appels invalides. Le juste équilibre dépend de l’importance accordée à la simplicité du client ou à la sûreté à la compilation.
Remplacez les conditions dépendant de l’état par des objets d’état qui prennent en charge leur propre comportement.
Rendez les états explicites. La première machine à boules de gomme stocke un état sous forme d’entier et répète des tests conditionnels dans chacune de ses actions. Ajouter un état gagnant signifie modifier de nombreuses méthodes et risque de produire des transitions incohérentes. Le patron état attribue à chaque situation son propre objet, comme NoQuarter, HasQuarter, Sold et SoldOut. La machine délègue les actions à son état actuel, et les objets d’état gèrent à la fois les réponses et les transitions.
Payez la clarté avec des classes. La promotion d’une chance sur dix ajoute un WinnerState qui distribue deux boules de gomme lorsqu’un joueur est admissible. La structure ressemble à celle de la stratégie, mais l’objectif diffère: un objet d’état reflète la situation actuelle du contexte, tandis qu’une stratégie est généralement choisie pour fournir un algorithme. L’ajout de classes améliore la localisation du comportement, mais les transitions peuvent créer des dépendances entre les objets d’état.
Les objets d’état transforment une logique à embranchements en un modèle qui reflète les conditions de fonctionnement de la machine. Cela peut faciliter l’examen et l’extension des transitions, surtout lorsque les actions invalides appellent des réponses distinctes. Ce gain n’est pas gratuit : quelques conditions peuvent être plus claires sous la forme d’un petit test conditionnel que dans une hiérarchie de classes. Le patron état est particulièrement convaincant lorsque le comportement propre à chaque état est substantiel, que les transitions sont nombreuses et que l’état actuel est une notion importante du domaine.
Interposez un proxy entre les clients et les objets distants, coûteux ou protégés.
Préservez le contrat du client. À l’origine, le moniteur de la machine à boules de gomme lit les données d’une machine locale. Lorsque le PDG a besoin de rapports sur des machines éloignées, le moniteur peut utiliser la même interface distante, tandis qu’un proxy se charge de la recherche et des appels réseau. Java RMI fournit une grande partie des mécanismes nécessaires, mais le client doit tout de même gérer les exceptions distantes, car les opérations réseau peuvent échouer.
Contrôlez l’accès d’autres façons. Un proxy virtuel prend la place d’une image coûteuse à charger, affiche un message provisoire puis délègue à l’image. Un proxy de protection autorise ou refuse des méthodes en fonction de l’appelant, comme dans le service de rencontres où les utilisateurs peuvent modifier leur propre profil, mais pas leur propre évaluation. Les proxies ont une structure commune avec les décorateurs, mais contrôlent l’accès plutôt que d’ajouter principalement des responsabilités.
Le patron proxy regroupe différentes techniques de gestion des frontières. Il peut masquer l’emplacement, différer un travail coûteux ou appliquer des permissions tout en préservant l’interface attendue par un client. Cette cohérence est puissante, mais des appels distants transparents peuvent dissimuler la latence et les défaillances si l’API laisse croire que le réseau est local. L’exemple de RMI le reconnaît en faisant intervenir des exceptions. Un proxy devrait simplifier l’accès sans inciter les clients à oublier les réalités opérationnelles qu’il gère.
Considérez le MVC comme une collaboration entre patrons, et non comme un modèle à imposer partout.
Répartissez les responsabilités de l’application. Dans le Modèle-vue-contrôleur, le modèle contient les données et la logique de l’application, la vue les présente et le contrôleur interprète les actions de l’utilisateur. Le modèle avertit les vues intéressées lorsque son état change. Le contrôleur joue le rôle d’une stratégie pour la vue, tandis qu’une interface graphique prend souvent la forme d’un composite de composants imbriqués. Un adaptateur peut relier un autre modèle à une vue et à un contrôleur existants.
Utilisez les patrons lorsqu’ils conviennent. Le simulateur de canards associe fabriques, adaptateurs, décorateurs, composites, itérateurs et observateurs pour illustrer la coopération entre patrons. Le livre précise qu’il s’agit d’un exercice artificiel, et non d’une recette pour chaque conception. Les patrons transmettent une expérience de conception éprouvée, mais peuvent ajouter des classes et de la complexité. Commencez par la conception la plus simple qui réponde aux exigences réelles, puis remaniez-la lorsqu’un besoin véritable apparaît.
Le MVC se comprend plus facilement comme une séparation des changements : la présentation de l’interface, l’interprétation des actions de l’utilisateur et l’état de l’application évoluent à des rythmes différents. La composition de patrons est utile précisément parce que chacun traite une relation locale. Toutefois, l’étiquette peut masquer des différences considérables entre les implémentations de bureau et du Web. La mise en garde du livre contre la fièvre des patrons est donc essentielle. Un patron est une décision de conception réutilisable, pas un titre de compétence, et la simplicité reste une réussite architecturale à part entière.
Analyse
La principale réussite du livre est d’enseigner les patrons de conception comme des décisions concernant le changement, et non comme du vocabulaire à mémoriser. Le simulateur de canards rend concret le coût de l’héritage: une méthode partagée, pratique en apparence, propage un comportement à des sous-classes auxquelles il ne convient pas. Chaque exemple suivant pose alors une question pratique: qu’est-ce qui change indépendamment, à qui revient la responsabilité de ce changement, et dans quelle mesure les objets voisins doivent-ils en avoir connaissance? Cette démarche donne aux patrons une logique cohérente malgré leur diversité.
La structure pédagogique du livre est elle-même délibérée. Des récits familiers, de petits fragments de code, des exercices, des schémas et des explications répétées offrent plusieurs voies d’accès aux idées abstraites. Le restaurant présente les commandes comme un processus social; les franchises de pizzerias montrent comment les fabriques gèrent les variations régionales; la machine à boules de gomme rend visibles les comportements liés aux transitions d’état. Le sujet, souvent enseigné comme une taxonomie, devient ainsi particulièrement accessible. La limite est que des exemples pédagogiques concis peuvent donner une image plus nette des mécanismes des frameworks que celle des systèmes de production. Les appels distribués échouent, les collections sont modifiées, les transitions d’état deviennent concurrentes et les abstractions peuvent accumuler des indirections inutiles. Le livre reconnaît plusieurs de ces coûts, notamment pour les singletons, les décorateurs, les composites et les proxies, mais ses exemples sont volontairement succincts.
La leçon la plus durable n’est pas que chaque problème possède un patron portant un nom. C’est que la qualité d’une conception dépend du placement des variations à une frontière où elles peuvent être modifiées sans perturber du code sans rapport avec elles. Les patrons nomment des choix récurrents concernant ces frontières: déléguer un comportement, avertir des abonnés, envelopper des responsabilités, centraliser la création, regrouper des requêtes, traduire des interfaces ou représenter explicitement un état. Leur valeur est à la fois technique et sociale, puisqu’un nom partagé condense une discussion sur la conception. Mais ce raccourci comporte aussi un danger: une étiquette familière peut se substituer à l’analyse. Utilisés avec mesure, les patrons constituent un vocabulaire pour expliquer des compromis, et non un substitut au discernement.
Résumé des avis
Tête la Première Design Patterns reçoit des avis extrêmement positifs pour son approche captivante et accessible de l’enseignement des patrons de conception. Les lecteurs saluent son humour, ses exemples tirés du monde réel et ses techniques d’apprentissage interactives. Beaucoup le trouvent supérieur aux manuels traditionnels, surtout pour les débutants. Le livre est apprécié pour la clarté de ses explications, ses exemples pratiques et l’importance qu’il accorde aux situations où les patrons sont utiles. Certains lecteurs remarquent que tous les patrons ne sont pas approfondis, mais, dans l’ensemble, il est vivement recommandé comme introduction aux patrons de conception pour les programmeurs de différents niveaux d’expérience.
Les lecteurs ont aussi lu
Glossaire
Patron stratégie
Comportement interchangeableUn patron qui définit une famille d’algorithmes, donne à chacun sa propre implémentation derrière un type commun et permet aux clients de les utiliser de manière interchangeable. Un contexte délègue le travail au comportement choisi plutôt que de coder en dur chaque variation. Dans l’exemple des canards, le vol et le coin-coin sont des comportements indépendants qui peuvent être combinés avec différents canards.
Patron observateur
Notification un-à-plusieursUn patron qui établit une dépendance un-à-plusieurs entre un sujet et ses observateurs. Les observateurs s’inscrivent pour être informés des changements, et le sujet les avertit lorsque son état change. Le sujet dépend du contrat des observateurs, et non de l’identité ou de la fonction d’observateurs particuliers, ce qui permet d’ajouter et de retirer des affichages ou des écouteurs indépendamment.
Patron décorateur
Enveloppe de responsabilités à l’exécutionUn patron qui attribue des responsabilités à un objet en l’enveloppant dans un autre objet partageant sa même interface. Un décorateur peut ajouter un comportement avant ou après avoir délégué au composant enveloppé. Plusieurs décorateurs peuvent être empilés à l’exécution, comme dans une commande de café composée d’une boisson et d’enveloppes facultatives représentant les condiments.
Fabrique simple (Simple Factory)
Sélection centralisée des objetsUne idiomatique de programmation courante, plutôt qu’un patron GoF formel, qui déplace la sélection des objets concrets vers une méthode ou un objet de création dédié. Les clients demandent un produit à la fabrique au lieu de contenir une logique conditionnelle répétée et des instanciations directes. Elle centralise les changements, mais n’offre pas la flexibilité des sous-classes du patron méthode fabrique.
Patron méthode fabrique
Création choisie par les sous-classesUn patron qui déclare une méthode de création dans une classe créatrice et laisse les sous-classes l’implémenter pour choisir le produit concret. Les autres opérations du créateur peuvent fonctionner avec l’abstraction du produit sans connaître sa classe exacte. Dans la pizzeria, les sous-classes régionales choisissent la pizza, tandis que la superclasse commune contrôle la commande et la préparation.
Patron fabrique abstraite
Familles de produits liésUn patron qui fournit une interface pour créer des familles de produits liés sans nommer leurs classes concrètes. Chaque fabrique concrète fournit une famille cohérente, comme une pâte, une sauce et un fromage régionaux pour les pizzas. Les clients dépendent de la fabrique abstraite et des interfaces des produits ; une famille peut donc changer sans qu’il soit nécessaire de réécrire la logique du client.
Patron singleton
Instance unique partagéeUn patron qui garantit qu’une classe n’a qu’une seule instance et fournit un point d’accès global à celle-ci. Les implémentations doivent tenir compte de l’initialisation et de la concurrence. Le livre compare la création différée, la synchronisation, l’initialisation anticipée, le verrouillage à double vérification et les énumérations Java, tout en soulignant que l’accès global peut créer du couplage.
Patron commande
Requête sous forme d’objetUn patron qui encapsule une requête dans un objet, généralement en associant une action au récepteur qui l’exécute. Un invocateur peut exécuter des commandes sans en connaître les détails. Comme les commandes peuvent être stockées, mises en file d’attente, consignées, regroupées ou associées à une annulation, ce patron sépare le moment où une requête est faite de la manière dont elle est exécutée.
Patron adaptateur
Traducteur d’interfacesUn patron qui convertit une interface en une autre, attendue par un client. L’adaptateur implémente le contrat cible et délègue à un objet doté d’une interface incompatible. Le code client existant peut ainsi fonctionner avec une classe nouvelle ou ancienne sans modifier l’un ou l’autre côté, comme lorsqu’une dinde est présentée comme un canard.
Patron façade
Interface simplifiée pour un sous-systèmeUn patron qui fournit une interface unifiée de plus haut niveau à un sous-système composé de plusieurs classes ou d’interactions complexes. Une façade délègue le travail au sous-système tout en simplifiant les tâches courantes pour les clients. Elle n’a pas à masquer ni à supprimer les interfaces de plus bas niveau du sous-système, qui restent disponibles lorsqu’un contrôle plus précis est nécessaire.
Patron méthode gabarit
Squelette d’algorithme fixeUn patron qui définit la structure d’un algorithme dans une méthode tout en reportant certaines étapes aux sous-classes. La superclasse contrôle la séquence ; les sous-classes implémentent les étapes abstraites et peuvent redéfinir les points d’extension facultatifs. Le café et le thé suivent une séquence de préparation commune, mais diffèrent par les étapes d’infusion et d’ajout des condiments.
Patron itérateur
Parcours masqué d’une collectionUn patron qui fournit une manière standard d’accéder séquentiellement aux éléments d’un agrégat sans en révéler la représentation interne. L’itérateur prend en charge le parcours, ce qui permet au code client de travailler avec des tableaux, des listes ou d’autres collections à travers une interface commune. La gestion des collections est ainsi séparée de leur parcours, ce qui simplifie le code client.
Patron composite
Structures arborescentes uniformesUn patron qui compose des objets individuels et des groupes d’objets en structures arborescentes représentant des relations entre parties et ensembles. Les clients peuvent appliquer uniformément des opérations aux feuilles et aux composites, par exemple aux éléments de menu et aux menus imbriqués. Une conception transparente simplifie le code client, mais peut exposer des opérations qui n’ont pas de sens pour tous les composants.
Patron état
Comportement propre à chaque étatUn patron qui représente les états d’un objet sous forme d’objets distincts et délègue le comportement à l’état courant. Les actions et transitions propres à chaque état résident dans ces objets plutôt que dans des branches conditionnelles répétées du contexte. Le comportement de la machine à boules de gomme change à mesure qu’elle passe par des états tels que « en attente d’une pièce », « vendue » et « épuisée ».
Patron proxy
Accès contrôlé à un objetUn patron qui fournit un représentant d’un autre objet et en contrôle l’accès. Un proxy distant relaie les appels réseau, un proxy virtuel remplace temporairement un objet coûteux pendant sa création et un proxy de protection limite les opérations selon l’appelant. Les proxies conservent généralement l’interface du sujet tout en modifiant la manière dont l’accès est géré.
Modèle-vue-contrôleur
Rôles applicatifs séparésUn patron composé qui répartit une application entre un modèle contenant l’état et la logique, une vue qui présente cet état et un contrôleur qui interprète les actions de l’utilisateur. Le modèle peut avertir les vues à l’aide du patron observateur, un contrôleur peut servir de patron stratégie pour une vue, et une vue peut utiliser le patron composite pour les éléments d’interface imbriqués.
Principe ouvert-fermé
Étendre sans modifierUn principe de conception qui privilégie les classes auxquelles on peut ajouter de nouveaux comportements par extension sans modifier le code établi. C’est un objectif, et non une obligation de rendre chaque classe extensible à l’infini. Les décorateurs et les observateurs illustrent des manières d’ajouter des comportements ou des participants tout en laissant les implémentations existantes inchangées.
Principe d’inversion des dépendances
Dépendre d’abstractionsUn principe de conception qui recommande aux composants de haut et de bas niveau de dépendre d’abstractions plutôt que directement des implémentations concrètes les uns des autres. Dans l’exemple de la pizzeria, la boutique et les pizzas concrètes dépendent toutes deux de l’abstraction Pizza. Les fabriques aident à éliminer les dépendances directes liées à la construction, mais ce principe est une recommandation, et non une règle absolue.
Principe de moindre connaissance
Limiter les collaborateurs directsUn principe de conception qui recommande à un objet de ne communiquer qu’avec ses proches collaborateurs, par exemple lui-même, ses paramètres, les objets qu’il crée et ses composants. Éviter les chaînes d’appels qui passent par des objets renvoyés par d’autres méthodes peut limiter la propagation des dépendances. Ce principe peut aussi entraîner la création de méthodes de délégation ; il faut donc mettre ses avantages en balance avec la complexité ajoutée.
Principe de Hollywood
Flux de contrôle de haut niveauUn principe de conception selon lequel les composants de haut niveau contrôlent le processus global et appellent les composants de bas niveau lorsque leurs contributions sont nécessaires. Les composants de bas niveau peuvent être intégrés au cadre sans le contrôler ni dépendre directement de son code de haut niveau. Le patron méthode gabarit et le patron méthode fabrique illustrent cette organisation.
Principe de responsabilité unique
Une seule raison de changerUn principe de conception selon lequel une classe doit avoir une seule responsabilité, entendue comme une seule raison principale de changer. Séparer la gestion d’une collection de son parcours peut améliorer la cohésion, car les changements de stockage et de parcours n’ont pas à affecter la même classe. Le patron composite illustre un compromis : une interface uniforme peut réunir des responsabilités afin de simplifier le code client.
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.