Aller au contenu

Patrons de Conception - Série N°6

Patrons de conception en informatique Ce document traite des patrons de conception en informatique, en se concentrant sur des exercices pratiques qui aident à comprendre des concepts tels que le singleton, la notation polonaise et le patron Observer. Les étudiants trouveront des exemples concrets et des questions qui les guideront dans l'application de ces concepts.

D'après le document Patrons de Conception - Série N°6

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

Document source

Patrons de Conception - Série N°6

Computer Science · École Nationale des Sciences de l'Informatique (ENSI) · PDF · 2 pages · 2017

Afficher l'aperçu du document

Consulter le document original →

Patrons de conception en informatique

Ce document traite des patrons de conception en informatique, en se concentrant sur des exercices pratiques qui aident à comprendre des concepts tels que le singleton, la notation polonaise et le patron Observer. Les étudiants trouveront des exemples concrets et des questions qui les guideront dans l'application de ces concepts.

Exercice 1 : Amélioration de la classe BouilleurChocolat

Dans cet exercice, nous examinons la classe contrôleur du bouilleur industriel de Bonchoco, SA. Cette classe est responsable de la gestion d'un mélange de chocolat et de lait, en veillant à éviter des erreurs telles que le débordement ou le fonctionnement à vide. Pour améliorer cette classe, nous allons la transformer en singleton.

Le patron de conception singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance. Cela est particulièrement utile dans le cas du bouilleur, car il ne doit y avoir qu'un seul bouilleur actif à un moment donné.

class BouilleurChocolat {
    private static BouilleurChocolat instance;

    private BouilleurChocolat() {
        // Constructeur privé
    }

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

    // Méthodes pour gérer le mélange
}

En appliquant ce patron, nous garantissons que toutes les opérations sur le bouilleur sont centralisées et que les erreurs potentielles sont réduites.

Exercice 2 : Représentation des expressions arithmétiques

Une expression arithmétique peut être représentée de manière arborescente. Par exemple, l'expression (2+3)*4 peut être représentée comme suit :

*(+(2,3), 4)

Cette notation, appelée notation polonaise, permet d'éviter l'utilisation de parenthèses, car l'ordre des opérations est clair. Pour représenter ces expressions, nous allons utiliser le patron composite.

Le patron composite permet de traiter des objets individuels et des compositions d'objets de manière uniforme. Dans notre cas, nous allons créer une classe abstraite pour les termes, qui peut être soit une valeur constante, soit une expression.

abstract class Terme {
    abstract int calculerValeur();
}

class Constante extends Terme {
    private int valeur;

    public Constante(int valeur) {
        this.valeur = valeur;
    }

    @Override
    int calculerValeur() {
        return valeur;
    }
}

class ExpressionBinaire extends Terme {
    private Terme gauche;
    private Terme droite;
    private String operateur;

    public ExpressionBinaire(Terme gauche, Terme droite, String operateur) {
        this.gauche = gauche;
        this.droite = droite;
        this.operateur = operateur;
    }

    @Override
    int calculerValeur() {
        switch (operateur) {
            case "+":
                return gauche.calculerValeur() + droite.calculerValeur();
            case "*":
                return gauche.calculerValeur() * droite.calculerValeur();
            default:
                throw new UnsupportedOperationException("Opérateur non supporté");
        }
    }
}

Avec cette structure, nous pouvons facilement construire des expressions complexes tout en maintenant une interface simple pour le calcul de leur valeur.

Exercice 3 : Utilisation du patron Observer

Dans cet exercice, nous allons définir une classe représentant un calculateur qui effectue des calculs. La classe Synchronisateur régule les demandes de calcul et distribue les tâches aux différents calculateurs. Pour informer les utilisateurs de l'état d'avancement des calculs, nous allons implémenter une barre de progression.

Le patron de conception Observer permet à un objet de notifier d'autres objets lorsque son état change. Dans notre cas, la barre de progression doit être informée des mises à jour de l'état du calcul.

class Calculateur {
    private Synchronisateur sync;
    private List<Observer> observers = new ArrayList<>();

    public Calculateur(Synchronisateur sync) {
        this.sync = sync;
    }

    public void ajouterObserver(Observer observer) {
        observers.add(observer);
    }

    public void calculer() {
        // Logique de calcul
        notifyObservers();
    }

    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

interface Observer {
    void update();
}

class BarreDeProgression implements Observer {
    @Override
    public void update() {
        // Mettre à jour l'affichage de la barre de progression
    }
}

En appliquant le patron Observer, nous assurons que la barre de progression est toujours à jour avec l'état du calcul, offrant ainsi une meilleure expérience utilisateur.

Points clés à retenir

Voici les principaux points à retenir concernant les exercices sur les patrons de conception :

  • Le patron singleton garantit qu'une classe n'a qu'une seule instance.
  • La notation polonaise permet de représenter des expressions arithmétiques sans ambiguïté.
  • Le patron composite facilite la gestion d'objets individuels et de compositions d'objets.
  • Le patron Observer permet de notifier les changements d'état entre objets.

Questions fréquentes

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

Le patron de conception singleton assure qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance. Cela est utile pour des classes qui doivent être uniques, comme un gestionnaire de configuration.

Comment fonctionne la notation polonaise ?

La notation polonaise représente les expressions arithmétiques en plaçant l'opérateur avant ses opérandes, ce qui élimine le besoin de parenthèses. Par exemple, l'expression (2+3)*4 devient *(+(2,3), 4).

Qu'est-ce que le patron Observer ?

Le patron Observer permet à un objet (le sujet) de notifier d'autres objets (les observateurs) lorsque son état change. Cela est particulièrement utile dans les interfaces utilisateur pour mettre à jour les éléments d'affichage en fonction des changements de données.

Comment appliquer le patron composite ?

Le patron composite permet de traiter des objets individuels et des compositions d'objets de manière uniforme. Il est utilisé pour représenter des structures d'arbres, comme les expressions arithmétiques, où chaque nœud peut être soit une valeur, soit une opération.

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