Aller au contenu

TD6: Patrons de conception

Patrons de conception en programmation Les patrons de conception sont des solutions réutilisables à des problèmes courants en programmation. Cet article présente plusieurs patrons de conception, notamment le singleton et l'observer, ainsi que des exemples pratiques et des diagrammes de classes. Les étudiants apprendront comment appliquer ces concepts dans leurs projets de programmation.

D'après le document TD6: Patrons de conception

Cet article a été rédigé automatiquement à partir du document source, puis vérifié avant publication.

Document source

TD6: Patrons de conception

Software Engineering, specifically Design Patterns · PDF · 7 pages

Afficher l'aperçu du document

Consulter le document original →

Patrons de conception en programmation

Les patrons de conception sont des solutions réutilisables à des problèmes courants en programmation. Cet article présente plusieurs patrons de conception, notamment le singleton et l'observer, ainsi que des exemples pratiques et des diagrammes de classes. Les étudiants apprendront comment appliquer ces concepts dans leurs projets de programmation.

Le patron de conception Singleton

Le patron de conception singleton est utilisé pour garantir qu'une classe n'ait qu'une seule instance et fournisse un point d'accès global à cette instance. Dans le contexte de la classe BouilleurChocolat, il est essentiel d'éviter la création de plusieurs instances qui pourraient causer des catastrophes, comme le déversement de mélange non bouilli.

Pour transformer la classe BouilleurChocolat en singleton, il faut suivre ces étapes :

  1. Déclarer un attribut statique pour stocker l'instance unique.
  2. Rendre le constructeur privé pour empêcher la création d'instances externes.
  3. Créer une méthode statique qui retourne l'instance unique, en la créant si nécessaire.

Voici un exemple de code pour le patron singleton :

class BouilleurChocolat {
    private static BouilleurChocolat instance;

    private BouilleurChocolat() {
        // Constructeur privé
    }

    public static BouilleurChocolat getInstance() {
        if (instance == null) {
            instance = new BouilleurChocolat();
        }
        return instance;
    }
}

Le patron de conception Composite

Le patron de conception composite permet de traiter des objets individuels et des compositions d'objets de manière uniforme. Dans le cas des expressions arithmétiques, ce patron est utile pour représenter des opérations complexes.

Pour représenter une expression comme (2+3)*4, on peut utiliser un arbre où chaque nœud représente un opérateur et les feuilles représentent les opérandes. Les classes pourraient être définies comme suit :

  • Expression : classe abstraite avec une méthode calculerValeur().
  • ExpressionBinaire : hérite de Expression et représente les opérations binaires.
  • ExpressionUnaire : hérite de Expression et représente les opérations unaires.
  • Constante : classe représentant une valeur constante.
  • Variable : classe représentant une variable avec un nom.

Voici un exemple de diagramme de classes pour les expressions arithmétiques :

Diagramme de classes pour les expressions arithmétiques
<img src="diagramme_expressions.png" alt="Diagramme de classes pour les expressions arithmétiques">

Le patron de conception Observer

Le patron de conception observer est utilisé pour établir une relation entre un sujet et ses observateurs. Dans notre cas, un Calculateur notifie une BarreProgression de l'état d'avancement des calculs.

Pour appliquer ce patron, les étapes suivantes doivent être suivies :

  1. Créer une interface Observer avec une méthode pour recevoir les notifications.
  2. Créer une classe BarreProgression qui implémente l'interface Observer.
  3. Dans la classe Calculateur, ajouter une liste d'observateurs et des méthodes pour attacher, détacher et notifier les observateurs.

Voici un exemple de code pour le patron observer :

interface Observer {
    void mettreAJour(int pourcentage);
}

class BarreProgression implements Observer {
    public void mettreAJour(int pourcentage) {
        // Mettre à jour l'affichage de la barre de progression
    }
}

class Calculateur {
    private List<Observer> observateurs = new ArrayList<>();

    public void attacher(Observer obs) {
        observateurs.add(obs);
    }

    public void notifier() {
        for (Observer obs : observateurs) {
            obs.mettreAJour(pourcentage);
        }
    }
}

Points clés à retenir

Voici les points essentiels à retenir concernant les patrons de conception :

  • Le patron singleton garantit une seule instance d'une classe.
  • Le patron composite permet de traiter des objets individuels et des compositions de manière uniforme.
  • Le patron observer établit une relation entre un sujet et ses observateurs pour notifier les changements d'état.

Questions fréquentes

Qu'est-ce qu'un patron de conception ?

Un patron de conception est une solution réutilisable à un problème courant en programmation. Il fournit un cadre pour résoudre des problèmes de conception de manière efficace.

Comment fonctionne le patron singleton ?

Le patron singleton fonctionne en restreignant la création d'une classe à une seule instance. Cela se fait en rendant le constructeur privé et en fournissant une méthode statique pour accéder à l'instance unique.

Quels sont les avantages du patron observer ?

Le patron observer permet de créer des systèmes flexibles où les objets peuvent être informés des changements d'état sans être fortement couplés. Cela facilite la maintenance et l'évolution du code.

Comment représenter des expressions arithmétiques avec le patron composite ?

Avec le patron composite, on peut représenter des expressions arithmétiques comme des arbres, où chaque nœud est un opérateur et les feuilles sont des opérandes, permettant de traiter des expressions complexes de manière uniforme.

Partager

Commentaires

Aucun commentaire pour le moment. Posez la première question.

Les commentaires sont relus avant publication. Votre e-mail n'est jamais affiché.

← Toutes les révisions