Comment utiliser le modèle d'observateur en Java?

La réponse claire à cette question est la recommandation d'implémenter le modèle d'observateur à l'aide d'une interface d'observateur personnalisée. 1. Bien que Java offre observable et observateur, le premier est une classe et a été obsolète et manque de flexibilité; 2. La pratique recommandée moderne consiste à définir une interface d'observateur fonctionnel , qui maintient la liste des observateurs par sujet et avertit tous les observateurs lorsque l'État change; 3. Il peut être utilisé en combinaison avec les expressions de lambda pour améliorer la simplicité et la maintenabilité du code; 4. Pour les scénarios GUI ou Javabean, PropertyChangeListener peut être utilisé. Par conséquent, les nouveaux projets devraient adopter un schéma d'interface d'observateur personnalisé, qui est en sécurité, facile à tester et bien compatible avec les fonctionnalités Java modernes.

Le modèle d'observateur en Java est un modèle de conception comportemental où un objet (appelé le sujet ) maintient une liste de personnes à charge (appelées observateurs ) qui sont notifiées automatiquement lorsque le sujet change l'état. Java fournit une prise en charge intégrée pour ce modèle via la classe java.util.Observable et l'interface java.util.Observer - bien qu'elles soient obsolètes depuis Java 9 , les comprendre aide à saisir le concept. Nous couvrirons à la fois l'approche héritée et la manière moderne et recommandée en utilisant des interfaces personnalisées ou une programmation fonctionnelle.

1. Utilisation de l'héritage Observable et Observer (non recommandé)

Même s'il est obsolète, voici comment cela fonctionnait auparavant:

 import java.util.observable;
import java.util.observer;

// Sujet (source de données)
La série de la classe s'étend observable {
    température flottante privée;

    métier de vide public (température du flotteur) {
        this.temperature = température;
        setChanged (); // doit appeler cela avant de notifier
        notifyObservers (température); // Envoyez la mise à jour
    }

    public float getTemperature () {
        température de retour;
    }
}

// Observer (abonné)
L'affichage de classe implémente l'observateur {
    nom de chaîne privé;

    affichage public (nom de chaîne) {
        this.name = name;
    }

    @Outrepasser
    Mise à jour du public (observable observable, objet arg) {
        if (instance observable de Weatherstation) {
            float temp = (float) arg;
            System.out.println (nom "Affichage: température mise à jour vers" temp "° C");
        }
    }
}

// utilisation
classe publique ObserverDemo {
    public static void main (String [] args) {
        Station de Weatherstation = New Weatherstation ();
        Affichage phonedisplay = nouveau affichage ("téléphone");
        Affichage tvDisplay = nouveau affichage ("TV");

        Station.AddObserver (PhoneDisplay);
        Station.AddObserver (TVDisplay);

        Station.SetTemperature (25,5f); // déclenche des notifications
        Station.SetTemperature (30.0f);
    }
}

⚠️ Remarque : Observable est une classe, pas une interface, vous ne pouvez donc pas l'utiliser avec un héritage multiple. C'est une des raisons pour lesquelles elle a été obsolète.

2. Approche moderne: modèle d'observateur personnalisé (recommandé)

Au lieu de s'appuyer sur des classes intégrées, définissez votre propre contrat d'observateur sujet à l'aide d'interfaces.

Étape 1: Définissez l'interface de l'observateur

 @FunctionalInterface
Observer d&#39;interface publique <T> {
    VOID UPDATE (T DONNÉES);
}

Étape 2: implémenter le sujet

 import java.util.arraylist;
Importer java.util.list;

classe publique Weatherstation {
    Liste privée <Observer <fload >> Observateurs = new ArrayList <> ();
    température flottante privée;

    public void addObserver (Observer <fload> Observer) {
        observateurs.add (observateur);
    }

    public void retireobserver (Observer <fload> Observer) {
        observateurs.remove (observateur);
    }

    métier de vide public (température du flotteur) {
        this.temperature = température;
        notifyObservers ();
    }

    private void notifyObservers () {
        pour (observateur <fload> observateur: observateurs) {
            Observer.Update (température);
        }
    }

    public float getTemperature () {
        température de retour;
    }
}

Étape 3: Utilisez-le avec des expressions de lambda

 classe publique ModernObserverDemo {
    public static void main (String [] args) {
        Station de Weatherstation = New Weatherstation ();

        // ajouter des observateurs à l'aide de lambdas
        Station.AddObserver (temp -> System.out.println ("Affichage du téléphone:" Temp "° C"));
        Station.AddObserver (temp -> System.out.println ("Affichage TV:" Temp "° C"));
        Station.AddObserver (temp -> {
            if (temp> 28) {
                System.out.println ("Alerte: haute température détectée!");
            }
        });

        // Changer l'état
        Station.SetTemperature (25.0f);
        Station.SetTemperature (29,5F);
    }
}

Sortir:

 Affichage du téléphone: 25,0 ° C
Affichage du téléviseur: 25,0 ° C
Affichage du téléphone: 29,5 ° C
Affichage du téléviseur: 29,5 ° C
Alerte: température élevée détectée!

Cette approche est:

• Plus flexible (utilise des interfaces, pas des classes de béton)
• Prend en charge les expressions de lambda
• Plus facile à tester et à étendre
• Non lié aux API obsolètes

3. Alternative: Utilisation PropertyChangeListener (pour GUI ou des objets en forme de haricot)

Java a également java.beans.PropertyChangeListener , qui n'est toujours pas obsolète et utile dans certains contextes (comme Swing ou Pojos avec des événements de changement de propriété).

 Importer java.beans.propertychangeListener;
Importer java.beans.propertyChangeSupport;

classe publique SmartThermostat {
    Private Final PropertyChangeSupport Support = new PropertyChangeSupport (this);
    INT privé TargetTemp;

    public void addPropertyChangeListener (PropertyChangeListener Écouteur) {
        support.addpropertychangeListener (auditeur);
    }

    public void SettargetTemp (int NewTemp) {
        int old = this.targetTemp;
        this.targetTemp = newTemp;
        Support.FireProperTyChange ("TargetTemp", Old, NewTemp);
    }
}

Utile lorsque vous souhaitez suivre la propriété a changé et ses valeurs anciennes / nouvelles.

Résumé

Pour de nouveaux projets, optez pour une interface d'observateur personnalisée - c'est simple, en sécurité de type et fonctionne bien avec les lambdas.

Fondamentalement, juste:

• Définir une interface Observer<t></t>
• Maintenir une liste d'auditeurs dans votre sujet
• Les informer sur le changement d'état

C'est le modèle d'observateur bien fait dans Java moderne.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!