[Java] Realizzare il pattern Observer

[e-commerce84]

Ciao,
stò studiando i pattern applicati a Java.
Attualmente mi stò vedendo il pattern Observer che viene usato praticamente in tutte le GUI.

Mi dite se ho capito bene?

Allora io ho sostanzialmente ho due tipi di oggetti:
1) Un SOGGETTO (o publisher) che di fatto rappresenta i miei dati.
2) Vari OBSERVER (o listener) che di fatto rappresentano una specifica vista dei mie dati (mantenendosi sincronicatti con il soggetto)

La logica che ci stà dietro è la seguente: Il soggetto rappresenta i miei dati e si manterrà una lista di tutti gli osservatori che lo stanno osservando (che vogliono quindi rappresentare i dati e le loro modifiche quando esse avvengono).
Quando i dati subiscono una modifica il soggetto invia una notifica a tutti i suoi osservatori che si auto aggiorneranno e forniranno una nuova vista dei dati.

(Es: ho un foglio di excell. I dati nel sistema sono il soggetto. La rappresentazione è l'osservatore. Tramite l'osservatore modifico il valore di una cella. Il soggetto ricalcola con una formula i valori di tutte le altre celle del foglio di calcolo che vengono così modificate, così avverte l'osservatore della modifica, esso si aggiorna e visualizza i nuovi valori di tutte le celle)

Esempio in codice:

Observer la dichiaro come un'interfaccia, poi ovviamente devo implementarla ed in base al tipo concreto dell'Observer il metodo update aggiornerà la vista o farà qualcosa in uno specifico modo:

/* Interfaccia che rappresenta i vari oggetti osservatori che a loro volta
 * rappresentano una specifica rappresentazione dei dati
 */

public interface Observer {
  public void update(Subject subject) ;	// Metodo astratto che modifica i dati
}

Subject:

import java.util.Vector;

/* Classe che rappresenta i dati su cui si basano le viste */

public class Subject{
	
  /* Crea un vettore che conterrà la lista di tutti gli osservatori che lo
   * osservano */
  protected Vector observers = new Vector();

  public void addObserver(Observer o){  // Aggiunge un oggetto Observer al vettore  
    observers.addElement(o);
  }

  public void removeObserver(Observer o){ // Rimuove un osservatore dal vettore
    observers.removeElement(o);
  }
  
  /* Notifica agli oggetti osservatori che c'è stata una modifica dei dati
   * rappresentati da Subject */
  public void notify(){			
    Enumeration e = observers.getElements();

    while (e.hasMoreElements()) {
      /* Invoca il metodo update su tutti gli osservatori per modificare le viste */
      ((Observer)e.nextElement()).update(this);
    }
  }
}

mmm...il mio ragionamento è corretto?

Grazie

[nuovoUtente86]

Il pattern observer, realizza il relazionamento 1-molti tra il subject ed n ascoltatori, in modo che ogni variazione di stato dell' observable sia ascoltata in broadcast dagli observer. Ovviamente tale logica trova un' applicazione nello slegare i dati applicativi dalla loro rappresentazione. Ad esempio 2 observer potrebbero consumare i dati: uno per mostrarli a video e l' altro per loggarli su file o mandarli in rete.

[e-commerce84]

Ti ringrazio,
mmm...ora però ho un altro problemino con un altro esempio più concreto che non mi gira (purtroppo sono tremendamente arrugginito con Java e diciamo che non ci ho mai fatto nulla di che)

L'esempio è questo:

INTERFRACCIA Observer:

/* Rappresenta un generico oggetto osservatore  */

public interface Observer {
       void update();
}

CLASSE ConcreteObserver:

/* Implementa l'interfaccia Observer e rappresenta uno specifico tipo di oggetto
 * osservatore */

public class ConcreteObserver implements Observer{
       
	// Specifica quale suggetto stà osservando l'oggetto osservatore
	private ConcreteSubject subject;	
       
	/* COSTRUTTORE: crea uno specifico osservatore e gli passa il riferimento
	 * all'oggetto soggetto che si intende osservare */
	public ConcreteObserver(ConcreteSubject aSubject){
		subject = aSubject;
        subject.add(this);
    }
	
	/* Metodo pubblico che viene invocato dal soggetto per modificare lo stato
	 * dell'osservatore quando nel soggetto avviene una modifica */
    public void update(){
    	System.out.println("Io sono l'observer " + this + 
    			" ed il nuovo stato del mio subject e' " + subject.getState());
    }
    
}

INTERFACCIA Subject:

/* Interfaccia che rappresenta un generico soggetto che rappresenta i dati */

public interface Subject {
       void add(Observer anObserver);	// Aggiunge un elemento lista degli osservatori
       void remove(Observer anObserver);	// Rimuove un elemento dalla lista degli osservatori
       void notify(); // Notifica a tutti gli oggetti osservatori una modifica sui dati
}

CLASSE ConcreteSubject (che contiene anche il metodo main() ):

import java.util.LinkedList;

/* Rappresenta un tipo concreto di Subject ed implementa l'interfaccia Subject */

public class ConcreteSubject implements Subject {
       
	private int state;	// Rappresenta lo stato del soggetto (il dato rappresentato)
       
    
    private LinkedList observers;	// Rappresenta la lista degli osservatori
       
    /* Creatore: Crea un oggetto di tipo ConcreteSubject e riceve come input il
     * dato che si intende rappresentare (lo stato iniziale del soggetto) */
    public ConcreteSubject(int initialState){
       state = initialState;				// Setta lo stato
       }
    
    /* Metodo pubblico che restituisce al chiamante il valore dello stato del 
     * soggetto */
    public int getState(){
        return state;
    }
    
    /* Metodo pubblico che permette la modifica dello stato del soggetto */
    public void setState(int aState) {
        state = aState;
    }
    
    /* Metodo pubblico che permette di inserire un oggetto osservatore nella lista
     * di ogetti che osservano il soggetto */
    public void add(Observer anObserver) {
        observers.add(anObserver);
    }
    
    /* Metodo pubblico che permette di rimuovede un oggetto osservatore dalla lista
     * di ogetti che osservano il soggetto */
    public void remove(Observer anObserver) {
        observers.remove(anObserver);
    }
    
    /* Metodo pubblico che notifica agli oggetti osservatori eventuali modifiche
     * dei dati nel soggetto */
    public void notify(){
        Iterator iter=observers.iterator();	// Crea un iteratore su observer
        Observer obs;			// Contiene il riferimento ad un generico Observer
        while(iter.hasNext()){	// Aggiorna tutti gli observer
                obs=(Observer)iter.next();
                obs.update();
        }
        
    /* Metodo main() che avvia l'applicazione: prende in input un array di
     * argomenti */
    public static void main(String[] args){
        
    	// Crea un array di osservatori di 3 locazioni 
    	int concreteObservers[3];
    	int initialState = 10;		// Setta a 10 la variabile initialState
        
    	// Crea un nuovo soggetto concreto passandogli uno stato iniziale
    	ConcreteSubject mySubject = new ConcreteSubject(initialState);
    	// Stampa lo stato del soggetto appena creato
        System.out.println("E' stato creato un subject con stato " +
        mySubject.getState());
        
        /* Crea tre oggetti osservatori e mette il loro riferimento nell'array
         * concreteObservers */
        for (int i = 0; i < 3; i++){
        	concreteObservers[i] = new ConcreteObserver(mySubject);
        }
        
        System.out.println("..."); 
        mySubject.setState(17);		// Cambia il valore dello stato del soggetto
        mySubject.notify(); // Notifica il cambiamento di stato agli oggetti osservatori
        System.out.println("...");
        mySubject.setState(06);		// Cambia il valore dello stato del soggetto
        mySubject.notify();  // Notifica il cambiamento di stato agli oggetti osservatori
    }

}

Praticamente eclipse mi segnala una sorta di warning: "Cannot override the final method from Object" alla linea:
void notify(); di Subject (forse c'entra con quella cosa che mi dicevi prima?)

E poi mi dà una serie di errori dentro la classe ConcreteSubject.

Gli errori che mi dà sono:


Cannot override the final method from Object ConcreteSubject.java /Observer3/src line 43 Java Problem
Iterator cannot be resolved to a type ConcreteSubject.java /Observer3/src line 44 Java Problem
Syntax error on token "3", delete this token ConcreteSubject.java /Observer3/src line 56 Java Problem
Syntax error, insert "}" to complete Block ConcreteSubject.java /Observer3/src line 48 Java Problem
Type mismatch: cannot convert from ConcreteObserver to int ConcreteSubject.java /Observer3/src line 68 Java Problem
LinkedList is a raw type. References to generic type LinkedList<E> should be parameterized ConcreteSubject.java /Observer3/src line 10 Java Problem
Type safety: The method add(Object) belongs to the raw type LinkedList. References to generic type LinkedList<E> should be parameterized ConcreteSubject.java /Observer3/src line 32 Java Problem

Non capisco...l'esempio è prefetto...preso dal sito di un corso universitario...booo

[Darecon]

Chiamalo notifica, notify e' un metodo di object che viene ereditato, e tu cosi' tenti di sovrascriverlo..

[e-commerce84]

Originariamente inviato da Darecon

Chiamalo notifica, notify e' un metodo di object che viene ereditato, e tu cosi' tenti di sovrascriverlo..

Vero :-)