Methoden Methode als String übergeben, dann aufrufen?

[membersound]

Hallo,

kann man einen Methodenname als String übergeben, und diese Methode dann irgendwie aufrufen?

Folgendes geht natürlich nicht, aber ihr versteht was ich meine:

    private void testfnc() {
        int foo;
        foo = 2;
        
        switch(foo) {
            case 1: bar("myMethod1()"); break;
            case 2: bar("myMethod2()"); break;
            default: break;
        }
    }
    
    private void bar(String choice) {
        //do something like:
        myObject.choice; //which would mean myObject.myMethod1() or myMethod2();
    }

Abhängig von foo möchte ich also immer die Methode bar aufrufen, aber der Inhalt dieser Methode unterscheidet sich immer nur um einen bestimmten Methodenaufruf.

Danke

 

[ARadauer]

Such mal nach dem Stichwort Reflection, damit gehts

 

[turtle]

Klar geht das.

Unter dem Stichwort Reflection findest Du genügend "Material" zum Studieren.

 

[bygones]

huete dich gleich vor dem schwergewicht reflection.

schau dir lieber das command pattern an !

 

[pl4gu33]

Hallo,

kann man einen Methodenname als String übergeben, und diese Methode dann irgendwie aufrufen?

Folgendes geht natürlich nicht, aber ihr versteht was ich meine:

    private void testfnc() {
        int foo;
        foo = 2;
        
        switch(foo) {
            case 1: bar("myMethod1()"); break;
            case 2: bar("myMethod2()"); break;
            default: break;
        }
    }
    
    private void bar(String choice) {
        //do something like:
        myObject.choice; //which would mean myObject.myMethod1() or myMethod2();
    }

Abhängig von foo möchte ich also immer die Methode bar aufrufen, aber der Inhalt dieser Methode unterscheidet sich immer nur um einen bestimmten Methodenaufruf.

Danke

wäre es nicht einfacher in diesem Falle foo zu übergeben in die bar Methode und den Vergleich dort zu machen und die Methoden direkt aufzurufen ?

 

[membersound]

Also bei den Reflections steige ich nicht durch.

Zum Command pattern: vl habe ich mich unverständlich ausgedrückt, aber ich sehe nicht wo mir das helfen könnte.

Ich mach nochmal ein komplettes Beispiel:

    class MyObject {
        String name = "hans";
        int age = 12;
        
        private String getName() {
            return name;
        }

        private int getAge() {
            return age;
        }
    }
        
    private void testfnc() {
        int foo;
        foo = 2;
        MyObject obj = new MyObject();
                
        switch(foo) {
            case 1: bar("getName", obj); break;
            case 2: bar("myAge", obj); break;
            default: break;
        }
    }
    
    private void bar(String choice, MyObject obj) {
        //do same thing on every choice

        switch(choice) {
            case "getName": System.out.println(obj.getName());
            case "getAge": System.out.println(obj.getAge());
            default: break;

        //do same thing on every choice
    }

Die letzte Methode möchte ich jetzt verkürzen und ersetzen mit:

    private void bar(String choice, MyObject obj) {
        System.out.println(obj.choice);
    }

Im Fall von Command Pattern müsste ich mir dann ja doch viele einzelne Methoden schreiben: printName(), printAge() usw.
Das wollte ich ja gerade vermeiden...

 

[bygones]

warum so kompliziert ???

    class MyObject {
        String name = "hans";
        int age = 12;
        
        private String getName() {
            return name;
        }

        private int getAge() {
            return age;
        }
    }
        
    private void testfnc() {
        int foo;
        foo = 2;
        MyObject obj = new MyObject();
                
        switch(foo) {
            case 1: System.out.println(obj.getName()); break;
            case 2: System.out.println(obj.getAge); break;
            default: break;
        }
    }

Im Fall von Command Pattern müsste ich mir dann ja doch viele einzelne Methoden schreiben: printName(), printAge() usw.
Das wollte ich ja gerade vermeiden...

nein. beim command pattern arbeitest du mit einer methode und die implementierungen sind dann die versch. Methoden

public interface MyObjectPrinter {
   public void print();
}

private void testfnc() {
        int foo;
        foo = 2;
        final MyObject obj = new MyObject();
                
        switch(foo) {
            case 1: new MyObjectPrinter() { 
                               public void print() { 
                                     System.out.println(obj.getName());
                               }
                         }
                       break;
           }
    }

 

[asdf1234]

Du kannst dir das Leben natürlich auch mit den Apache-Commons um einiges leichter machen

Stichwort: MethodUtils, BeanUtils

Wobei trotzdem die Frage bleibt: Willst du das wirklich? Du hast bis jetzt noch nichts gezeigt, das den Aufwand rechtfertig. Und mit Reflection holst du dir etliche Nachteile mit ins Boot. Besonders, wenn du noch wenig Ahnung davon hast.

Kurz gesagt: Reflection ist in Händen vo Profis ein enorm mächtiges Konzept und die Basis vieler fortgeschrittener Frameworks. Als Anfänger solltest du aber erstmal einen weiten Bogen drum machen und dir lieber überlegen, wie du die Probleme "ordentlich" lösen kannst. Denn Reflection ist kein Holzhammer, mit dem man drauf los drischt, wenn man als Anfänger nicht mehr weiter weiß.

 

[membersound]

warum so kompliziert ???

Schon klar, dass das Beispie deutlich einfacher zu realisieren wäre.
Aber mir gehts ja eben darum, den Methodennamen weiterzureichen, und anhand dessen die zugehörige Methode aufzurufen.

Ob der Aufwand sich lohnt ist eine andere Frage, aber ich mach das hier primär um zu lernen. Und da versuche ich halt die Dinge, die ich mir in den Kopf gesetzt habe, zu hinterfragen und Lösungen zu finden. Wie eben hier mit dem "methodennamen weiterreichen"...

 

[Antoras]

Aber mir gehts ja eben darum, den Methodennamen weiterzureichen, und anhand dessen die zugehörige Methode aufzurufen.

Macht in Java keinen Sinn. Das kann man in dynamisch typisierten Sprachen anwenden, aber nicht in Java.

Ob der Aufwand sich lohnt ist eine andere Frage, aber ich mach das hier primär um zu lernen.

Das einzige was man da lernt ist wie man es nicht machen sollte. Es funktioniert in Java nicht und fertig. Reflection ist nicht dazu gedacht dynamisch typisierte Programmierung mit Java-Code nachzubauen.

Wenn du Reflection lernen möchtest, dann versuche Java-Objekte zu serialisieren und aus serialisierten Informationen wieder Java-Objekte zu erstellen. Aber baue bitte keine dynamische Typisierung innerhalb von Java-Code nach.

 

[Spacerat]

Es funktioniert in Java nicht und fertig. Reflection ist nicht dazu gedacht dynamisch typisierte Programmierung mit Java-Code nachzubauen.

Das ja mal 'ne Aussage :lol:
Gerade weil man Reflections sehr gut dafür prostituieren kann, funktionierts eben doch. Aber zu welch' Dummheiten man sich hinreissen lässt, bleibt jedem selbst überlassen.
Frage an den TS: Das soll nicht zufällig ein Script-Interpreter bzw. Compiler werden? Bei einem solchen hatte ich zumindest mal ein ähnliches Problem und ich muss sagen... Vergiss es, mit dem CommandPattern hast definitiv mehr Erfolg.

import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;

public class CommandPatternTest
{
	private static final Map<String, Command<?>> commands;

	static
	{
		Map<String, Command<?>> tmp = new TreeMap<String, Command<?>>();
		tmp.put("getName", new Command<String>()
				{
			@Override
			public String execute(Object ... parameters)
			throws Throwable
			{
				return getName();
			}
		});
		tmp.put("getAge", new Command<Integer>()
				{
			@Override
			public Integer execute(Object ... parameters)
			throws Throwable
			{
				return getAge();
			}
		});
		commands = Collections.unmodifiableMap(tmp);
	}

	public static void main(String[] args)
	{
		if(args == null || args.length == 0) {
			args = new String[] {"getName", "getAge"};
		}
		for(String arg : args) {
			try {
				System.out.println(commands.get(arg).execute());
			} catch(Throwable e) {
				e.printStackTrace();
			}
		}
	}

	private static String getName()
	{
		return "Spacerat";
	}

	private static int getAge()
	{
		return 43;
	}
}

interface Command<T>
{
	T execute(Object ... parameters) throws Throwable;
}

Lass dich vom statischen Kontext jetzt nicht täuschen, der existiert nur im KSKB. Dieses Inteface ist so konzipiert, dass "untypisierte" Parameter übergeben und typisierte Rückgabewerte verwendet werden können. Vor dem Aufruf der jeweiligen "execute"-Methoden, lässt sich der übergebene String (z.B. eine Kommandozeile) noch parsen, wodurch man evtl. noch Parameter erhält. Der Phantasie sind recht wenig Grenzen gesetzt.

 

[Antoras]

Gerade weil man Reflections sehr gut dafür prostituieren kann, funktionierts eben doch.

Naja, kommt darauf an wie man "funktionieren" definiert. Man kann das auch in Assembler programmieren. Ob man das da aber auch Bug-frei hinbekommt ist eine andere Sache.

Viel wichtiger ob es funktioniert oder nicht, dürfte aber sein, dass wir uns hier im Anfängerforum befinden. Jemand, der weiß wie er mit den ihm gegebenen Möglichkeiten umgeht, würde hier nicht nachfragen. Dem TO hingegen ist mehr geholfen wenn man ihm sagt wie er seine Ziele möglichst geschickt und fehlerfrei erreichen kann. Auf die "hidden features" kommt er schon noch früh genug und dann wird er auch damit umgehen können.

 

[bygones]

oder warte bis java8, dann kennt java auch die lambda expressions und du kannst genau das tun was du hier willst ;-)

 

[membersound]

Bis Ende 2012 warten :autsch:
Klingt brauchbar