Quand devons-nous utiliser observateur et Observable

en termes très simples (parce que les autres réponses vous réfèrent à tous les modèles officiels de toute façon, alors regardez-les pour plus de détails):

Si vous voulez avoir une classe qui est contrôlé par d'autres classes dans l'écosystème de votre programme, vous dire que vous voulez la classe pour être observable. I. e. il pourrait y avoir quelques changements dans son état dont vous souhaitez diffuser au reste du programme.

maintenant, pour faire ceci nous appeler une sorte de méthode. Nous ne voulons pas que la classe Observable soit étroitement liée aux classes qui sont intéressées à l'observer. Il se fiche de qui il est tant qu'il répond à certains critères. (Imaginez que c'est une station de radio, peu importe qui est à l'écoute tant qu'ils ont une radio FM accordée sur leur fréquence). Pour y parvenir que nous utilisons une interface, appelée l'Observateur.

par conséquent, la classe Observable aura une liste d'observateurs (c.-à-d. les instances mettant en œuvre les méthodes D'interface D'Observateur que vous pourriez avoir). Chaque fois qu'il veut diffuser quelque chose, il appelle juste la méthode sur tous les observateurs, l'un après l'autre.

la dernière chose à fermer le puzzle est de savoir comment la classe Observable sait qui est intéressé? La classe Observable doit donc offrir un mécanisme pour permettre aux observateurs de faire part de leur intérêt. Une méthode telle que addObserver(Observer o) intérieurement ajoute L'observateur à la liste des observateurs, de sorte que quand quelque chose d'important se produit, il boucle à travers la liste et appelle la méthode de notification respective de l'interface observateur de chaque instance dans la liste.

il se peut que, dans l'entrevue, ils ne vous aient pas posé de questions explicites au sujet du java.util.Observer et du java.util.Observable , mais au sujet du concept générique. Le concept est un modèle de conception, que Java se trouve à fournir le soutien pour directement hors de la boîte pour vous aider à le mettre en œuvre rapidement lorsque vous en avez besoin. Je vous suggère que vous comprenez le concept plutôt que sur les méthodes/classes (que vous pouvez consulter quand vous en avez besoin).

mise à JOUR

en réponse à votre commentaire, la classe réelle java.util.Observable offre les facilités suivantes:

1. maintien d'une liste d'instances java.util.Observer . De nouvelles instances intéressées à être notifiées peuvent être ajoutées par addObserver(Observer o) , et supprimé par deleteObserver(Observer o) .

2. maintien d'un état interne, en précisant si l'objet a changé depuis la dernière notification aux observateurs. Ceci est utile parce qu'il sépare la partie où vous dites que le Observable a changé, de la partie où vous notifiez les changements. (P. ex. C'est utile si vous avez plusieurs changements qui se produisent et vous voulez seulement notifier à la fin du processus plutôt qu'à chaque petit pas). Cela se fait par setChanged() . Donc vous l'appelez juste quand vous avez changé quelque chose au Observable et vous voulez que le reste du Observers pour éventuellement savoir à ce sujet.

3. notifiant à tous les observateurs que le Observable spécifique a changé d'état. Cela se fait par notifyObservers() . Ceci vérifie si l'objet a effectivement changé (c'est-à-dire qu'un appel à setChanged() a été fait) avant de procéder à la notification. Il y a 2 versions, une avec aucun argument et une avec un argument Object , dans le cas où vous voulez passer quelques informations supplémentaires avec la notification. À l'interne, ce qui se passe, c'est qu'il itère simplement à travers la liste des instances Observer et appelle la méthode update(Observable o, Object arg) pour chacune d'elles. Cela indique le Observer qui était L'objet Observable qui a changé( vous pourriez être en observant plus d'un), et le supplémentaire Object arg pour éventuellement porter un certain supplément de l'information (passé par notifyObservers() .

définition

motif observateur est utilisé lorsqu'il existe une ou plusieurs relations entre des objets, par exemple si un objet est modifié, ses objets dépendants doivent être notifiés automatiquement et les modifications correspondantes sont faites à tous les objets dépendants .

exemples

1. disons, votre adresse permanente est changée alors vous devez notifier l'administration des passeports et l'administration des cartes pan.Donc ici l'autorité des passeports et l'autorité des cartes pan sont des observateurs et vous êtes un sujet.

2. sur Facebook également,si vous vous abonnez à quelqu'un, puis chaque fois que de nouvelles mises à jour se produisent, vous serez avisé.

quand l'utiliser:

1. When one object changes its state,then all other dependents object must automatically change their state to maintain consistency
2. When subject doesn't know about number of observers it has.
3. When an object should be able to notify other objects without knowing who objects are.

Étape 1

créer L'objet de la classe.

sujet.java

  import java.util.ArrayList;
  import java.util.List;

  public class Subject {

  private List<Observer> observers 
        = new ArrayList<Observer>();
  private int state;

  public int getState() {
    return state;
  }

 public void setState(int state) {
   this.state = state;
   notifyAllObservers();
 }

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

  public void notifyAllObservers(){
    for (Observer observer : observers) {
     observer.update();
  }
}   

}

Étape 2

créer la classe Observateur.

Observer.java

public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

Étape 3

Créer béton observateur classes

BinaryObserver.java

public class BinaryObserver extends Observer{

  public BinaryObserver(Subject subject){
     this.subject = subject;
     this.subject.attach(this);
  }

  @Override
  public void update() {
     System.out.println( "Binary String: " 
     + Integer.toBinaryString( subject.getState() ) ); 
  }

}

OctalObserver.java

public class OctalObserver extends Observer{

   public OctalObserver(Subject subject){
     this.subject = subject;
    this.subject.attach(this);
 }

  @Override
  public void update() {
    System.out.println( "Octal String: " 
    + Integer.toOctalString( subject.getState() ) ); 
  }

}

HexaObserver.java

public class HexaObserver extends Observer{

  public HexaObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
 }

  @Override
  public void update() {
     System.out.println( "Hex String: " 
    + Integer.toHexString( subject.getState() ).toUpperCase() ); 
}

}

Étape 4

utiliser des objets sujet et observateur en béton.

Obserververpatterndemo.java

 public class ObserverPatternDemo {
    public static void main(String[] args) {
       Subject subject = new Subject();

       new HexaObserver(subject);
       new OctalObserver(subject);
       new BinaryObserver(subject);

       System.out.println("First state change: 15");    
       subject.setState(15);
       System.out.println("Second state change: 10");   
       subject.setState(10);
 }

}

Étape 5

Verify sortie.

Premier changement d'état: 15

Chaîne Hexadécimale: F

Chaîne Octale: 17

Chaîne Binaire: 1111

deuxième changement d'état: 10

Chaîne Hexadécimale: Un

Chaîne Octale: 12

Chaîne Binaire: 1010

, Ils font partie de la Observateur modèle de conception . Habituellement un ou plusieurs obervers s'informer des changements dans un observable . C'est une notification que "quelque chose" est arrivé, où vous en tant que programmeur pouvez définir ce que "quelque chose" signifie.

en utilisant ce modèle, vous découplez les deux entités l'une de l'autre - les observateurs deviennent branchables.

Observer A. K. un rappel est enregistré à Observable.

il est utilisé pour informer par exemple sur des événements qui se sont produits à un moment donné. Il est largement utilisé en Swing, Ajax, GWT pour des opérations de dispatching sur par exemple des événements UI (clics de bouton, textfields changed etc).

dans Swing vous trouvez des méthodes comme addXXXListener(Listener l), dans GWT vous avez des callbacks (Async).

Comme la liste des observateurs est dynamique, les observateurs peuvent Enregistrez et désinscrivez pendant l'exécution. C'est aussi une bonne façon de découpler observable des observateurs, car les interfaces sont utilisées.

si l'intervieweur demande de mettre en œuvre Observer design pattern sans utiliser les classes D'observateur et les interfaces, vous pouvez utiliser l'exemple simple suivant!

MyObserver en tant qu'observateur de l'interface

interface MyObserver {

    void update(MyObservable o, Object arg);
}

Myo-observable as Observable class

class MyObservable
{
    ArrayList<MyObserver> myObserverList = new ArrayList<MyObserver>();

    boolean changeFlag = false;

    public void notifyObservers(Object o)
    {
        if (hasChanged())
        {
            for(MyObserver mo : myObserverList) {
                mo.update(this, o);
            }
            clearChanged();
        }
    }


    public void addObserver(MyObserver o) {
        myObserverList.add(o);        
    }

    public void setChanged() {
        changeFlag = true;
    }

    public boolean hasChanged() {
        return changeFlag;
    }

    protected void clearChanged() {
        changeFlag = false;
    }

    // ...
}

votre exemple avec MyObserver et MyObservable!

class MessageBoard extends MyObservable {
  private String message;

  public String getMessage() {
    return message;
  }

  public void changeMessage(String message) {
    this.message = message;
    setChanged();
    notifyObservers(message);
  }

  public static void main(String[] args) {
    MessageBoard board = new MessageBoard();
    Student bob = new Student();
    Student joe = new Student();
    board.addObserver(bob);
    board.addObserver(joe);
    board.changeMessage("More Homework!");
  }
}

class Student implements MyObserver {
  public void update(MyObservable o, Object arg) {
    System.out.println("Message board changed: " + arg);
  }
}

"j'ai essayé de comprendre, exactement pourquoi nous avons besoin de l'Observateur et Observable"

comme il a déjà été dit dans les réponses précédentes, elles fournissent un moyen de s'abonner à un observateur pour recevoir des notifications automatiques d'un observable.

un exemple d'application où cela peut être utile est dans data binding , disons que vous avez une certaine interface utilisateur qui édite certaines données, et vous voulez que L'interface utilisateur réagisse lorsque les données sont mises à jour, vous pouvez rendre vos données observables, et souscrire vos composants D'interface utilisateur aux données

K. O.js est un MVVM javascript framework qui a un excellent tutoriel de démarrage, pour voir plus d'observables en action, je recommande vraiment de passer par le tutoriel. http://learn.knockoutjs.com /

j'ai aussi trouvé cet article dans Visual Studio 2008 start page ( le motif de L'observateur est la base du contrôleur de vue de modèle (MVC) développement ) http://visualstudiomagazine.com/articles/2013/08/14/the-observer-pattern-in-net.aspx

j'ai écrit une brève description du motif de l'observateur ici: http://www.devcodenote.com/2015/04/design-patterns-observer-pattern.html

Un extrait de la poste:

motif D'Observateur: il établit essentiellement une relation de un à plusieurs entre des objets et a un dessin vaguement couplé entre des objets interdépendants.

définition de manuel: le modèle D'Observateur définit un dépendance un à plusieurs entre les objets de sorte que lorsqu'un objet change d'état, toutes ses dépendances sont notifiées et mises à jour automatiquement.

considérez par exemple un service de notification d'alimentation. Les modèles d'Abonnement sont les meilleurs pour comprendre le modèle de l'observateur.

motif observateur est utilisé lorsqu'il existe une relation un à plusieurs entre des objets, par exemple si un objet est modifié, ses objets dépendants doivent être notifiés automatiquement.

depuis Java9, les deux interfaces sont obsolètes, ce qui signifie que vous ne devez plus les utiliser. Voir L'observateur est déprécié en Java 9. Que devrions-nous utiliser à la place?

cependant, vous pourriez toujours obtenir des questions d'entrevue à leur sujet...