Referenz auf Funktion?

[Samuel]

Ich konnte nichts genaures finden, aber schlecht gesucht ist immer eine Möglichkeit, daher frag ich zur sicherheit.

Ist es möglich in Java eine Referenz auf eine Funktion zu haben?

 

[Guest]

Nur über Reflection. Wenn du sowas wie die Delegates in C# suchst, dann findest du in Java nichts vergleichbares.
In Java löst man es eher durch Interfaces (Callback, Functor, Visitor).

 

[Samuel]

Ich such einen weg generisch eine Methode aufzurufen, ohne zu wissen welche Methode dies nun ist, quasi aus einem Pool von Methoden mit der gleichen Signatur nur mit einem anderen Namen

 

[Jango]

Delegates haben damit nichts zu tun. Die sind alle 'gebunden'.
Was du suchst, sind Generics (vergleichbar mit den 'Templates' von C++). Sie ermöglichen den Zugriff (zur Laufzeit) auf Datentypen, die zur Kompilierzeit noch nicht bekannt sind (Klassen, Strukturen, Schnittstellen (Interfaces) und Methoden).
Ich denke Java verfügt jetzt auch über Generics, weil doch sehr viel von C# abgeschaut wurde.
Such mal in der Richtung.

 

[Samuel]

Hallo,
ich weiß was generics sind, und die sind ja schon seit 1.5 mitbei, aber ich sehe den Zusammenhang zwischen generischen Methoden und Methoden Referenzen.
Generische Methoden ermöglichen zur Kompilierzeit unbekannte Rückgabewerte von Methode A, ich hab aber Methode A,B,C die ich einheitlich aufrufen will, ohne irgendwelche if Bedingungen oder ähnliches. Quasi
ref = methodeA
rufe ref auf
ref = methodeB
rufe ref auf.
Das ist vereinfacht, ziel ist es zu vermeiden noch Variablen über Zustände zu haben, wenn man direkt den Zustand nutzen kann (also die jeweilige Methode)

 

[Guest]

Wie ich schon schrieb, über Reflection geht es.
Schau dir die Klassen Class und Method an. Du kannst alle Methoden einer Klasse ermitteln und auch
alle Parameter der Methoden. Wenn du dir eine Art Signaturklasse baust, kannst du zu jedem beliebigen
Objekt nach Methoden mit der gewünschten Signatur suchen. Das brauchst du pro Klasse nur einmal
zu machen (intern einen Cache halten Class->Signatur) und beliebig oft wiederverwenden.

 

[Samuel]

Ok, also die gute alte Reflection

Danke

 

[ARadauer]

Ist es möglich in Java eine Referenz auf eine Funktion zu haben?

Ich verwende da immer das Command Pattern. Ich hab ein Interface, mit der Methode excecute und dann kann ich mir Commandos erstellen, die die entsprechende Methode über excecute ausführen.

Pool von Methoden mit der gleichen Signatur nur mit einem anderen Namen

passt doch perfekt, oder? eine Faktory die Commands zurück liefert

 

[Samuel]

Wie switcht du denn?

 

[Leroy42]

Gar nicht!

interface ExecI {public void exec();}
class E1 implements ExecI {public void exec() {System.out.print("Hallo ");}}
class E2 implements ExecI {public void exec() {System.out.print("Welt");}}

...
ExecI ex;
ex = new E1(); ex.exec();
ex = new E2(); ex.exec();

 

[Samuel]

N bisschen umständlich für 3 Methoden extra drei Klassen anzulegen, findest du nicht?

Und ich kenne dies nicht als Command pattern, sondern als simple polymorphie

 

[SlaterB]

es geht auch anonym:

ExecI ex;
ex = new ExecI() {
public void exec() {System.out.print("Hallo ");}
};
ex.exec();

und wenn die Alternative Reflection heißt, dann verbietet es sich, das Wort 'umständlich' zu benutzen

 

[Samuel]

Ich glaub ein Swith mit einem Enum ist wohl doch besser

 

[Beni]

Ich glaub ein Swith mit einem Enum ist wohl doch besser

Nur wenn du schon beim Compilieren alle Methoden kennst, die möglicherweise aufgerufen werden. Normalerweise ist der Weg mit den Interfaces flexibler, und damit im Endeffekt auch einfacher.

 

[Samuel]

Naja, das kann man sicherlich sehen, wie man will.
Ich finde es zum Beispiel nicht einfacher.
Ich habe drei Methoden in einer Klasse, diese nutzen Member der eigenen Klasse und bilden eine Objekteinheit.
Wenn ich die drei Methoden nun in Pseudoklassen werfe, muss ich denen auch noch Parameter übergeben, will ich was ändern, muss ich die Signaturen der Methoden, des Interfaces, des Aufrufs und der Implementierung ändern. Wenn die Methoden in der Klasse ändere, so muss ich nur deren Implementierung ändern und sonst nichts...

 

[Guest]

Hier eine kleine "Skizze", wie ich es oben mit der Signaturklasse gemeint habe.

public class Signature<TResultType>
{
   private Class<?> signature[];

   public Signature(Class<?> ... signature)
   {
      // Parameter prüfen (null als Klasse macht keinen Sinn, siehe *1)
      this.signature = signature;
   }

   public TResultType invoke(Object target, Object ... arguments)
   {
      ... Null-Check, Parameter-Check, Methode ermitteln, Ausführen
   }

   public boolean isApplicableTo(Object obj)
   {
      ... Null-Check, Methode ermitteln
   }

   ... interner Cache für die Signaturen bereits bekannter Klassen.
}

Verwendung

// *1 Signature<Void> s0 = new Signature<Void>(null); <-- Nicht zulassen
Signature<Void> s1 = new Signature<Void>(Integer.class);
Signature<Long> s2 = new Signature<Long>(Integer.class, String.class);
Signature<Void> s3 = new Signature<Void>();

Object obj1 = Class.forName("was.auch.Immer").newInstance();
Object obj2 = new Foo();

s1.invoke(obj1, 1);
s1.invoke(obj2, 2);

if(s2.isApplicableTo(obj1))
{
   Long result = s2.invoke(obj1, 1, "Test");
}

if(s3.isApplicableTo(obj2))
{
   s3.invoke(obj2);
}

 

[byte]

Ich habe drei Methoden in einer Klasse, diese nutzen Member der eigenen Klasse und bilden eine Objekteinheit.
Wenn ich die drei Methoden nun in Pseudoklassen werfe, muss ich denen auch noch Parameter übergeben, will ich was ändern, muss ich die Signaturen der Methoden, des Interfaces, des Aufrufs und der Implementierung ändern. Wenn die Methoden in der Klasse ändere, so muss ich nur deren Implementierung ändern und sonst nichts...

Nein. Du musst das Interface bloß anonym in der Klasse implementieren.
Wenn Du Dich mit Interfaces aber nicht anfreunden willst, dann rate ich Dir die Sprache zu wechseln. Denn Interfaces stellen ein - wenn nicht das - zentrale Konzept in Java dar.