Newsgroup: it.comp.java
Titolo: uno o più listeners?

Ho realizzato un gestionale con java, funzionante, ma vorrei apportare
delle modifiche più che altro stilistiche.
per il momento tutti gli oggetti (pulsanti , tabelle, liste,eccetera)
possiedono un loro listener(ho utilizzato le classi adapter interne),
e quindi quando creo un pannello che contiene 5 oggetti di questi,
vengono creati anche 5 listeners.
Ora quello che vorrei fare è creare dei listeners comuni a seconda
della categoria.
Quindi se in tutto il programma ci sono 10 button, creo un unico
listener per i button (premettoche i button li ho ridefiniti e possono
essere di tre tipi)
esempio:
public class gestoreBottoni implements ActionListener{
public void actionPerformed(ActionEvent e) {
  if(e.getClass().equals(bottonetipo1) )
    CLASSE1.METODOSTATICO(e.getSource().campo);  // DOVE CAMPO E'
PUBBLICO E DI TIPO STRINGA
  elseif(e.getClass().equals(bottonetipo2))
    CLASSE2.METODOSTATICO(e.getSource().campo);  // DOVE CAMPO E'
PUBBLICO E DI TIPO STRINGA
  else
    CLASSE3.METODOSTATICO(e.getSource().campo);  // DOVE CAMPO E'
PUBBLICO E DI TIPO STRINGA
}
}
Sicuramente perdo qualcosa in termini di tempo in fase di esecuzione,
però la ram ipegnata e' minore visto che facendo questo discorso con
tutti cli oggetti , riesco a diminuire i listeners
che ne dite?
Sono giusti i metodi utilizzati?Accetto consigli e correzioni

Apporto le doverose correzioni alla classe che ho scritto
public class gestoreBottoni implements ActionListener{
public void actionPerformed(ActionEvent e) {
   Object o = e.getSource();
   Class c = o.getClass();
   if (c==bottonetipo1.class)
    CLASSE1.METODOSTATICO(o.campo);  // CAMPO E' PUBBLICO E DI TIPO
STRINGA
  elseif(c==bottonetipo2.class))
    CLASSE2.METODOSTATICO(o.campo);  // CAMPO E' PUBBLICO E DI TIPO
STRINGA
  else
    CLASSE3.METODOSTATICO(o.campo);  // CAMPO E' PUBBLICO E DI TIPO
STRINGA
}
}
Aspetto vostri consigli
Grazie a tutti


La gestione dei listeners a mio parere dipende principalmente dagli oggetti
su cui si vuole avere visibilità: essi vanno definiti ed implementati nel
"luogo" più opportuno, il *come* sono fatti secondo me è secondario. Se poi
nel tuo gestionale tutti gli oggetti di una certa tipologia (ad es. i
pulsanti) sono nello stesso "posto" della tua interfaccia allora la tua
soluzione ha senso: naturalmente con questo tipo di codice ti vincoli molto
al tipo di struttura usata, nel tuo source dell'event devi portarti dietro
un riferimento (il tuo 'campo') a tutti gli oggetti che subiscono modifiche
a causa dell'evento, e se devi fare un cambiamento ti tocca rivedere la
struttura di tali riferimenti... Non puoi risolvere più pulitamente con
un'unico actionCommand e mettere il listener con una visibilità opportuna
sugli oggetti che deve modificare?
Nel tuo codice cmq devi evidentemente castare il source 'o'.
Inoltre Class è implementato come singleton, visto che usi l'==?

 Inoltre Class è implementato come singleton, visto che usi l'==?
Potresti essere più chiaro?

 Potresti essere più chiaro?
Cosa intendi per c==bottonetipo1.class?
c è un oggetto di tipo Class, bottonetipo1.class lo stesso (o sarà
bottonetipo1.getClass() ?): per eguagliarli in quel modo devono essere
proprio lo *stesso* oggetto, ergo ogni istanza di Class deve essere univoca
a parità di nome di classe.
A meno che non fosse metaJAVA, natur.te.

gnurant ha scritto:

ciao,
come mai usi l'uguaglianza di classe? se tu avessi 2 bottoni (oggetti) 
diversi, ma istanze della stessa classe, questoi approccio non 
funzionerebbe.
Se nella classe hai dichiarazioni del tipo:
MyJButton bottonetipo1;
MyJButton bottonetipo2;
MyJButton bottonetipo3;
a parte il fatto che:
- i nomi delle classi "dovrebbero" essere scritti in maiuscolo (vedi 
gestoreBottoni);
- i nomi degli oggetti(bottoni) "dovrebbero" essere esplicativi..
il listener potrebbe essere del tipo:
public void actionPerformed(ActionEvent e) {
   Object o = e.getSource();
   if (o == bottonetipo1 )
     CLASSE1.METODOSTATICO((MyJButton)e.getSource().campo);
   else if (o == bottonetipo2)
     CLASSE2.METODOSTATICO((MyJButton)e.getSource().campo);
   else if (o == bottonetipo3)
     CLASSE3.METODOSTATICO((MyJButton)e.getSource().campo);
}
è vero che i metodi statici occupano meno memoria... ma ti piacciono 
così tanto? ;)
ciao,
Mauro

 che ne dite?
Ah, giusto, dimenticavo: riesci ad apprezzare prestazioni diverse in fase di
esecuzione *su un gestionale*???

Cosa intendi per c==bottonetipo1.class?
facendo bottonetipo1.class ti ritorna una classe,  potresti anche
scrivere JButton.class  ritornerebbe JButton,
bottonetipo1 non è il riferimento ad un oggetto creato, in quel caso
avrei dovuto fare bottonetipo1.getClass()

 
mi sono perso un pezzo della discussione..
se vuoi disaccoppiare la vista dal controller, potresti mettere nella 
vista un listener di eventi (es. interfaccia MyControlListener),
lasciare nella vista l'actionlistener dei bottoni (e quindi usando 
l'action listener visto) e quando il bottone lancia un evento, 
dall'actionListener lo puoi propagare al controlListener
oppure
non conoscendo bene il problema, potrebbe essere contro producente, ma, 
se utilizzi dei tuoi bottoni, al posto di avere 1 classe x ogni bottone 
potresti aggiungere un campo
String tag
al tuo bottone, in modo tale che l'actionListener esterno possa usare 
tale dato per determinare la giusta azione da compiere
if (butt.getTag().equals("exit")) { }
Mettere metodi pubblici al posto ddgli statiche va bene, metterli nelle 
classi dei bottoni non so', si rischia di snaturare un poco la natura 
(semplice) del bottone, ma tutto dipende dagli scopi dei metodi.
ciao,
Mauro