Methodenname als Parameter

[obafmkm]

Wie kann ich einen Parameter definieren, der eine Methode darstellt?

Ich möchte folgendes erreichen (das Beispiel belegt eine JXTaskPane mit einem Eintrag):

private AbstractAction getTaskAction( String name, String tip, ? methodenname )
{
	AbstractAction action = new AbstractAction()
		{
			private static final long serialVersionUID = 1L;
			{
				putValue( Action.NAME, name );
				putValue( Action.SHORT_DESCRIPTION, tip );
			}

			public void actionPerformed( ActionEvent e )
			{
				 methodenname();
			}
		};
	return action;
}

 

[Der Müde Joe]

so einfach geht das nicht...
Stichwort: Reflection
http://java.sun.com/javase/6/docs/api/java/lang/reflect/Method.html

 

[obafmkm]

Aha, danke. Müsste es also heißen:

private AbstractAction getTaskAction( String name, String tip, String method )
{
	AbstractAction action = new AbstractAction()
		{
			{
				putValue( Action.NAME, name );
				putValue( Action.SHORT_DESCRIPTION, tip );
			}

			public void actionPerformed( ActionEvent e )
			{
				try
				{
					this.getClass().getMethod( method, null );
				}
				catch( SecurityException e )
				{
					e.printStackTrace();
				}
				catch( NoSuchMethodException e )
				{
					e.printStackTrace();
				}
			}
		};
	return action;
}

 

[SlaterB]

so fragst du die Klasse nach dem Method-Objekt,
was ohne Parameterangabe auch noch evtl. nicht klappen könnte

ausgeführt wird die Methode aber auf jeden Fall nicht,

so ein richtiges Thema bitte länger als 5 Min. anschauen, auch google bemühen (Beispiele!),
und wenn, dann erstmal in einem neuen kleinen Test-Programm mit main-Methode ausprobieren,
nicht irgendwo zwischen sowieso schon komplizierten Actions und Listener vergraben

 

[Schandro]

Von dieser Art der Methodenübergabe hast du schon gehört, oder?

interface MyMethod{
	public void doSomething();
}

class A{

	public static void main(String[] args){
		new A(new MyMethod(){
			public void doSomething(){
				System.out.println("Blablubb");
			}
		});
	}
	
	public A(MyMethod method){
		method.doSomething();
	}
}

Keine Ahnung was du mit deinem Code vorhast, mmn ist aber so eine Lösung Reflection vorzuziehen

EDIT: Falls du auf fertige Methoden zugreifen willst, die als normale Methoden im Klassencode drinstehen, kannst du ja auch einfach sowas als Paramter übergeben:

new MyMethod(){
		public void doSomething(){
			meinObject.führDeineSpezielleMethodeAus();
		}
	}

 

[ARadauer]

auf jeden Fall, also meiner meinung nach ist Reflection nur was für Ausnahmefälle.. wenns wirklich gar nicht anders geht!

Im normallfall sollte man eine art command pattern benutzen. So wie Schandro es gezeigt hat. Du hast Klassen die alle ein Interface implementieren, das praktisch eine "ausfürhen" Methode definiert....

sowas wie Funktionspointer oder wie in javascript dass man einfach einen methode mitgibt... gibts in java leider nicht.... noch nicht ;-)

 

[obafmkm]

Zum Sinn des Ganzen:

In meinem Programm wird ein JXTaskPaneContainer definiert, der seine JXTaskPanes aufnimmt. Jedes dieser Panes kann ja mehrere Einträge enthalten. Derzeit habe ich es so realisiert, wie es die SwingX-Doku zeigt:

openpanel = new JXTaskPane();
openpanel.setTitle( "Open" );

openpanel.add( new AbstractAction()
	{
		{
			putValue( Action.NAME, "Open" );
		}

		public void actionPerformed( final ActionEvent ev )
		{
			taskopen();
		}
	} );

openpanel.add( new AbstractAction()
	{
		{
			putValue( Action.NAME, "New" );
		}

		public void actionPerformed( final ActionEvent ev )
		{
			tasknew();
		}
	} );

openpanel.add( new AbstractAction()
	{
		{
			putValue( Action.NAME, "New with defaults" );
		}

		public void actionPerformed( final ActionEvent ev )
		{
			tasknewdefaults();
		}
	} );

Das sieht noch recht übersichtlich aus. Ich habe den Code ja hier auch gekürzt. Tatsächlich werden pro neuer AbstractAction mehrere putValue-Angaben gemacht und weitere Einstellungen. Wenn jede TaskPane nur 5 solcher Einträge hat, wird der Codeteil schnell umfangreich.

Deshalb meine Abkürzung. Statt z. B.

openpanel.add( new AbstractAction(){ /* ... */ } );

bräuchte nur sowas stehen wie

openpanel.add( getTaskAction( "Open", "tooltip", "methode_open" );
openpanel.add( getTaskAction( "New", "tooltip", "methode_new" );
// usw.

Dann könnte die Methode getTaskAction() ungefähr so stehen (hier mal ohne Exception-Behandlung):

private AbstractAction getTaskAction( String name, String tip, String method )
{
   AbstractAction action = new AbstractAction()
      {
         {
            putValue( Action.NAME, name );
            putValue( Action.SHORT_DESCRIPTION, tip );
         }

         public void actionPerformed( ActionEvent e )
         {
               this.getClass().getMethod( method, null );
         }
      };
   return action;
}

Hintergrund ist also nur, einen umfangreichen Code zu kürzen, um ihn besser wartbar zu machen.

 

[Der Müde Joe]

machs doch so wie oben vorgeschlagen..

private AbstractAction getTaskAction( String name, String tip, ActionCommand command )  {
//..
command.execute();
//..
}
public interface ActionCommand {
execute();
}

public PrintAction implements ActionCommand {

public execute() {
System.out.println("hello world)
}

}

//ausführen dann mit
asdf.getTaskAction("","",new PrintAction());

für jede Methode dann eine eigene Klasse

EDIT:
Reflection ist nicht grad das einfachste und Methode müssete man mit invoke ausführen

 

[SlaterB]

nebenbei:

openpanel.add( new AbstractAction() 
   { 
      { 
         putValue( Action.NAME, "New with defaults" ); 
      } 

      public void actionPerformed( final ActionEvent ev ) 
      { 
         tasknewdefaults(); 
      } 
   } );

ließe sich mit einer ordentlichen eigenen SubKlasse zumindest auf

openpanel.add( new ShortAction("New with defaults") { 
      public void action() 
      { 
         tasknewdefaults(); 
      } 
   } );

kürzen, indem man einen Konstruktor einsetzt und die Standard-actionPerformed() die neue abstrakte Methode action() aufrufen läßt,
aber Reflection bietet natürlich noch mehr Einsparpotential

-----

@Der Müde Joe
> machs doch so wie oben vorgeschlagen..

das ist doch alles längst bekannt?

 

[obafmkm]

Hmm, den Schreibaufwand, denn ich in meiner eigentlichen Klasse vermeiden möchte, lagere ich in weiteren Interfaces und Klassen aus ... Nette Idee, aber was habe ich dadurch gespart?

 

[SlaterB]

zu Der Müde Joe mag das stimmen, das meinst du vielleicht,
bei der ShortAction wäre der Vorteil, dass man die ShortAction nur einmal programmieren muss,

 

[obafmkm]

@SlaterB: Da kam dein Post, als ich gerade meine Entgegnung an Der Müde Joe anfertigte. Wenn Reflection noch mehr Einsparpotential bietet, wäre das ja meine Frage gewesen, wie ich das konkret machen muss.

 

[SlaterB]

das wurde schon in der allerersten Antwort beantwortet, bzw. deine Nachfragen in meiner ersten Antwort dann zurechtgewiesen

wenn du wirklich spezielle Probleme hast, dann frag ruhig,
aber dass du z.B. noch die invoke() Methode von Method brauchst kannst du nun wirklich überall nachlesen

 

[obafmkm]

@SlaterB: Es ist wohl in der ersten Antwort beantwortet worden, aber ich habs bisher nicht richtig umsetzen können. (Ist hier immerhin das Anfängerforum). Und ich teste dies immer eingebunden in meinem (kurzen) Code, weil ich die Erfahrung gemacht habe, dass sich viele Sachen plötzlich anders verhalten, wenn man alleinstehende (und funktionierende) Methoden in den Hauptcode aufnimmt (auch die Java-Doku ist nicht fehlerfrei) ...

Ich hab jetzt testweise folgendes versucht (Beispiel):

openpanel.add( new AbstractAction()
   {
      {
         putValue( Action.NAME, "Open" );
      }

      public void actionPerformed( final ActionEvent ev )
      {
         showLine();
      }
   } );

hab ich ersetzt durch

openpanel.add( getTaskAction( "name", "tooltip", "showLine" ) );

getTaskAction() ist wie folgt (hier ohne Exceptions):

private AbstractAction getTaskAction( final String name, final String tip, final String method )
{
	AbstractAction action = new AbstractAction()
		{
			{
				putValue( Action.NAME, name );
				putValue( Action.SHORT_DESCRIPTION, tip );
			}

			public void actionPerformed( ActionEvent e )
			{
					this.getClass().getMethod( method, (Class[])null ).invoke( method, (Object[])null );
			}
		};
}

Dazu kommt noch die showLine() (mit Testinhalt):

protected void showLine()
{
	System.out.println( "HURRA" );
}

Beim Klick auf den entsprechenden Eintrag des Panes kommt folgende Ausgabe (Auszug):

java.lang.NoSuchMethodException: de.package.GUI$8.showLine()
	at java.lang.Class.getMethod(Unknown Source)
	at de.package.GUI.GUI$8.actionPerformed(GUI.java:302)

Wieso kann Java die in der gleichen Klasse definierte Methode nicht finden?

 

[Noctarius]

Weil Sie nicht in der gleichen Klasse sitzt. Du definierst mit "new AbstractAction" eine neue (so called) anonyme Klasse welche das Interface AbstractAction implementiert.

 

[SlaterB]

weil der übergebene Paramer '(Class[])null' Quark ist,
wie du ihn in keinem funktionierenden Beispiel im Internet finden wirst,
oder auch in der API-Beschreibung zur Methode nachlesen kannst,
du musst ein leeres Class[] übergeben (Länge 0),

(edit: oder siehe vorherige Antwort, vielleicht geht sogar Array null..)

----

'Anfänger-Forum' sollte sich auf die Themen beziehen, nicht dass die Fragesteller selbstständiges Nachlesen einstellen können
aber das kann man so und so sehen, ich bleib jetzt mal hier meiner Argumentation treu, ohne dass nun allzu ernst zu sehen

 

[Der Müde Joe]

Als kleines Beispiel:

import java.lang.reflect.Method;


public class Reflector {

	public void foo() {
		System.out.println("Hurra");
	}

	public static void main(String[] args) throws Exception {
		Reflector ref = new Reflector();
		Method meth = ref.getClass().getMethod("foo");
		// mit referent auf das Objekt
		meth.invoke(ref);
	}
}

 

[Noctarius]

this.getClass().getMethod( method, new Class[0] ).invoke( this.getClass(), new Object[0] );

 

[Der Müde Joe]

this.getClass().getMethod( method, new Class[0] ).invoke( this.getClass(), new Object[0] );

so ... Zeugs kann man weglassen und this.getClass will nicht die Klasse, sondern das Objekt..also this

EDIT:
bei this.getClass() meine ich invoke will das Objekt und nicht die Klasse vom Objekt

 

[Noctarius]

Ahjo stimmt ^^ Class is ja nur bei static *gg* Ach egal, bin noch halb am Schlafen