Introduction aux patrons de conception

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 64 sur 87.

Les patrons de conception sont des solutions éprouvées aux problèmes courants que les développeurs rencontrent régulièrement lors de la création de logiciels. Plutôt que de réinventer la roue à chaque fois, vous pouvez appliquer ces modèles éprouvés pour résoudre des problèmes de conception récurrents.

Considérez les patrons de conception comme des plans. Ils ne vous fournissent pas de code fini à copier-coller, mais décrivent comment structurer vos classes et vos objets pour résoudre un type spécifique de problème. Les patrons que vous allez apprendre s’appuient sur les concepts de la POO que vous maîtrisez déjà : héritage, interfaces, polymorphisme et composition.

Les patrons de conception se répartissent en trois grandes catégories :

Catégorie	Objectif	Exemples
Creational	Comment les objets sont créés	Singleton, Factory, Builder
Structural	Comment les objets sont composés	Adapter, Decorator, Composite
Behavioral	Comment les objets communiquent	Observer, Strategy, Command

Pourquoi apprendre les patrons de conception ? Ils vous donnent un vocabulaire commun avec les autres développeurs : dire « utilisez une Factory ici » communique instantanément une idée complexe. Ils vous aident également à écrire un code plus flexible et plus facile à maintenir en appliquant des principes tels que « programmez contre une interface, pas contre une implémentation ».

Dans les prochaines leçons, tu implémenteras plusieurs modèles essentiels, en commençant par des modèles de création comme Singleton et Factory, puis en passant à des modèles comportementaux comme Observer et Strategy.

Défi

Facile

Construisons un classificateur simple de motifs qui démontre ta compréhension des trois catégories de motifs de conception ! Tu vas créer un système qui classe les motifs et explique leur objectif, en organisant ton code sur plusieurs fichiers.

Tu vas créer trois fichiers :

Pattern.java : crée une interface appelée Pattern qui définit le contrat pour tous les motifs de conception. Ton interface doit déclarer deux méthodes : String getCategory(), qui renvoie la catégorie du motif (Creational, Structural ou Behavioral), et String getPurpose(), qui renvoie une description de ce que fait cette catégorie de motifs.
PatternInfo.java : crée trois classes qui implémentent ton interface Pattern, chacune représentant une catégorie de motifs de conception :
CreationalPattern - doit renvoyer "Creational" pour la catégorie et "How objects are created" pour l'objectif.

StructuralPattern - doit renvoyer "Structural" pour la catégorie et "How objects are composed" pour l'objectif.

BehavioralPattern - doit renvoyer "Behavioral" pour la catégorie et "How objects communicate" pour l'objectif.
Main.java : rassemble ton classificateur de motifs ! Tu recevras une entrée : le nom d'un motif (String), qui sera l'un des suivants : "Singleton", "Factory", "Adapter", "Decorator", "Observer" ou "Strategy".
En fonction de l'entrée, crée l'objet motif approprié :
- "Singleton" et "Factory" sont des motifs Creational
- "Adapter" et "Decorator" sont des motifs Structural
- "Observer" et "Strategy" sont des motifs Behavioral
Stocke ton objet motif dans une variable de type Pattern (l'interface), afin de démontrer le principe de la programmation envers une interface. Affiche ensuite les trois lignes suivantes :

Pattern: [input pattern name]

Category: [category from getCategory()]

Purpose: [purpose from getPurpose()]

Tu recevras une entrée : le nom d'un motif de conception (String).

Ce défi renforce l'idée clé de la leçon : les motifs de conception sont organisés en catégories selon le problème qu'ils résolvent. En utilisant une interface, tu pratiques également le principe « programmer envers une interface, et non une implémentation » — un concept essentiel qui rend les motifs de conception si puissants !

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String patternName = scanner.nextLine();
        
        // TODO: Déclarez une variable de type Pattern (l'interface)
        Pattern pattern = null;
        
        // TODO: En fonction de patternName, créez l'objet pattern approprié :
        // - "Singleton" et "Factory" sont des patterns Créationnels
        // - "Adapter" et "Decorator" sont des patterns Structurels
        // - "Observer" et "Strategy" sont des patterns Comportementaux
        
        // TODO: Affichez la sortie au format suivant :
        // Pattern: [nom du pattern en entrée]
        // Category: [catégorie de getCategory()]
        // Purpose: [objectif de getPurpose()]
    }
}