Newsgroup: it.comp.java
Titolo: Generazione di Eventi. ???

Ciao,
vorrei chiedere dove reperire esempi su come scrivere classi
che generino degli eventi; tutto quello che sono riuscito a trovare
riguarda eventi legati alle interfacce grafiche. A me interessa
che una classe non grafica generi un evento; da un'altra parte
un'altra classe dovrebbe intercettarlo ed solo in alcuni casi
aggiornare un componente grafico o scrivere in um file.
Per essere più chiari:
ho una classe che implementa un algoritmo complesso la cui esecuzione
dura anche 9 ore; vorrei durante l'esecuzione del programma scrivere in
un file il risultato intermedio di alcuni calcoli.
Grazie in anticipo,
saluti Enzo.

 che generino degli eventi; tutto quello che sono riuscito a trovare
In Java la gestione degli eventi è demandata al modello attore (che genera
l'evento) / ascoltatore (che lo recepisce), quindi per creare un evento
tutto tuo non devi fare altro che seguire la seguente procedura:
- crei un'interfaccia che contenga un metodo che verrà richiamato
all'interno dell'osservatore. Chiamiamo questa interfaccia 
p.es
EventoListener, e ipotizziamo che il metodo si chiami suEvento. I parametri
di suEvento sono a tuo piacimento, puoi metterci anche niente se non hai
particolari informazioni da comunicare.
- crei la tua classe attrice (
p.es
. GeneraEventi) che contenga un metodo che
permetta di aggiungere degli ascoltatori: 
p.es
.
addEventoListener(EventoListener oggetto) che si occuperà di memorizzare
"oggetto" in un array privato della tua classe GeneraEventi insieme a tutti
quelli interessati a gestire l'evento. Vedi tu se rendere metodo e array
statici (uno per tutte le instanze) o meno (uno per istanza), dipende da
cosa ci devi fare.
- crei la classe ascoltatrice che implementa EventoListener. Nel costruttore
(o dove più ti fa comodo) ci metti un bel
IstanzaDiGeneraEventi.addEventoListener(this), e implementi il metodo
suEvento dichiarato in EventoListener per fargli fare quello che ti serve in
risposta all'evento.
- quando la classe attrice deve generare l'evento non fa altro che scorrere
l'array degli oggetti ascoltatori e richiamare il metodo suEvento di
ciascuno.
Questo modello per altro si presta ad essere realizzato in tutti i linguaggi
ad oggetti degni di questo nome e ha il vantaggio di essere sostanzialmente
indipendante dalla piattaforma su cui gira.
Ti allego un esempio semplicissimo con una classe di test che crea due
ascoltatori e genera un evento.
EventoListener.java
--------------------
public interface EventoListener {
 public void suEvento();
}
GeneraEventi.java
-------------------
import java.*;
import java.util.*;
public class GeneraEventi {
 private static ArrayList Ascoltatori=new ArrayList();
 public static void addEventoListener (EventoListener Ascoltatore) {
  Ascoltatori.add (Ascoltatore);
 }
 public static void Evento() {
  int idx=Ascoltatori.size();
  while (idx>0) {
   ((EventoListener) Ascoltatori.get(idx-1)).suEvento();
   idx--;
  }
 }
}
Ascoltatore.java
-----------------
import java.*;
public class Ascoltatore implements EventoListener {
 public void suEvento() {
  System.out.println("EVENTO");
 }
 public Ascoltatore () {
  GeneraEventi.addEventoListener(this);
 }
}
Test.java
---------
public class Test {
 public static void main(String[] argv) {
  Ascoltatore a1=new Ascoltatore();
  Ascoltatore a2=new Ascoltatore();
  GeneraEventi.Evento();
 }
}

 ascoltatori e genera un evento.
Grande!!!
Trattazione esaustiva al 100%; Ho quasi implementato il tutto.
Ora posso permettermi di far girare l'algo anche per due giorni.
Saluti Enzo.