getMethod, come utilizzarlo correttamente?

[andbin]

correttamente mi va al JPanel indicato pero lo fa aprendo una nuova finestra del programma e quindi ho 2 finestre aperte.

Scusa ma se hai già un oggetto della tua classe Interface (cioè hai già un tuo frame visibile) .... passa quello! Se il metodo invocato tramite reflection è "di istanza" si presuppone allora che vuoi che faccia "qualcosa" su una istanza specifica. E probabilmente creare un oggetto nuovo, in questo caso un nuovo frame, può appunto non avere senso.


Poi scusa ancora la domanda: perché stai usando la reflection? La reflection applicata in quel modo, cioè per fare operazioni scatenate da voci di menù o pulsanti, ecc... ha senso tipicamente se la creazione della interfaccia è estremamente "dinamica". Ad esempio se hai definito un tuo file XML che descrive e contiene la struttura dei menù. Quindi leggendo e parsando il documento XML vai a creare dinamicamente i tuoi menù. In tal caso, sì, può avere molto senso far scatenare le operazioni "dinamicamente" tramite reflection.

Se la creazione della tua interfaccia utente e dei tuoi menù è "cablata" nel codice, probabilmente l'uso della reflection per le azioni non ha granché senso .... o perlomeno rende tutto solo un po' più complesso.

[joker06]

public void actionPerformed(ActionEvent e) {
	    String comStr = e.getActionCommand();
	    try{
	    	Class<?> c= Class.forName("Interface");
	    	Class<?>[] params = null;
	    	Method m=c.getDeclaredMethod(comStr,params);
            m.invoke(this);
	    }catch (NoSuchMethodException | SecurityException |
                IllegalAccessException | IllegalArgumentException | InvocationTargetException | ClassNotFoundException ea) {
            // TODO Auto-generated catch block
            ea.printStackTrace();
        }
	}

Come ti sembra? funzionare funziona però volevo un parare da te se hai tempo, ora cambia correttamente i pannelli (l unico problema è che quando torno nel pannello mi continua ad aggiungere le scritte 1 x ogni volta che entro nel JPanel ma quello ora non credo sia legato alla chiamata che sto facendo).

Avevo deciso di abbandonare questa strada per passare allo switch e tanti saluti ma è una questione personale oramai

[andbin]

Come ti sembra?

"nì" ... sì e no. Nel senso che tecnicamente può anche funzionare ma si può fare di meglio (pur usando la reflection) anche a livello di design generale (tra poco spiego meglio).

Innanzitutto se puoi usare fino a Java 8, potresti sfruttare due nuove caratteristiche che sono le principali e più interessanti novità di questa release, ovvero le lambda expression e i method references.

1) Con le lambda expression:

menuItem1.addActionListener(e -> {  /*tue istruzioni*/  });

menuItem2.addActionListener(e -> {  /*altre tue istruzioni*/  });
....

Sì, basta proprio solo questo: e -> { ....... } è una "lambda expression". La "e" che vedi è il parametro ActionEvent. Non serve precisare il tipo (ma si può fare) perché il compilatore lo deduce dal contesto tramite la inferenza dei tipi.

2) Oppure con i method reference:

Se hai un tuo metodo di istanza es.

public void azione1(ActionEvent e) { ...... }

che è nella classe dove poi fai gli addActionListener:

menuItem1.addActionListener(this::azione1);

Sì, hai di nuovo capito bene, è proprio tutto qui.


Se non puoi usare Java 8, puoi continuare ad usare la reflection, se proprio non vuoi/puoi fare altro. Ma almeno tieni presente che:
- Se la classe è nota a priori, non serve per forza il Class.forName. Per ottenere il Class basta usare un class "literal" (cioè Interface.class) oppure invocare getClass() sul tuo oggetto Interface.
- Puoi anche, e in maniera molto più "pulita", definire una classe, anche esterna al tuo Interface, per implementare il listener. Come la seguente.

public class MethodInvokerActionListener implements ActionListener {
    private Object targetObj;
    private Class<?> targetClass;

    public MethodInvokerActionListener(Object targetObj) {
        this.targetObj = targetObj;
        targetClass = targetObj.getClass();
    }

    public void actionPerformed(ActionEvent event) {
        String methodName = event.getActionCommand();

        try {
            Method method = targetClass.getDeclaredMethod(methodName);  // no-params
            method.invoke(targetObj);  // no-args
        } catch (Exception ex) {
            // ..... log o altro .....
        }
    }
}

Non ti sembra estremamente più pulita la cosa? Queste sono questioni più che altro di "design". Ma cerca di farci caso ... perché sono parecchio importanti!

Nella tua classe Interface avrai solo da istanziare MethodInvokerActionListener passando il this al costruttore, poi l'oggetto MethodInvokerActionListener (lo stesso identico) lo puoi passare a tutti gli addActionListener che vuoi (quelli per cui sai che il componente ha il command che è il nome di un metodo in Interface).

ora cambia correttamente i pannelli (l unico problema è che quando torno nel pannello mi continua ad aggiungere le scritte 1 x ogni volta che entro nel JPanel ma quello ora non credo sia legato alla chiamata che sto facendo.

Non ho ben capito ma ... se la questione è quella che ogni tanto mi capita di sentire, cioè poter "scambiare" pannelli, ne ho già parlato più volte, tipo qui e (più vecchio) qui.

[joker06]

Per ora ho risolto il problema dello sdoppiamento dei label quando esco e rientro in un pannello con la removeAll