Funktionszeiger in Java

Dies mag etwas Alltägliches und Triviales sein, aber ich scheine Schwierigkeiten zu haben, eine konkrete Antwort zu finden. In C# gibt es ein Konzept von Delegaten, das sich stark an die Idee von Funktionszeigern aus C++ anlehnt. Gibt es eine ähnliche Funktionalität in Java? Angesichts der Tatsache, dass Hinweise etwas fehlen, was ist der beste Weg, dies zu tun? Und um das klarzustellen, wir reden hier erstklassig.

Das Java-Idiom für funktionszeigerähnliche Funktionalität ist eine anonyme Klasse, die eine Schnittstelle implementiert, z

Collections.sort(list, new Comparator<MyClass>(){
    public int compare(MyClass a, MyClass b)
    {
        // compare objects
    }
});

Aktualisieren: Das Obige ist in Java-Versionen vor Java 8 erforderlich. Jetzt haben wir viel schönere Alternativen, nämlich Lambdas:

list.sort((a, b) -> a.isGreaterThan(b));

und Methodenreferenzen:

list.sort(MyClass::isGreaterThan);

Sie können einen Funktionszeiger durch eine Schnittstelle ersetzen. Angenommen, Sie möchten eine Sammlung durchlaufen und mit jedem Element etwas tun.

public interface IFunction {
  public void execute(Object o);
}

Dies ist die Schnittstelle, die wir beispielsweise an CollectionUtils2.doFunc(Collection c, IFunction f) übergeben könnten.

public static void doFunc(Collection c, IFunction f) {
   for (Object o : c) {
      f.execute(o);
   }
}

Als Beispiel sagen wir, wir haben eine Sammlung von Zahlen und Sie möchten zu jedem Element 1 hinzufügen.

CollectionUtils2.doFunc(List numbers, new IFunction() {
    public void execute(Object o) {
       Integer anInt = (Integer) o;
       anInt++;
    }
});

Sie können die Reflexion dazu verwenden.

Übergeben Sie als Parameter das Objekt und den Methodennamen (als Zeichenfolge) und rufen Sie dann die Methode auf. Beispielsweise:

Object methodCaller(Object theObject, String methodName) {
   return theObject.getClass().getMethod(methodName).invoke(theObject);
   // Catch the exceptions
}

Und dann verwenden Sie es wie in:

String theDescription = methodCaller(object1, "toString");
Class theClass = methodCaller(object2, "getClass");

Überprüfen Sie natürlich alle Ausnahmen und fügen Sie die erforderlichen Umwandlungen hinzu.

Nein, Funktionen sind keine erstklassigen Objekte in Java. Sie können dasselbe tun, indem Sie eine Handler-Klasse implementieren – so werden Callbacks in Swing usw. implementiert.

Es gibt jedoch Vorschläge für Schließungen (der offizielle Name für das, worüber Sie sprechen) in zukünftigen Versionen von Java – Javawelt hat einen interessanten Artikel.

Das erinnert an Steve Yegges Hinrichtung im Reich der Substantive. Es besagt im Grunde, dass Java für jede Aktion ein Objekt benötigt und daher keine „Nur-Verb“-Entitäten wie Funktionszeiger hat.

Um eine ähnliche Funktionalität zu erreichen, könnten Sie anonyme innere Klassen verwenden.

Wenn Sie eine Schnittstelle definieren würden Foo:

interface Foo {
    Object myFunc(Object arg);
}

Erstellen Sie eine Methode bar die einen ‘Funktionszeiger’ als Argument erhält:

public void bar(Foo foo) {
    // .....
    Object object = foo.myFunc(argValue);
    // .....
}

Rufen Sie die Methode schließlich wie folgt auf:

bar(new Foo() {
    public Object myFunc(Object arg) {
        // Function code.
    }
}

Java8 hat Lambdas und eingeführt Methodenreferenzen. Wenn Ihre Funktion also mit a übereinstimmt funktionale Schnittstelle (Sie können Ihre eigene erstellen) Sie können in diesem Fall eine Methodenreferenz verwenden.

Java bietet eine Reihe von gemeinsame Funktionsschnittstellen. während Sie Folgendes tun könnten:

public class Test {
   public void test1(Integer i) {}
   public void test2(Integer i) {}
   public void consumer(Consumer<Integer> a) {
     a.accept(10);
   }
   public void provideConsumer() {
     consumer(this::test1);   // method reference
     consumer(x -> test2(x)); // lambda
   }
}