Originariamente inviato da Bobo90
ho una classe finestra in cui estendo JFrame e faccio tutto quello che devo fare.. e ho una classe MyListener che implements Listener in cui ho un metodo ActionPerformed che mi compie l'azione..
Partiamo dalle questioni concettuali: la gestione degli eventi è una cosa che tipicamente deve avere una certa "intimità" con il resto del codice di creazione/gestione della interfaccia utente. Quindi i listener generalmente è bene averli il più vicino possibile alla gestione della interfaccia utente. E che siano oltretutto possibilmente anche nascosti all'esterno.
Pertanto, e salvo casi particolari, non è buona cosa avere le classi di implementazione dei listener esterne ai frame/pannelli/altro. Lo vedi bene anche tu: hai dovuto passare al costruttore di MyListener il riferimento a Finestra e questa non è una buona cosa.
Se nel listener dovessi, come scenario di esempio, disabilitare o abilitare il pulsante "Ok" ... cosa fai? In Finestra metti il campo ok come "public"? Pessima idea.
Metti un metodo "public" es. void abilitaOk(boolean enable) ? Già meglio del campo public ma comunque non buono dal punto di vista del design (a meno che ci siano seri motivi per permettere dall'esterno di (dis)abilitare il Ok).
Hai colto il nocciolo della questione?
I listener tipicamente si implementano dentro le classi di gestione della interfaccia utente. In genere con delle "inner class", di tipo "anonymous" o anche "regular" (raramente quelle "local").
E poi è vero che si può usare il action command per distinguere tra eventuali più pulsanti ma in genere la soluzione più diretta è il confronto dei reference, cioè verificare che il "source" dell'evento sia esattamente uguale (in senso di == dei reference) ad uno dei vari componenti.
2 scenari di codice di esempio (abbozzati!):
1) listener distinti come "anonymous inner class"
codice:
public class Finestra extends JFrame {
private JButton ok = new JButton("Ok");
private JButton annulla = new JButton("Annulla");
public Finestra() {
// ........
ok.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// ...... premuto ok
}
});
annulla.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// ...... premuto annulla
}
});
}
}
2) listener unico come "regular inner class" che distingue il "source"
codice:
public class Finestra extends JFrame {
private JButton ok = new JButton("Ok");
private JButton annulla = new JButton("Annulla");
public Finestra() {
// ........
MyListener myListener = new MyListener();
ok.addActionListener(myListener);
annulla.addActionListener(myListener);
}
private class MyListener implements ActionListener {
public void actionPerformed(ActionEvent e) {
Object source = e.getSource();
if (source == ok) {
// ...... premuto ok
} else if (source == annulla) {
// ...... premuto annulla
}
}
}
}
E non sono gli unici scenari possibili!
E nota i vari "private" !
Rispondi quotando
