Nouvelles interfaces fonctionnelles et références de méthode Java 8 à l'aide de l' ::
opérateur.
Java 8 est capable de maintenir des références de méthode (MyClass :: new) avec des pointeurs " @ Functional Interface ". Il n'y a pas besoin du même nom de méthode, seule la même signature de méthode est requise.
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();
}
}
Alors, qu'est-ce que nous avons ici?
- Interface fonctionnelle - il s'agit d'une interface, annotée ou non avec @FunctionalInterface , qui ne contient qu'une seule déclaration de méthode.
- Références de méthode - ceci est juste une syntaxe spéciale, ressemble à ceci, objectInstance :: methodName , rien de plus rien de moins.
- Exemple d'utilisation - juste un opérateur d'affectation puis un appel de méthode d'interface.
VOUS DEVEZ UTILISER DES INTERFACES FONCTIONNELLES POUR LES AUDITEURS UNIQUEMENT ET UNIQUEMENT POUR CELA!
Parce que tous les autres pointeurs de fonction sont vraiment mauvais pour la lisibilité du code et pour la capacité de comprendre. Cependant, les références de méthode directes sont parfois utiles, avec foreach par exemple.
Il existe plusieurs interfaces fonctionnelles prédéfinies:
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 les versions antérieures de Java, vous devriez essayer les bibliothèques de goyave, qui ont des fonctionnalités et une syntaxe similaires, comme Adrian Petrescu l'a mentionné ci-dessus.
Pour plus de recherche, regardez Java 8 Cheatsheet
et merci à The Guy with The Hat pour le lien §15.13 du Java Language Specification .