L'interface fonctionnelle est une interface qui n'a qu'une seule méthode abstraite, mais peut avoir plusieurs méthodes non abstraites.
Les interfaces fonctionnelles peuvent être implicitement converties en expressions de lambda.
Les interfaces fonctionnelles peuvent prendre en charge les Lambdas conviviales par les fonctions existantes.
introduire
Les interfaces fonctionnelles sont en fait une classe d'interface abstraite. Les interfaces fonctionnelles suivantes ont été trouvées avant Java 8.
java.lang.runnablejava.util.concurrent.callablejava.util.
etc...
Comment utiliser
En fait, la classe d'interface mentionnée ci-dessus ne doit être modifiée qu'avec l'annotation FunctionalInterface, et devient une interface fonctionnelle en Java. Par exemple, la définition de l'interface appelée dans JDK
@FunctionalInterFacePublic Interface Calable <v> {v Call () lève une exception;}C'est aussi simple que cela.
Parlons maintenant de la nouvelle interface de fonction ajoutée à Java 8. Voici sa définition
// t est le paramètre entrant // r est le paramètre de retour @FunctionalInterFacePublic Interface Fonction <T, R> {r Apply (t t); Default <v> fonction <v, r> compose (fonction <? Super V ,? étend t> avant {objets.RequireNonnull (avant); return (v v) -> appliquer (avant.apply (v));} Default <v> fonction <t, v> et thern (function <? super r ,? étend v> after) {objets.requirelUll (after); return (t) - After) (t); } STATIC <T> Fonction <T, T> Identity () {return t -> T;Il peut être compris comme un pointeur de fonction dans le langage C (opinion personnelle).
En usage réel, la méthode d'application est largement utilisée. Compose / andThen est principalement utilisé dans des scénarios où plus de deux interfaces de fonction et séquence d'exécution sont effectuées.
Dans un code commercial spécifique, je l'utilise généralement en combinaison avec Bifuncton / Fournisseur. La bifonction prend en charge 2 paramètres, la fonction ne prend en charge qu'un seul paramètre. Le fournisseur peut être utilisé pour stocker des valeurs requises spécifiques et les faire passer.
exemple
Références au code sur lequel vous travaillez habituellement. Cet exemple évite principalement plusieurs conditions de jugement qui provoquent un code gonflé. Dans le même temps, la même logique métier peut être abstraite de l'interface de fonction, afin que le code puisse être réutilisé à plusieurs endroits. Le code spécifique est le suivant.
Fonction <objet, entier> actiontest1 = (objet) -> {// logic return 0;}; function <object, Integer> ActionTest2 = (objet) -> {// logic return 0;}; public fournisseur <map <Integer, fonction <objet, entier >>> ActionSUpplier = () Hashmap <> (); maps.put (1, actiontest1); maps.put (2, actiontest2); return maps;}; // Utiliser public void test (int type, objet objet) {facultatif.ofNullable (actionsupplier.get (). get (type)). ifpresent (x -> x.apply (v, objet)); // if / else logic if (type == 1) {// Test1 Logic} else if (type == 2) {// Test2 Logic}}Résumer
Personnellement, je crois que dans les scénarios où il y a plus de jugements sur les succursales logiques commerciales, il est plus adapté à utiliser la fonction et il y a les avantages suivants.
Exemple d'interface fonctionnelle
L'interface prédicat <t> est une interface fonctionnelle qui accepte un paramètre d'entrée T et renvoie un résultat booléen.
Cette interface contient une variété de méthodes par défaut pour combiner le prédicat dans d'autres logiques complexes (telles que: contre, ou non).
Cette interface est utilisée pour tester l'objet est vrai ou faux.
Nous pouvons comprendre l'utilisation du prédicat d'interface fonctionnelle <T> via l'exemple suivant (java8teter.java):
Java8Tester.Java Fichier Importer Java.util.arrays; Importer java.util.list; import java.util.function.predicate; classe publique Java8Tester {public static void main (String args []) {list <Integer> list = arrays.aslist (1, 2, 3, 4, 5, 6, 7, 8, 9); // Predicat <Integer> Predicat = n -> true // n est une méthode de test qui transmet des arguments à l'interface du prédicat // n s'il y en a, la méthode de test renvoie True System.out.println ("Out toutes les données:"); // passe le paramètre n eval (list, n-> true); // Predicat <Integer> Predict1 = n -> n% 2 == 0 // n est une méthode de test qui passe le paramètre à l'interface du prédicat // Si n% 2 est 0 la méthode de test renvoie True System.out.println ("out tous les nombres:"); eval (list, n-> n% 2 == 0); // Predicat <Integer> Predict2 = n -> n> 3 // n est une méthode de test qui transmet le paramètre à l'interface de prédicat // Si n est supérieur à 3 que la méthode de test renvoie True System.out.println ("Sortir tous les nombres supérieurs à 3:"); eval (list, n-> n> 3); } public static void eval (list <Integer> list, Predicate <Integer> prédite) {for (Integer n: list) {if (predicate.test (n)) {System.out.println (n + ""); }}}}Exécuter le script ci-dessus et le résultat de sortie est:
$ javac java8teter.java
$ java java8teter
Sortir toutes les données:
1
2
3
4
5
6
7
8
9
Sortir tous les nombres uniformes:
2
4
6
8
Sortie tous les nombres supérieurs à 3:
4
5
6
7
8
9
Résumer
Ce qui précède est l'interface fonctionnelle de la fonction Java 8 et les exemples d'interface fonctionnelle introduits par l'éditeur. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez me laisser un message et l'éditeur répondra à tout le monde à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!