Ce qui est le plus proche pour remplacer un pointeur de fonction en Java?

Anonyme intérieur de la classe

Dites que vous voulez avoir une fonction passés avec un String param qui renvoie un int.

Vous devez d'abord définir une interface avec la fonction en tant que seul membre, si vous ne pouvez pas réutiliser un existant.

interface StringFunction {
    int func(String param);
}

Une méthode qui prend le pointeur voudrais juste accepter StringFunction exemple comme ceci:

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

Et appelé de la sorte:

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

EDIT: Dans Java 8, vous pouvez l'appeler avec une expression lambda:

ref.takingMethod(param -> bodyExpression);

Quand il y a un nombre prédéfini de différents calculs que vous pouvez faire dans cette ligne, à l'aide d'un enum est un rapide, mais de façon claire afin de mettre en œuvre un modèle de stratégie.

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);
}

De toute évidence, la stratégie de la déclaration de la méthode, ainsi que exactement une instance de chaque mise en œuvre sont tous définis dans une classe unique/fichier.

Méthode des références à l'aide de la :: opérateur

Vous pouvez utiliser la méthode références de la méthode des arguments où la méthode accepte un interface fonctionnelle. Une interface fonctionnelle est une interface qui contient une seule méthode abstraite. (Une interface fonctionnelle peut contenir une ou plusieurs méthodes par défaut ou méthodes statiques.)

IntBinaryOperator est une interface fonctionnelle. Sa méthode abstraite, applyAsInt, accepte deux ints, ainsi que ses paramètres et renvoie un int. Math.max accepte également les deux ints et renvoie un int. Dans cet exemple, A.method(Math::max); fait parameter.applyAsInt envoyer ses deux valeurs d'entrée pour Math.max et de retourner le résultat de cette 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);
    }
}

En général, vous pouvez utiliser:

method1(Class1::method2);

au lieu de:

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

qui est l'abréviation de:

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

Pour plus d'informations, voir :: (deux points) opérateur en Java 8 et Java Langage De Spécification §15.13.

Si vous avez juste une ligne qui est différente, vous pourriez ajouter un paramètre comme un drapeau et d'un si(drapeau) déclaration qui appelle une ligne ou l'autre.

Java 8 Interfaces Fonctionnelles et Méthode des Références à l'aide de la :: opérateur.

Java 8 est en mesure de maintenir la méthode de référence ( MyClass::nouvelle ) avec "@ Interface Fonctionnelle" pointeurs. Il n'y a pas besoin pour le même nom de méthode, seulement même méthode de signature est nécessaire.

Exemple:

@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();
    }
}

Donc, ce que nous avons ici?

1. Interface fonctionnelle - c'est de l'interface, annoté ou non avec @FunctionalInterface, qui ne contient qu'une seule déclaration de la méthode.
2. Méthode des Références - c'est juste une syntaxe spéciale, ressemble à ceci, objectInstance::methodName, rien de plus rien de moins.
3. Exemple d'utilisation - il suffit d'un opérateur d'affectation et puis l'interface de l'appel de méthode.

VOUS DEVEZ UTILISER DES INTERFACES FONCTIONNELLES POUR LES AUDITEURS, ET UNIQUEMENT POUR ÇA!

Parce que tous les autres pointeurs de fonction sont vraiment mauvais pour la lisibilité du code et de la capacité à comprendre. Cependant, la méthode directe de références, parfois, viennent à portée de main, avec foreach par exemple.

Il y a plusieurs prédéfinis Interfaces Fonctionnelles:

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);

Pour d'anciennes versions de Java, vous devriez essayer de Goyave Bibliothèques, qui a les mêmes fonctionnalités, et de la syntaxe, comme Adrian Petrescu a mentionné ci-dessus.

Pour la recherche de regarder Java 8 Triche

et merci pour Le Gars avec Le Chapeau pour le Java Langage De Spécification §15.13 lien.

Google Goyave bibliothèques, qui sont en train de devenir très populaire, ont un générique La fonction et Prédicat objet qu'ils ont travaillé dans de nombreuses parties de leur API.

L'une des choses que j'ai vraiment manquer lors de la programmation en Java est fonction de rappels. Un exemple de situation où la nécessité pour ces gardé présenter elle-même était dans récursivement le traitement des hiérarchies où vous souhaitez effectuer des mesures précises pour chaque élément. Comme marcher sur une arborescence de répertoire, ou de la transformation d'une structure de données. Le minimaliste à l'intérieur de moi déteste avoir à définir une interface, puis une mise en œuvre pour chaque cas spécifique.

Un jour, je me demandais pourquoi pas? Nous avons pointeurs de méthode - la Méthode de l'objet. Avec l'optimisation des compilateurs JIT, réfléchissant à l'invocation n'a vraiment pas de réaliser un gain de performance énorme peine plus. Et d'ailleurs, à côté de, disons, la copie d'un fichier d'un emplacement à un autre, le coût de l'expression de l'invocation de méthode bien pâle dans l'insignifiance.

Comme je le pensais plus à ce sujet, j'ai réalisé qu'un rappel dans le paradigme de la programmation orientée objet nécessite une liaison d'un objet et une méthode d'ensemble - entrez l'objet de Rappel.

Découvrez ma réflexion à partir de la solution pour Rappels en Java. Gratuit pour toute utilisation.

De faire la même chose sans interfaces pour une multitude de fonctions:

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); } }

Wow, pourquoi ne pas simplement créer un Délégué de classe qui n'est pas si difficile étant donné que je l'ai déjà fait pour java et de l'utiliser pour passer en paramètre (où T est le type de retour. Je suis désolé, mais en tant que C++/C#, programmeur en général l'apprentissage de java, j'ai besoin de pointeurs de fonction parce qu'ils sont très pratique. Si vous êtes familier avec n'importe quelle classe qui traite de la Méthode d'Informations, vous pouvez le faire. Dans les bibliothèques java, qui serait celle de java.lang.de réfléchir.méthode.

Si vous utilisez toujours une interface, vous avez toujours à le mettre en œuvre. Dans eventhandling il n'y a vraiment pas de meilleure façon autour de l'inscription/désinscription de la liste de gestionnaires mais pour les délégués où vous devez passer dans les fonctions et non pas le type de la valeur, en faisant un délégué de classe pour gérer cela pour le surclasse une interface.

Si quelqu'un a de la difficulté à passer d'une fonction qui prend un ensemble de paramètres afin de définir son comportement, mais d'un autre ensemble de paramètres sur lequel exécuter, à l'instar du Régime:

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

voir Passer de la Fonction avec le Paramètre-Comportement Défini en Java

Avant Java 8, plus proche de substitution de la fonction pointeur de fonctions de type a une classe anonyme. Par exemple:

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.
    }
});

Mais maintenant dans Java 8, nous avons une très soigné alternative connu comme expression lambda, qui peut être utilisé comme:

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

où isBiggerThan est une méthode CustomClass. Nous pouvons également utiliser la méthode des références ici:

list.sort(MyClass::isBiggerThan);