Newsgroup: it.comp.java
Titolo: Tecniche di programmazione

Salve a tutti,
leggendo alcuni manuali Java ho notato che, nella creazione di interfacce
grafiche, le tecniche usate sono delle più disparate: creazione di una
classe derivata da Frame o JFrame e implementante i vari listener, listener
implementati come classi interne, Frame implementato tramite
composizione.......una gran confusione!!!!
La mia domanda è: esiste una tecnica "privilegiata"?
In particolare, circa l'implementazione di componenti quali i bottoni, avevo
pensato di derivare una mia classe (implementandola come classe interna)
"personalizzata" a seconda dell'azione svolta dal componente, inserendovi il
listener come classe interna, in modo da istanziare poi un oggetto completo
delle sue funzionalità, non un semplice bottone al quale poi aggiungere
listener e quanto altro, aumentando la complessità locale del codice!
Vi sembra una buona idea?
Vi ringrazio anticipatamente,
Un saluto,
Sergio B.

Vi sembra una buona idea?
Conosci le Action?
http://java.sun.com/docs/books/tutorial/uiswing/misc/action.html
-- 
Ciao
	Fabrizio C.

 del codice! Vi sembra una buona idea?
mmmmhh... personalmente non mi piace. Pensa se volessi eseguire lo stesso 
comando, oltre che alla pressione del tasto, anche ad esempio da un clic 
sul menu o in seguito a una particolare sequenza di tasti. In questo caso 
dovresti scrivere da qualche parte cose tipo button1.click(), il che non è 
affatto bello. 
In realtà IMHO la soluzione invece è già più che suggerita nel framework di 
Java, ed è il pattern Observer: i componenti lanciano gli eventi a chiunque 
sia interessato (e si limitano a fare questo), mentre i comandi in risposta 
a questi eventi sono implementati altrove.
Ad esempio io trovo molto comodo usare un unico ActionListener per tutta 
l'applicazione, dove "concentro" la risposta a tutti i comandi validi per 
l'applicazione. Generalmente l'ActionListener è per me l'applicazione 
stessa: può tornarmi utile ad esempio per lanciare comandi dall'esterno.
Ciascun comando, sempre secondo la logica di Java, è poi una stringa (che 
per me è bene mettere in una costante), per cui è davvero facile richiamare 
i comandi che vuoi. Ti faccio un esempio:
class MyApplication implements ActionListener
{
        // Qui definisco i comandi accettati dall'applicazione
        public static final String CMD_FAIQUALCOSA = "fai_qualcosa";
        public static final String CMD_FAIALTRO = "fai_altro";
 
        // Qui rispondo ai comandi
        public void actionPerformed( ActionEvent e )
        {
                String command = e.getActionCommand();
 
                if ( command.equals( CMD_FAIQUALCOSA ) )
                {
                        faiQualcosa();
                }
                else if ( command.equals( CMD_FAIALTRO ) )
                {
                        faiAltro();
                }
        }
 
        // Qui associo i controlli che voglio ai comandi
        public void method( ... )
        {
                ...
                button1.setActionCommand( CMD_FAIQUALCOSA );
                button1.addActionListener( this );
                ...
        }
}
Lavorando in questo modo ti sarà sempre facile ridefinire il comportamento 
di un comando, anche se ad esempio decidi di lanciarlo non più dalla 
pressione di un tasto ma magari dalla selezione di un menu.
Personalmente questo è il modo di procedere che preferisco.
ciao :)
pole

 La mia domanda è: esiste una tecnica "privilegiata"?
Non direi. In genere, per reazioni la cui specifica e' corta, una classe 
anonima derivata "sul posto" va bene. Se il codice e' piu' corposo, 
conviene fare una classe separata, magari nello stesso file. Implementare 
le interfacce di listening direttamente puo' essere valido, ma dipende 
dalla natura della classe che implementa - in genere, appena ti accorgi che 
lo stesso listener ti serve in due contesti diversi, e' meglio delegare a 
due classi distinte.
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun

Grazie a tutti,
Sergio