Funktion aus array aufrufen

[guni]

Hallo,

ich möchte (muss) ein Java Programm schreiben, dem man als Kommandozeilenparameter den Namen der aufzurufenden Methode übergeben kann!

gibts da eine schöne möglichkeit?

evtl. plane ich auch, meine Methode in ein Array zu schreiben; sthg. like:

<?> methodarray = new <?>[]{
    Methode1,
    Methode2,
    Methode3,
    Methode4,
    Methode5,
    Methode6,
    Methode7,
    Methode8,
    Methode9,
    Methode10,
}

dann möchte ich das array im code so aufrufen können:

foreach(<?> method : methodarray){
    method(param_1, ... param_n)
}

in der Perl Welt ist das kein Problem - ich hatte damit die Möglichkeiten, dass sie Methoden in der Datenbank "registrieren" und von "fremden" Klassen aufrufen zu lassen ;-)

wie könnte ich das in JAVA umsetzen?
gibt es hier function pointer oder sowas nettes???

mfg, guni

 

[Der Müde Joe]

Reflection

http://wiklet.javacore.de/index.php/Reflection_-_Die_Java_Reflection_API
http://java.sun.com/docs/books/tutorial/reflect/

..oder wilde if else abfragen

 

[maki]

ich möchte (muss) ein Java Programm schreiben, dem man als Kommandozeilenparameter den Namen der aufzurufenden Methode übergeben kann!

Methode schön und gut, hoffe dass das Objekt zumindest feststeht zu der die Methode gehört.

Mit reflection geht das, aber "schön" ist anders.

evtl. plane ich auch, meine Methode in ein Array zu schreiben; sthg. like:

Methoden in Arrays???
Methoden gehören zu Objekten, zumindest zu Klassen, kannst dir ja das Strategy Muster ansehen.

gibt es hier function pointer oder sowas nettes???

Natürlich nicht, das gibt es bei primitiven (und) manchen Scriptsprachen

Darf man fragen wie man auf so etwas kommt?
klingt sehr sehr schräg.

 

[SlaterB]

man kann sich auch auf eine Methode einigen,
und nur verschiedene Objekte zu anonymen inneren Klassen haben, die dann die eigentliche Aufgabe übernehmen:

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        Worker a = new Worker()
            {
                public void work()
                {
                    System.out.println("Huhu");
                }
            };
        Worker b = new Worker()
            {
                public void work()
                {
                    System.out.println(5 + 5);
                }
            };

        Map<String, Worker> map = new HashMap<String, Worker>();
        map.put("x", a);
        map.put("y", b);


        String parameter = "y";
        map.get(parameter).work();

        for (Worker w : map.values())
        {
            w.work();
        }
    }
}

interface Worker
{
    public void work();
}

als Parameter ginge ein beliebiges Object oder Object[]

 

[Leroy42]

gibt es hier function pointer oder sowas nettes???

Natürlich nicht, das gibt es bei primitiven (und) manchen Scriptsprachen

:shock:
C z.B. ist weder primitiv noch 'ne Scriptsprache!

(mögen tue ich C jedoch dennoch nicht...)

 

[maki]

Naja, C ist zwar auch eine Hochsprache, aber eine primitive *g*

 

[Leroy42]

LOL!

:toll:

 

[ARadauer]

sind funktions paointer nicht geplant?
mit javascript hab ich da schon manchmal sehr perverse sachen getrieben ;-)

ich setz in java bei sochen sachen oft das command pattern ein, aber das ist eh das was SlaterB da zeigt....

 

[Leroy42]

sind funktions paointer nicht geplant?
mit javascript hab ich da schon manchmal sehr perverse sachen getrieben ;-)

Für Java nicht; sind auch unnötig!

ich hab einen Avatar!

Sollte das nicht eher heißen:

ich hab heute schon einen sitzen!

 

[Janus]

interface Func
{
  doStuff( Object... args );
}

Func[] arr = usw.

for( Func func : arr )
   func.doStuff( args );

oder so in der art

 

[guni]

Hallo,

hatte grad 2 Tage Auszeit an meinem "Projekt" und sehe, dass die meisten von euch dahingehend argumentieren, für jede Methode ein eigenes Objekt zu erstellen um der main dann ein Objekt als Parameter zu übergeben ...
na ja - ich werd mein Problem mal konkeretisieren.

Mein Programm rufe ich auf mit

java -jar programm.jar parameter_1, ... ,parameter_n

wobei parameter_1 die gewünschte Methode sein soll und parameter_2 - parameter_n dann die parameter, die der Methode übergeben werden.
d.h. in der main / meinem Konstruktor soll dann nur mehr stehen:

parameter_1(parameter_2, ... ,parameter_n);

je nach Namen des parameter_1 soll dann die richtige Funktion aufgerufen werden ...

versteht ihr, was ich meine?!
wie könnte ich das umsetzen? / gibt es eine schönere Lösung (bitte keine IF-Abfragen!!!)

lg, guni

 

[SlaterB]

deine Frage wurde erschöpfend beantwortet,
wenn mehr Möglichkeiten da wären, dann wären sie auch (ebenso mehrfach) genannt worden

 

[guni]

Hallo,

in einem eurer posts steht folgendes:

HashMap<String, Worker>();

da ich sehr verschiedene Objekte habe, erzeuge ich meine HashMap so:

HashMap<String,Object>();

allerdings weiß ich, dass jedes dieser Objekte das gleiche Interface implementiert ...
kann ich beim Festlegen meiner HashMap irgendwie sagen, dass ich meine Values auf Objects beschränken möchte, die dieses Interface implementieren?
d.h. irgendwas in der Form:

MashMap<String,Object implements someInterface>

weiß da wer weiter?
danke.

guni

 

[maki]

MashMap<String,SomeInterface>

 

[SlaterB]

MashMap ist gut

und muss es nicht
HashMap<String, ? extends MyInterface>();
sein?

 

[Beni]

Nein:

"HashMap<String,X>" ist eine HashMap die X's oder Unterklassen von X als Wert akzeptiert.

"HashMap<String, ? extends X>" ist eine HashMap von der man nicht weiss, was er jetzt genau akzeptiert. Man weiss nur, dass wenn man was von ihr liest, dass man dann mindestens ein X bekommt (schreibender Zugriff ist nicht möglich, da wir niemals ein ? erzeugen können).

 

[SlaterB]

wo ich wohl wieder war..
das kann man hier nur so gebrauchen und ist nicht soo relevant

public class Test
{
    public static void main(String[] args)
        throws Exception
    {
        Map<String, CoolWorker> map1 = new HashMap<String, CoolWorker>();
        letThemWork(map1);
    }

    public static void letThemWork(Map<String, ? extends Worker> map)
    {
        for (Worker w : map.values())
        {
            w.work();
        }
    }
}

interface Worker
{
    public void work();
}

interface CoolWorker
    extends Worker
{

}