[java] Registrare un metodo

[ceres80]

Salve,
ho la necessità di registrare un metodo....
Ho ad esempio una classe generica

public class MiaClasse
{
public void do()
{
...
metodoRegistratoDaUtente()
//questo metodo non lo so chi è sarà l'utente a dirmi quale sarà
...
}
}

qualcuno ha idea di come si faccia ?

[andbin]

Originariamente inviato da ceres80

qualcuno ha idea di come si faccia ?

Non puoi creare dei metodi a run-time. Tutti i metodi devono essere conosciuti a tempo di compilazione.

[j_c_maglio]

fra l'altro non vedo l'utilità

[PGI-Bis]

Sono di corsa, perdona la sintesi. Per aggiungere un metodo ad una classe dovresti usare il package instrument e correlati. Una via più semplice è appoggiarsi all'introspezione: non puoi aggiungere un nuovo metodo ad una classe ma puoi infilare un'intera categoria di oggetti nella jvm.

import java.lang.reflect.*;

public class MiaClasse {
	private String className, methodName;
	
	public void setMethod(String className, String methodName) {
		this.className = className;
		this.methodName = methodName;
	}

	public void doIt() {
		if(className != null && methodName != null) {
			invokeMethod();
		}
	}
	
	private void invokeMethod() {
		try {
			Class c = Class.forName(className);
			Method m = c.getMethod(methodName); //no parameters method
			Object o = c.newInstance(); //no args constructor
			m.invoke(o);
		} catch(Exception ex) {
			ex.printStackTrace();
		}
	}
}

Qui passi a MiaClasse il nome del tipo ed il nome del metodo da invocare, e con un doIt lo chiamerai.

Circa l'utilità, qualcuno direbbe che senza meccanismi di questa risma un programma non sarebbe che l'ombra di un sistema orientato agli oggetti =).

[ceres80]

Grazie mille....
però una cosa che non capisco è
m.invoke(o);

cosa fa ?

Quali sono i parametri che passao al metodo ?
(Ad esempio il metodo che registrerà l'utente ha bisogno di fue stringhe come parametri)

Grazie

[lovaz]

Ma non puoi usare una semplice interfaccia con il tuo metodo?
Cosa devi fare di preciso?

[PGI-Bis]

m.invoke(o);

è la versione riflessiva dell'espressione di invocazione di un metodo di nome m attraverso il riferimento o:

o.nomeMetodo();

Per intero, invoke è:

invoke(Object riferimento, Object... valori_per_i_parametri_del_metodo)

dove ogni valore nel parametro variabile (...) è di un tipo compatibile in assegnamento con i parametri formali del metodo m, determinati all'atto dell'ispezione della classe:

Method m = classe.getMethod(String nome, Class... tipi_parametri);

[The3DProgrammer]

Originariamente inviato da lovaz

Ma non puoi usare una semplice interfaccia con il tuo metodo?
Cosa devi fare di preciso?

infatti, secondo me c'è puzza di callback

prova a vedere se questo design ti può servire:

 public interface Command{

      public void execute();

}

public class MyClass{

        private Command myCommand;

         ...

        public void registerCommand(Command command){
          myCommand=command;
         }

         public void do(){

              ....

              myCommand.execute();

              ...

         }

}

class FirstCommand implements Command{

        void execute(){
         //prima implementazione di command
               ...
         }

}

class SecondCommand implements Command{

void execute(){
//seconda implementazione di command
...
}

}

...

class CommandFactory{

private CommandFactory(){}

public static Command createCommand(int commandChoosed){

      switch(commandChoosed){
        case 1:
          return new FirstCommand();
          break;
           ...

      }

       return null;
   }

}

dove ovviamente commandChoosed può anche non essere un intero, ma ad es una stringa passata dall'utente che consenta di decidere quale Command passare a MyClass.

ciau