Newsgroup: it.comp.java
Titolo: Una questione di classe!

Ciao, problema per guru degli oggetti:
ho un menu di avvio che mi fa partire i miei programmi costituiti da JPanel.
Ognuno di questi JPanel richiama una classe che ho chiamato BarraStrumenti 
nella quale ci sono i pulsanti standard tipo stampa, nuovo, cancella ecc..
Come faccio a fare in modo che quando premo un pulsante su BarraStrumenti, 
ad esempio stampa, mi parta un evento sul JPanel chiamante?
Grazie
Alberto 

 ad esempio stampa, mi parta un evento sul JPanel chiamante?
Hai diverse strade:
La piu' purista e' che estendi il tuo JPanel inserendo un nuovo campo 
privato del tipo dell'oggetto chiamante e un nuovo costruttore che 
accetti un oggetto del tipo di oggetto del chiamante.
Quando poi clicchi sulla voce di menu' e crei l'oggetto MioJPanel, passi 
anche il riferimento all'oggetto stesso (this).
es.:
   public MioJPanel extends JPanel{
     private OggettoChiamante chiamante;
     public MioJPanel(OggettoChiamante chiamante){
       super();
       this.chiamante = chiamante;
     }
     /* evento OnClick, non conosco la firma ma sara' qualcosa del tipo:
      */
     public void onClick(Event event){
       this.metodoOggettoChiamante();
     }
   }
La strada piu' veloce e' che invece fai un metodo di tipo static final, 
che richiami un po' dove ti pare, ma che non ha legami con i riferimenti 
degli oggetti che sono in memoria, a meno che non li passi tutti 
interamente nella firma del metodo.
L'ultimo modo che hai e' orrendo, ma te lo dico lo stesso:
Crei una classe astratta con membri public static, che conterra' i 
riferimenti agli oggetti che ti servono a livello globale:
public abstract class Global{
   private static String nomeApplicazione;
   public static Strin getNomeApplicazione(){
     return nomeApplicazione;
   }
   public static Strin setNomeApplicazione(String s){
     nomeApplicazione = s;
   }
}
// Dall'applicazione la richiami anche questa da dove ti pare, stando
// attento a non generare NullPointerException:
.....
   System.out.println(Global.getNomeApplicazione());
.....
Ciao
-- 
            Davide Gurgone
      web: 
http://www.gurgone.it/
mail: davidechiocciolinagurgonepuntoit

Intanto grazie per il tuo aiuto.
la soluzione che mi sembra migliore č la prima, perň per quanto mi sforzi 
non riesco a capirla.
Provo a spiegare meglio il mio problema:
Ho un JFrame chiamato Principale che tramite un JTree mi permette di avviare 
piů istanze di diversi JPanel entro il JFrame.
Ogni JPanel al suo interno ha una JToolBar chiamata BarraStrumenti. Detto 
questo portesti per favore riscrivermi il codice con  i suddetti nomi?
Alberto


Il fatto e' che non sviluppo GUI, ma solo web application, quindi non 
conosco i parametri dei costruttori...
Ho un'idea, passa il codice che usi per aprire i JPanel dal JTree. Poi 
il resto vedo di fartelo capire meglio..


 resto vedo di fartelo capire meglio..
ok: ( uso netbeans)
    private void scelta(java.awt.event.MouseEvent evt) {
        Class cl;
        JPanel pannello;
        if (jtrMenu.getLastSelectedPathComponent() != null){
            Nodo n = (Nodo)jtrMenu.getLastSelectedPathComponent();
            String s = n.getNomeProgramma();
            if (!s.equals("")){
                int nrSessioni = n.getNrSessioni();
                try{
                if (nrSessioni == 0){
                    jTP.removeAll();
                    cl = Class.forName(s);
                    pannello = (JPanel)cl.newInstance();
                    jTP.add(pannello);
                    jTP.setTitleAt(0, n.toString());
                    n.setSessione(pannello);
                } else {
                    if (n == ultimoNodo){
                        // aggiungi qui controllo nr max sessioni
                        cl = Class.forName(s);
                        pannello = (JPanel)cl.newInstance();
                        jTP.add(pannello);
                        jTP.setTitleAt(nrSessioni, n.toString() + " " + 
(nrSessioni + 1));
                        n.setSessione(pannello);
                    } else {
                        jTP.removeAll();
                        for (int i = 1 ; i <= nrSessioni; i++){
                            jTP.add(n.getSessione(i - 1));
                            jTP.setTitleAt(i - 1, n.toString() + " " + i);
                        }
                    }
                }
                }catch(ClassNotFoundException cnfe){
                    System.out.println( "Classe sconosciuta" );
                }catch(IllegalAccessException iae){
                    System.out.println( "Accesso illegale" );
                }catch(InstantiationException ie){
                    System.out.println( "Errore Istanza\n" );
                }
            }
        ultimoNodo = n;
        }
    } 

Alt!
Risolto!
Ho usato un'interfaccia!
Grazie
Alberto 

 Alberto
Per il tuo problema esiste una metodologia di risoluzione chiamata Observer.
(design pattern: 
http://www.dofactory.com/Patterns/PatternObserver.aspx
)
Quello che tu vorresti è che alla pressione di un pulsante della Toolbar, si
faccia partire un metodo di un oggetto (in questo caso il JPanel) che è
stato posto in "osservazione".
A favore della riusabilità del codice:
1) facciamo in  modo che il metodo sia fatto partire su una lista di oggetti
"ascoltatori", piuttosto che su uno (useremo un'ArrayList);
2) facciamo in modo che il nome del metodo sia univoco (useremo
un'interfaccia);
----------------------------------------------------
interface osservatore
{
        public void riferisci_pulsante_premuto(int numero);
}
///////////////////////////////////////////////////////
class pannello extends JPanel implements osservatore
{
        public void riferisci_pulsante_premuto(int numero)
        {
                System.out.println("JPANEL: e' stato premuto un pulsante della toolbar");
        }
        pannello()
        {
                toolbar tb=new toolbar();
                tb.addOsservatori(this);
        }
}
//////////////////////////////////////////////////7
class toolbar extends JToolBar
{
        ArrayList arrOsservatori=new ArrayList();
        public addOsservatori(osservatore oss)
        {
                arrOsservatori.add(oss);
        }
        public toolbar(){};
        public pulsante_premuto(int numero_pulsante_premuto)
        {
                int i;
                osservatore oss;
                for (i=0;i<arrOsservatori.size();i++)
                {
                        oss=arrOsservatori.get(i);
                        oss.riferisci_pulsante_premuto(numero_pulsante_premuto);
                }
        }
}       
//////////////////////////////////////////////////
Allora, il primo oggetto che verrà istanziato è pannello.
Il costruttore di pannello, in questo caso, ha due istruzioni; la prima
inizializza un oggetto di tipo toolbar (il cui costruttore non fa nulla di
particolare), mentre la seconda chiama il metodo addOsservatore
dell'oggetto toolbar appena creato e aggiunge il riferimento al pannello.
Quindi in teoria qualsiasi tipo di oggetto potrebbe chiamare il metodo
addOsservable di un oggetto toolbar per mettersi in ascolto (ovviamente
l'"osservatore" deve implementare l'interfaccia osservatore).
Ora supponiamo che quando si prema un pulsante della toolbar, l'evento venga
segnalato all'oggetto toolbar stesso attraverso il metodo pulsante_premuto
(con il numero del pulsante passato come parametro).
A questo punto, entrando nel metodo pulsante premuto dell'oggetto toolbar,
si fa una scansione di tutti gli elementi presenti nell'ArrayList
arrOsservatori (che praticamente contiene tutti i riferimenti agli
osservatori che si sono registrati per ricevere la segnalazione dell'evento
pulsante premuto) e si chiama il metodo riferisci_pulsante_premuto di
ciascun osservatore (quindi viene chiamato il metodo dell'oggetto 
pannello, riferisci_pulsante_premuto).
Come vedi la riusabilità del codice è completa, perchè si può mettere in
ascolto dell'evento qualsiasi tipo di oggetto che implementi l'interfaccia
osservatore ed il metodo dell'oggetto osservatore che verrà chiamato si
conosce a priori, perchè è contenuto nell'interfaccia.
Ed il tuo problema è risolto. Java mette ovviamnte già a disposizione delle
classi pronte per risolvere il problema (Observer).
Se hai dubbi, fammi un fischio.
-- 
Ciao,
 Fabrizio
=== 
http://www.negusweb.it
 ===