[Java] eventi...

[ally]

...come da titolo...avrei la necessità di creare due o piu' classi in grado di ricevere e segnalare cambi di stato o variazioni di valori su alcune variabili...è possibile una soluzione biunivoca o gli eventi sono solo monodirezionali?...

...grazie...

[andbin]

Originariamente inviato da ally

avrei la necessità di creare due o piu' classi in grado di ricevere e segnalare cambi di stato o variazioni di valori su alcune variabili

Se per "variabili" intendi proprio una classica variabile es. int a; di per sé non puoi ottenere delle "notifiche" al cambiamento del valore. Al massimo puoi fare in modo che l'assegnazione di un valore alla variabile sia fattibile solo attraverso un apposito metodo "setter" e in tal caso puoi certamente sapere quando avviene il set.
Se non è questo che chiedi, spiega meglio.

Originariamente inviato da ally

è possibile una soluzione biunivoca o gli eventi sono solo monodirezionali?...

Ma di "eventi" parli in generale o in modo particolare dei "listener" usati principalmente nelle interfacce grafiche?? Anche qui non è chiaro, scusa se lo dico.

In ogni caso, la notifica di un "evento" (e qui parlo in generale) è gestibile tipicamente attraverso l'uso delle interfacce. Poi si può stabilire se la notifica debba essere fatta ad 1 solo oggetto o a più oggetti (come nel caso dei listeners) che implementano una determinata interfaccia.

[ally]

...stavo prendendo spunto da un esempio postato proprio qui qualche mese fa...

public class BongoEvent extends EventObject {
	
    public BongoEvent(Object source) { 
    	
    	super(source); 
    	
    	System.out.println("wow");
    
    }
}

public interface BongoEventListener extends EventListener {
	
	
    void bongoEventPerformed(BongoEvent e);
    
}

public class Evento {

    private ArrayList listeners = new ArrayList();

    private void fireBongoEvent() {
        BongoEvent event = new BongoEvent(this);
       
        for(int i = 0; i < listeners.size(); i++) {
            ((BongoEventListener)listeners.get(i)).bongoEventPerformed(event);
        }
    }

   public static void main(String args[]){
    	
    	Evento evento = new Evento();
    	try{
    	Thread.sleep(1000);
    	}catch(Exception e){}
    	evento.fireBongoEvent();
    	
    }
}

...e fin qui ci sono...il mio problema è rendere la cosa possibilmente biunivoca e che sottenda un numero maggiore di classi che invochino l'evento...

...grazie...ciao...

[andbin]

Originariamente inviato da ally

...stavo prendendo spunto da un esempio postato proprio qui qualche mese fa...

Sì, è proprio il concetto dei listeners (non vedo add/remove dei listener ma è chiaro).

C'è una interfaccia che definisce il "contratto", c'è un oggetto che definisce l'evento e un oggetto che fa da "sorgente" e che ha una lista degli ascoltatori da notificare.

Questo è appunto lo stile della gestione degli eventi usati nelle interfacce grafiche. Ma nulla di vieta di fare in altro modo, sempre con le interfacce.
Cioè, per capirci, questa è solo la forma specifica usata nelle interfacce grafiche.

Originariamente inviato da ally

il mio problema è rendere la cosa possibilmente biunivoca e che sottenda un numero maggiore di classi che invochino l'evento...

Cioè vuoi che oggetti diversi possano fare il "fire" dell'evento? Se l'oggetto ha appunto un metodo per fare il fire dell'evento, non vedo il problema, chiamalo da dove vuoi.

[ally]

Originariamente inviato da andbin

Cioè vuoi che oggetti diversi possano fare il "fire" dell'evento? Se l'oggetto ha appunto un metodo per fare il fire dell'evento, non vedo il problema, chiamalo da dove vuoi.

...il mio problema è che diversi eventi lanciati da diverse classi arrivino ad una sola classe...l'ipotetica BongoEvent dovrebbe percio' essere in grado di ricevere diverse tipologie di event...

...sto forse sbagliando io?...è possibile assegnare informazioni all'evento generato?...

...ciao...

[lovaz]

Aggiungi a BongoEvent un metodo del tipo

public void notifyMe(Object o) {...}

che chiamerai dalle varie classi che devono comunicargli qualcosa.

[andbin]

Originariamente inviato da ally

il mio problema è che diversi eventi lanciati da diverse classi arrivino ad una sola classe...l'ipotetica BongoEvent dovrebbe percio' essere in grado di ricevere diverse tipologie di event...

Qui c'è da capire quali/quanti tipi di eventi. Intendo dire, per fare un paragone con gli eventi AWT/Swing: devi avere una interfaccia che definisce diversi metodi (es. come mouseClicked, mouseReleased ecc...) o il metodo è 1 solo ma può ricevere oggetti di tipo (un sottotipo, chiaramente) diverso?

Poi dove vuoi memorizzare il reference all'oggetto che riceve le notifiche? Puoi memorizzarlo in ogni classe che fa da sorgente (così tecnicamente sarebbe possibile avere destinatari diversi ... ma non ti serve) o memorizzarlo in un oggetto ben specifico?

[Guille]

Originariamente inviato da ally

...il mio problema è che diversi eventi lanciati da diverse classi arrivino ad una sola classe...l'ipotetica BongoEvent dovrebbe percio' essere in grado di ricevere diverse tipologie di event...

...sto forse sbagliando io?...è possibile assegnare informazioni all'evento generato?...

...ciao...

Citando andbin

C'è una interfaccia che definisce il "contratto", c'è un oggetto che definisce l'evento e un oggetto che fa da "sorgente" e che ha una lista degli ascoltatori da notificare.

devi prima chiarirti quali sono questi eventi e quali informazioni devono portarsi dietro dopo di che nessuno ti impedisce di definire un'interfaccia ed uno o piu eventi in funzione delle tue esigenze.

Ad esempio:

public class MyEventoA extends EventObject {
    int a;
    public MyEventoB(Object source, int a) { 
    	super(source); 
	this.a = a;
    }
}

public class MyEventoB extends EventObject {
    String msg;
    public MyEventoB(Object source, String msg) { 
    	super(source); 
	this.msg;
    }
}

// .. quanti ne vuoi

public interface MyMultyEventListener {
	public void performedEvantoA(MyEventoA e);
	public void performedEvantoB(MyEventoB e);
        ..... // quanti ne vuoi
}

La classe che deve ricevere i vari eventi implementa l'interfaccia MyMultyEventListener mentre ciascuna delle classi che lancia il singolo evento implementa un metodo fireMyEvento<X>().

[ally]

Originariamente inviato da lovaz

Aggiungi a BongoEvent un metodo del tipo

public void notifyMe(Object o) {...}

che chiamerai dalle varie classi che devono comunicargli qualcosa.

...un contenitore da riempire prima di scatenare l'evento?...non rischio problemi di concorrenza?...

Originariamente inviato da andbin

Qui c'è da capire quali/quanti tipi di eventi. Intendo dire, per fare un paragone con gli eventi AWT/Swing: devi avere una interfaccia che definisce diversi metodi (es. come mouseClicked, mouseReleased ecc...) o il metodo è 1 solo ma può ricevere oggetti di tipo (un sottotipo, chiaramente) diverso?

Poi dove vuoi memorizzare il reference all'oggetto che riceve le notifiche? Puoi memorizzarlo in ogni classe che fa da sorgente (così tecnicamente sarebbe possibile avere destinatari diversi ... ma non ti serve) o memorizzarlo in un oggetto ben specifico?

...non è possibile creare degli eventi custom?...il problema sarebbe notificare il funzionamento di un player esterno ad una classe madre...a questo pero' si agganciano altre classi che periodicamente notificano richieste di diversa natura...dall'alzare/abbassare il volume...al cambiare il file che il player sta visualizzando...e via dicendo...quindi avrei la necessitò che la classe madre riceva le diverse notifiche da tutte queste sorgenti e si comporti di conseguenza...nessuna interfaccia grafica...nessun evento legato a mouse o tastiera...

...grazie...ciao...

[lovaz]

Originariamente inviato da ally

...un contenitore da riempire prima di scatenare l'evento?...non rischio problemi di concorrenza?...

Quali problemi? Un oggetto "notificante" crea un contenitore, e lo passa al metodo
della classe "notificata" (in effetti mi sono spiegato male, questo metodo non
andrebbe in una classe "evento", ma proprio nella classe che deve ricevere l'evento).

[ally]

Originariamente inviato da Guille

Citando andbin

devi prima chiarirti quali sono questi eventi e quali informazioni devono portarsi dietro dopo di che nessuno ti impedisce di definire un'interfaccia ed uno o piu eventi in funzione delle tue esigenze.

Ad esempio:

public class MyEventoA extends EventObject {
    int a;
    public MyEventoB(Object source, int a) { 
    	super(source); 
	this.a = a;
    }
}

public class MyEventoB extends EventObject {
    String msg;
    public MyEventoB(Object source, String msg) { 
    	super(source); 
	this.msg;
    }
}

// .. quanti ne vuoi

public interface MyMultyEventListener {
	public void performedEvantoA(MyEventoA e);
	public void performedEvantoB(MyEventoB e);
        ..... // quanti ne vuoi
}

La classe che deve ricevere i vari eventi implementa l'interfaccia MyMultyEventListener mentre ciascuna delle classi che lancia il singolo evento implementa un metodo fireMyEvento<X>().

...mh...non mi è chiara l'idea...non sono le classi MyEventoA e MyEventoB che ricevono l'evento?...

...ciao...

[Guille]

Originariamente inviato da ally

...un contenitore da riempire prima di scatenare l'evento?...non rischio problemi di concorrenza?...



...non è possibile creare degli eventi custom?...il problema sarebbe notificare il funzionamento di un player esterno ad una classe madre...a questo pero' si agganciano altre classi che periodicamente notificano richieste di diversa natura...dall'alzare/abbassare il volume...al cambiare il file che il player sta visualizzando...e via dicendo...quindi avrei la necessitò che la classe madre riceva le diverse notifiche da tutte queste sorgenti e si comporti di conseguenza...nessuna interfaccia grafica...nessun evento legato a mouse o tastiera...

...grazie...ciao...

Certo, in effetti potrebbe anche non essere necessario definire un evento.
Ad esempio nel tuo caso potresti definire ed implementare:

public interface MyListener {
     public void incrementaVolume(int incremento);
     public void nuovoFile(String filePath);
}

Fondamentale è che tu chiarisca per bene quali sono le relazioni a livello di notifiche che intercorrono fra i vari oggetti che compongono l'insieme della tua applicazione.

[Guille]

Originariamente inviato da ally

...mh...non mi è chiara l'idea...non sono le classi MyEventoA e MyEventoB che ricevono l'evento?...

...ciao...

No quelli sono esempi di eventi, diversi fra loro e con eventuali informazioni aggiuntive, che la classe che implementa l'interfaccia MyMultyEventListener puo ricevere

[ally]

...scusate...evidentemente non ho capito come fungono tali event...

...ho creato le classi per i diversi Event...

public class MyEventoA extends EventObject {
	
    int a;
    
    public MyEventoA(Object source, int a) { 
    	super(source); 
	this.a = a;
	
	System.out.println("class "+a);
	
    }
}

...l'interfaccia che li implementa...

public interface MyMultyEventListener extends EventListener {
	
	public void performedEvantoA(MyEventoA e);
	public void performedEvantoB(MyEventoB e);
	      
}

...la classe che li lancia...

public class Fire {
	
	private ArrayList listeners = new ArrayList();
	
	private  void fireA() {
		MyEventoA event = new MyEventoA(this, 1);
		
		for(int i = 0; i < listeners.size(); i++) {
			((MyMultyEventListener)listeners.get(i)).performedEvantoA(event);
		}
	}
	
	private  void fireB() {
		MyEventoB event = new MyEventoB(this, "");
		
		for(int i = 0; i < listeners.size(); i++) {
			((MyMultyEventListener)listeners.get(i)).performedEvantoB(event);
		}
	}
	
	public static void main(String args[]){
		
		Fire evento = new Fire();
		try{
			Thread.sleep(1000);
		}catch(Exception e){}
		evento.fireA();
		try{
			Thread.sleep(1000);
		}catch(Exception e){}
		evento.fireB();
		
	}
}

...infine ho abbozzato quella che dovrebbe essere la classe implementa l'interfaccia...ma non riesco a capire come possa funzionare...infatti l'evento lanciato va a richiamare la classe che specifica il metodo...non le classi che implementano l'interfaccia...

public class Ricevitore implements MyMultyEventListener {


	public void performedEvantoB(MyEventoB e) {
		System.out.println("B");
		
	}

	public void performedEvantoA(MyEventoA e) {
		System.out.println("A");
		
	}
}

...chiedo lumi...

[Guille]

Prova a modifica la classe Fire cosi:

public class Fire {
	
	private ArrayList listeners = new ArrayList();

	// registra le classi che implementano MyMultyEventListener
	public void addMyEventListener(MyMultyEventListener listener) {
		listeners.add(listener);
	}

	private  void fireA() {
		MyEventoA event = new MyEventoA(this, 1);
		
		for(int i = 0; i < listeners.size(); i++) {
			((MyMultyEventListener)listeners.get(i)).performedEvantoA(event);
		}
	}
	
	private  void fireB() {
		MyEventoB event = new MyEventoB(this, "");
		
		for(int i = 0; i < listeners.size(); i++) {
			((MyMultyEventListener)listeners.get(i)).performedEvantoB(event);
		}
	}
	
	public static void main(String args[]){

		Fire evento = new Fire();
		Ricevitore ricevitore = new Ricevitore();
		// ricevitore si registra su evento
		evento.addMyEventListener(ricevitore);

		try{
			Thread.sleep(1000);
		}catch(Exception e){}
		evento.fireA();
		try{
			Thread.sleep(1000);
		}catch(Exception e){}
		evento.fireB();
		
	}
}

[ally]

...ok...ottimo grazie...ora vedo di riportare tutto al mio caso...

...grazie ciao...