Was ist der nächste Ersatz für einen Funktionszeiger in Java?

Ich habe eine Methode, die ungefähr zehn Codezeilen umfasst. Ich möchte mehr Methoden erstellen, die genau dasselbe tun, mit Ausnahme einer kleinen Berechnung, die eine Codezeile ändert. Dies ist eine perfekte Anwendung zum Übergeben eines Funktionszeigers, um diese eine Zeile zu ersetzen, aber Java verfügt nicht über Funktionszeiger. Was ist meine beste Alternative?

Anonyme innere Klasse

StringAngenommen, Sie möchten eine Funktion mit einem Parameter übergeben, der ein zurückgibt int.
Zuerst müssen Sie eine Schnittstelle mit der Funktion als einzigem Mitglied definieren, wenn Sie eine vorhandene nicht wiederverwenden können.

interface StringFunction {
    int func(String param);
}

Eine Methode, die den Zeiger verwendet, würde nur eine StringFunctionInstanz wie folgt akzeptieren :

public void takingMethod(StringFunction sf) {
   int i = sf.func("my string");
   // do whatever ...
}

Und würde so heißen:

ref.takingMethod(new StringFunction() {
    public int func(String param) {
        // body
    }
});

EDIT: In Java 8 können Sie es mit einem Lambda-Ausdruck aufrufen:

ref.takingMethod(param -> bodyExpression);

Für jeden "Funktionszeiger" würde ich eine kleine Funktorklasse erstellen , die Ihre Berechnung implementiert. Definieren Sie eine Schnittstelle, die von allen Klassen implementiert wird, und übergeben Sie Instanzen dieser Objekte an Ihre größere Funktion. Dies ist eine Kombination aus " Befehlsmuster " und " Strategiemuster ".

@ sblundys Beispiel ist gut.

Wenn es eine vordefinierte Anzahl verschiedener Berechnungen gibt, die Sie in dieser einen Zeile ausführen können, ist die Verwendung einer Aufzählung eine schnelle und dennoch klare Möglichkeit, ein Strategiemuster zu implementieren.

public enum Operation {
    PLUS {
        public double calc(double a, double b) {
            return a + b;
        }
    },
    TIMES {
        public double calc(double a, double b) {
            return a * b;
        }
    }
     ...

     public abstract double calc(double a, double b);
}

Offensichtlich sind die Strategie-Methodendeklaration sowie genau eine Instanz jeder Implementierung in einer einzigen Klasse / Datei definiert.

Sie müssen eine Schnittstelle erstellen, die die Funktion (en) bereitstellt, die Sie weitergeben möchten. z.B:

/**
 * A simple interface to wrap up a function of one argument.
 * 
 * @author rcreswick
 *
 */
public interface Function1<S, T> {

   /**
    * Evaluates this function on it's arguments.
    * 
    * @param a The first argument.
    * @return The result.
    */
   public S eval(T a);

}

Wenn Sie dann eine Funktion übergeben müssen, können Sie diese Schnittstelle implementieren:

List<Integer> result = CollectionUtilities.map(list,
        new Function1<Integer, Integer>() {
           @Override
           public Integer eval(Integer a) {
              return a * a;
           }
        });

Schließlich verwendet die Kartenfunktion die in Funktion1 übergebene wie folgt:

   public static <K,R,S,T> Map<K, R> zipWith(Function2<R,S,T> fn, 
         Map<K, S> m1, Map<K, T> m2, Map<K, R> results){
      Set<K> keySet = new HashSet<K>();
      keySet.addAll(m1.keySet());
      keySet.addAll(m2.keySet());

      results.clear();

      for (K key : keySet) {
         results.put(key, fn.eval(m1.get(key), m2.get(key)));
      }
      return results;
   }

Sie können Runnable häufig anstelle Ihrer eigenen Schnittstelle verwenden, wenn Sie keine Parameter übergeben müssen, oder Sie können verschiedene andere Techniken verwenden, um die Anzahl der Parameter weniger "fest" zu machen, aber dies ist normalerweise ein Kompromiss mit der Typensicherheit. (Oder Sie können den Konstruktor überschreiben, damit Ihr Funktionsobjekt die Parameter auf diese Weise übergibt. Es gibt viele Ansätze, und einige funktionieren unter bestimmten Umständen besser.)

Methodenreferenzen mit dem ::Operator

Sie können Methodenreferenzen in Methodenargumenten verwenden, bei denen die Methode eine funktionale Schnittstelle akzeptiert . Eine funktionale Schnittstelle ist eine Schnittstelle, die nur eine abstrakte Methode enthält. (Eine funktionale Schnittstelle kann eine oder mehrere Standardmethoden oder statische Methoden enthalten.)

IntBinaryOperatorist eine funktionale Schnittstelle. Seine abstrakte Methode applyAsIntakzeptiert zwei ints als Parameter und gibt ein zurück int. Math.maxakzeptiert auch zwei ints und gibt ein zurück int. In diesem Beispiel werden A.method(Math::max);die parameter.applyAsIntbeiden Eingabewerte an gesendet Math.maxund das Ergebnis zurückgegeben Math.max.

import java.util.function.IntBinaryOperator;

class A {
    static void method(IntBinaryOperator parameter) {
        int i = parameter.applyAsInt(7315, 89163);
        System.out.println(i);
    }
}

import java.lang.Math;

class B {
    public static void main(String[] args) {
        A.method(Math::max);
    }
}

Im Allgemeinen können Sie Folgendes verwenden:

method1(Class1::method2);

anstatt:

method1((arg1, arg2) -> Class1.method2(arg1, arg2));

das ist die Abkürzung für:

method1(new Interface1() {
    int method1(int arg1, int arg2) {
        return Class1.method2(arg1, agr2);
    }
});

Weitere Informationen finden Sie unter Operator :: (Doppelpunkt) in Java 8 und Java Language Specification §15.13 .

Sie können dies auch tun (was in einigen seltenen Fällen sinnvoll ist). Das Problem (und es ist ein großes Problem) ist, dass Sie die Sicherheit einer Klasse / Schnittstelle verlieren und sich mit dem Fall befassen müssen, in dem die Methode nicht vorhanden ist.

Es hat den "Vorteil", dass Sie Zugriffsbeschränkungen ignorieren und private Methoden aufrufen können (im Beispiel nicht gezeigt, aber Sie können Methoden aufrufen, die der Compiler normalerweise nicht aufrufen lässt).

Auch hier ist es selten, dass dies sinnvoll ist, aber in diesen Fällen ist es ein gutes Werkzeug.

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Main
{
    public static void main(final String[] argv)
        throws NoSuchMethodException,
               IllegalAccessException,
               IllegalArgumentException,
               InvocationTargetException
    {
        final String methodName;
        final Method method;
        final Main   main;

        main = new Main();

        if(argv.length == 0)
        {
            methodName = "foo";
        }
        else
        {
            methodName = "bar";
        }

        method = Main.class.getDeclaredMethod(methodName, int.class);

        main.car(method, 42);
    }

    private void foo(final int x)
    {
        System.out.println("foo: " + x);
    }

    private void bar(final int x)
    {
        System.out.println("bar: " + x);
    }

    private void car(final Method method,
                     final int    val)
        throws IllegalAccessException,
               IllegalArgumentException,
               InvocationTargetException
    {
        method.invoke(this, val);
    }
}

Wenn Sie nur eine andere Zeile haben, können Sie einen Parameter wie ein Flag und eine if (flag) -Anweisung hinzufügen, die die eine oder andere Zeile aufruft.

Vielleicht möchten Sie auch etwas über die Arbeit an Java 7 erfahren, bei der es um Schließungen geht:

Wie ist der aktuelle Stand der Schließungen in Java?

http://gafter.blogspot.com/2006/08/closures-for-java.html
http://tech.puredanger.com/java7/#closures

Neue Java 8- Funktionsschnittstellen und Methodenreferenzen mit dem ::Operator.

Java 8 kann Methodenreferenzen (MyClass :: new) mit Zeigern " @ Functional Interface " verwalten. Es ist nicht derselbe Methodenname erforderlich, sondern nur die gleiche Methodensignatur.

Beispiel:

@FunctionalInterface
interface CallbackHandler{
    public void onClick();
}

public class MyClass{
    public void doClick1(){System.out.println("doClick1");;}
    public void doClick2(){System.out.println("doClick2");}
    public CallbackHandler mClickListener = this::doClick;

    public static void main(String[] args) {
        MyClass myObjectInstance = new MyClass();
        CallbackHandler pointer = myObjectInstance::doClick1;
        Runnable pointer2 = myObjectInstance::doClick2;
        pointer.onClick();
        pointer2.run();
    }
}

Also, was haben wir hier?

1. Funktionsschnittstelle - Dies ist eine Schnittstelle, die mit @FunctionalInterface kommentiert ist oder nicht , die nur eine Methodendeklaration enthält.
2. Methodenreferenzen - Dies ist nur eine spezielle Syntax. Sieht so aus: objectInstance :: methodName , nicht mehr und nicht weniger.
3. Anwendungsbeispiel - nur ein Zuweisungsoperator und dann ein Aufruf der Schnittstellenmethode.

SIE SOLLTEN NUR FÜR LISTENER FUNKTIONALE SCHNITTSTELLEN UND NUR FÜR DIESE VERWENDEN!

Weil alle anderen derartigen Funktionszeiger für die Lesbarkeit des Codes und die Fähigkeit zum Verstehen wirklich schlecht sind. Direkte Methodenreferenzen sind jedoch manchmal nützlich, beispielsweise bei foreach.

Es gibt mehrere vordefinierte funktionale Schnittstellen:

Runnable              -> void run( );
Supplier<T>           -> T get( );
Consumer<T>           -> void accept(T);
Predicate<T>          -> boolean test(T);
UnaryOperator<T>      -> T apply(T);
BinaryOperator<T,U,R> -> R apply(T, U);
Function<T,R>         -> R apply(T);
BiFunction<T,U,R>     -> R apply(T, U);
//... and some more of it ...
Callable<V>           -> V call() throws Exception;
Readable              -> int read(CharBuffer) throws IOException;
AutoCloseable         -> void close() throws Exception;
Iterable<T>           -> Iterator<T> iterator();
Comparable<T>         -> int compareTo(T);
Comparator<T>         -> int compare(T,T);

Für frühere Java-Versionen sollten Sie Guava-Bibliotheken ausprobieren, die ähnliche Funktionen und Syntax haben, wie Adrian Petrescu oben erwähnt hat.

Weitere Informationen finden Sie im Java 8 Cheatsheet

und danke an The Guy with The Hat für die Java-Sprachspezifikation §15.13 Link.

Die Antwort von @ sblundy ist großartig, aber anonyme innere Klassen weisen zwei kleine Fehler auf, wobei der primäre darin besteht, dass sie nicht wiederverwendbar sind und der sekundäre eine umfangreiche Syntax ist.

Das Schöne ist, dass sein Muster ohne Änderung in der Hauptklasse (die die Berechnungen durchführt) zu vollständigen Klassen erweitert wird.

Wenn Sie eine neue Klasse instanziieren, können Sie Parameter an diese Klasse übergeben, die als Konstanten in Ihrer Gleichung fungieren können. Wenn also eine Ihrer inneren Klassen so aussieht:

f(x,y)=x*y

aber manchmal brauchen Sie eine, die ist:

f(x,y)=x*y*2

und vielleicht ein dritter:

f(x,y)=x*y/2

Anstatt zwei anonyme innere Klassen zu erstellen oder einen "Passthrough" -Parameter hinzuzufügen, können Sie eine einzelne ACTUAL-Klasse erstellen, die Sie instanziieren als:

InnerFunc f=new InnerFunc(1.0);// for the first
calculateUsing(f);
f=new InnerFunc(2.0);// for the second
calculateUsing(f);
f=new InnerFunc(0.5);// for the third
calculateUsing(f);

Es würde einfach die Konstante in der Klasse speichern und sie in der in der Schnittstelle angegebenen Methode verwenden.

Wenn Sie wissen, dass Ihre Funktion nicht gespeichert / wiederverwendet wird, können Sie Folgendes tun:

InnerFunc f=new InnerFunc(1.0);// for the first
calculateUsing(f);
f.setConstant(2.0);
calculateUsing(f);
f.setConstant(0.5);
calculateUsing(f);

Aber unveränderliche Klassen sind sicherer - ich kann keine Rechtfertigung dafür finden, eine Klasse wie diese veränderlich zu machen.

Ich poste das wirklich nur, weil ich zusammenzucke, wenn ich anonyme innere Klasse höre - ich habe viel redundanten Code gesehen, der "Erforderlich" war, weil der Programmierer als erstes anonym ging, wenn er eine tatsächliche Klasse hätte verwenden sollen und niemals überlegte seine Entscheidung.

Die Google Guava-Bibliotheken , die immer beliebter werden, verfügen über ein generisches Funktions- und Prädikatobjekt , das sie in vielen Teilen ihrer API bearbeitet haben.

Klingt für mich nach einem Strategiemuster. Schauen Sie sich die Java-Muster von fluffycat.com an.

Eines der Dinge, die ich beim Programmieren in Java wirklich vermisse, sind Funktionsrückrufe. Eine Situation, in der sich die Notwendigkeit für diese immer wieder zeigte, war die rekursive Verarbeitung von Hierarchien, in denen Sie für jedes Element eine bestimmte Aktion ausführen möchten. Zum Beispiel durch einen Verzeichnisbaum gehen oder eine Datenstruktur verarbeiten. Der Minimalist in mir hasst es, eine Schnittstelle und dann eine Implementierung für jeden speziellen Fall definieren zu müssen.

Eines Tages fragte ich mich, warum nicht? Wir haben Methodenzeiger - das Methodenobjekt. Mit der Optimierung von JIT-Compilern bringt der reflektierende Aufruf keine großen Leistungseinbußen mehr mit sich. Abgesehen davon, dass beispielsweise eine Datei von einem Speicherort an einen anderen kopiert wird, sind die Kosten für den Aufruf der reflektierten Methode unbedeutend.

Als ich mehr darüber nachdachte, wurde mir klar, dass ein Rückruf im OOP-Paradigma das Zusammenbinden eines Objekts und einer Methode erfordert - geben Sie das Rückrufobjekt ein.

Schauen Sie sich meine reflexionsbasierte Lösung für Rückrufe in Java an . Kostenlos für jede Verwendung.

OK, dieser Thread ist bereits alt genug, daher ist meine Antwort sehr wahrscheinlich nicht hilfreich für die Frage. Aber da dieser Thread mir geholfen hat, meine Lösung zu finden, werde ich ihn trotzdem hier veröffentlichen.

Ich musste eine variable statische Methode mit bekannter Eingabe und bekannter Ausgabe (beide doppelt ) verwenden. Wenn ich also das Methodenpaket und den Namen kenne, könnte ich wie folgt arbeiten:

java.lang.reflect.Method Function = Class.forName(String classPath).getMethod(String method, Class[] params);

für eine Funktion, die ein Double als Parameter akzeptiert.

Also habe ich es in meiner konkreten Situation mit initialisiert

java.lang.reflect.Method Function = Class.forName("be.qan.NN.ActivationFunctions").getMethod("sigmoid", double.class);

und rief es später in einer komplexeren Situation mit

return (java.lang.Double)this.Function.invoke(null, args);

java.lang.Object[] args = new java.lang.Object[] {activity};
someOtherFunction() + 234 + (java.lang.Double)Function.invoke(null, args);

wobei Aktivität ein beliebiger Doppelwert ist. Ich denke darüber nach, dies vielleicht etwas abstrakter zu machen und zu verallgemeinern, wie es SoftwareMonkey getan hat, aber derzeit bin ich mit dem, was es ist, zufrieden genug. Drei Codezeilen, keine Klassen und Schnittstellen erforderlich, das ist nicht schlecht.

So machen Sie dasselbe ohne Schnittstellen für eine Reihe von Funktionen:

class NameFuncPair
{
    public String name;                // name each func
    void   f(String x) {}              // stub gets overridden
    public NameFuncPair(String myName) { this.name = myName; }
}

public class ArrayOfFunctions
{
    public static void main(String[] args)
    {
        final A a = new A();
        final B b = new B();

        NameFuncPair[] fArray = new NameFuncPair[]
        {
            new NameFuncPair("A") { @Override void f(String x) { a.g(x); } },
            new NameFuncPair("B") { @Override void f(String x) { b.h(x); } },
        };

        // Go through the whole func list and run the func named "B"
        for (NameFuncPair fInstance : fArray)
        {
            if (fInstance.name.equals("B"))
            {
                fInstance.f(fInstance.name + "(some args)");
            }
        }
    }
}

class A { void g(String args) { System.out.println(args); } }
class B { void h(String args) { System.out.println(args); } }

Schauen Sie sich Lambdaj an

http://code.google.com/p/lambdaj/

und insbesondere seine neue Verschlussfunktion

http://code.google.com/p/lambdaj/wiki/Closures

und Sie werden eine sehr lesbare Möglichkeit finden, einen Abschluss oder einen Funktionszeiger zu definieren, ohne eine bedeutungslose Schnittstelle zu erstellen oder hässliche innere Klassen zu verwenden

Wow, warum nicht einfach eine Delegate-Klasse erstellen, die nicht allzu schwer ist, da ich dies bereits für Java getan habe, und damit Parameter übergeben, bei denen T der Rückgabetyp ist. Es tut mir leid, aber als C ++ / C # -Programmierer im Allgemeinen, der gerade Java lernt, brauche ich Funktionszeiger, weil sie sehr praktisch sind. Wenn Sie mit einer Klasse vertraut sind, die sich mit Methodeninformationen befasst, können Sie dies tun. In Java-Bibliotheken wäre das java.lang.reflect.method.

Wenn Sie immer eine Schnittstelle verwenden, müssen Sie diese immer implementieren. Bei der Ereignisbehandlung gibt es keinen besseren Weg, um sich von der Liste der Handler zu registrieren / die Registrierung aufzuheben, als für Delegaten, bei denen Sie Funktionen und nicht den Werttyp übergeben müssen, sodass eine Delegatenklasse diese für Outclasses einer Schnittstelle handhabt.

Keine der Java 8-Antworten hat ein vollständiges, zusammenhängendes Beispiel gegeben.

Deklarieren Sie die Methode, die den "Funktionszeiger" akzeptiert, wie folgt:

void doCalculation(Function<Integer, String> calculation, int parameter) {
    final String result = calculation.apply(parameter);
}

Rufen Sie es auf, indem Sie der Funktion einen Lambda-Ausdruck geben:

doCalculation((i) -> i.toString(), 2);

Wenn jemand Schwierigkeiten hat, eine Funktion zu übergeben, die einen Parametersatz benötigt, um ihr Verhalten zu definieren, aber einen anderen Parametersatz, der ausgeführt werden soll, wie z.

(define (function scalar1 scalar2)
  (lambda (x) (* x scalar1 scalar2)))

Siehe Übergabe der Funktion mit parameterdefiniertem Verhalten in Java

Seit Java8 können Sie Lambdas verwenden, die auch Bibliotheken in der offiziellen SE 8-API enthalten.

Verwendung: Sie müssen eine Schnittstelle mit nur einer abstrakten Methode verwenden. Erstellen Sie eine Instanz davon (möglicherweise möchten Sie die bereits bereitgestellte Java SE 8 verwenden) wie folgt:

Function<InputType, OutputType> functionname = (inputvariablename) {
... 
return outputinstance;
}

Weitere Informationen finden Sie in der Dokumentation: https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Vor Java 8 war eine anonyme Klasse der nächste Ersatz für funktionszeigerähnliche Funktionen. Zum Beispiel:

Collections.sort(list, new Comparator<CustomClass>(){
    public int compare(CustomClass a, CustomClass b)
    {
        // Logic to compare objects of class CustomClass which returns int as per contract.
    }
});

Aber jetzt haben wir in Java 8 eine sehr nette Alternative, die als Lambda-Ausdruck bekannt ist und verwendet werden kann als:

list.sort((a, b) ->  { a.isBiggerThan(b) } );

Dabei ist isBiggerThan eine Methode in CustomClass. Wir können hier auch Methodenreferenzen verwenden:

list.sort(MyClass::isBiggerThan);