À quoi servent les interfaces fonctionnelles dans Java 8?

Je suis tombé sur un nouveau terme en Java 8: "interface fonctionnelle". Je n'ai pu en trouver qu'une seule utilisation en travaillant avec des expressions lambda .

Java 8 fournit des interfaces fonctionnelles intégrées et si nous voulons définir une interface fonctionnelle, nous pouvons utiliser l' @FunctionalInterfaceannotation. Cela nous permettra de ne déclarer qu'une seule méthode dans l'interface.

Par exemple:

@FunctionalInterface
interface MathOperation {
    int operation(int a, int b);
}

Dans quelle mesure est-il utile dans Java 8 autre que de simplement travailler avec des expressions lambda ?

(La question ici est différente de celle que j'ai posée. Elle demande pourquoi nous avons besoin d'interfaces fonctionnelles tout en travaillant avec des expressions lambda. Ma question est: pourquoi d'autres utilisations des interfaces fonctionnelles ont-elles en plus des expressions lambda?)

@FunctionalInterfaceL'annotation est utile pour vérifier le temps de compilation de votre code. Vous ne pouvez pas avoir plus d'une méthode en plus static, defaultet des méthodes abstraites qui remplacent des méthodes Objectdans votre @FunctionalInterfaceinterface ou toute autre interface utilisée comme interface fonctionnelle.

Mais vous pouvez utiliser des lambdas sans cette annotation ainsi que vous pouvez remplacer des méthodes sans @Overrideannotation.

À partir de documents

une interface fonctionnelle a exactement une méthode abstraite. Puisque les méthodes par défaut ont une implémentation, elles ne sont pas abstraites. Si une interface déclare une méthode abstraite remplaçant l'une des méthodes publiques de java.lang.Object, cela ne compte pas non plus dans le nombre de méthodes abstraites de l'interface car toute implémentation de l'interface aura une implémentation de java.lang.Object ou ailleurs

Cela peut être utilisé dans l'expression lambda:

public interface Foo {
  public void doSomething();
}

Cela ne peut pas être utilisé dans l'expression lambda:

public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

Mais cela donnera une erreur de compilation :

@FunctionalInterface
public interface Foo {
  public void doSomething();
  public void doSomethingElse();
}

Annotation '@FunctionalInterface' non valide; Foo n'est pas une interface fonctionnelle

La documentation fait en effet une différence entre l'objectif

Un type d'annotation informatif utilisé pour indiquer qu'une déclaration de type d'interface est destinée à être une interface fonctionnelle telle que définie par la spécification du langage Java.

et le cas d'utilisation

Notez que les instances d'interfaces fonctionnelles peuvent être créées avec des expressions lambda, des références de méthode ou des références de constructeur.

dont la formulation n'exclut pas d'autres cas d'utilisation en général. Étant donné que l'objectif principal est d'indiquer une interface fonctionnelle , votre question réelle se résume à "Y a-t-il d'autres cas d'utilisation d' interfaces fonctionnelles autres que les expressions lambda et les références de méthode / constructeur?"

Étant donné que l'interface fonctionnelle est une construction de langage Java définie par la spécification du langage Java, seule cette spécification peut répondre à cette question:

JLS §9.8. Interfaces fonctionnelles :

…

En plus du processus habituel de création d'une instance d'interface en déclarant et en instanciant une classe (§15.9), des instances d'interfaces fonctionnelles peuvent être créées avec des expressions de référence de méthode et des expressions lambda (§15.13, §15.27).

Ainsi, la spécification du langage Java ne dit pas le contraire, le seul cas d'utilisation mentionné dans cette section est celui de la création d'instances d'interface avec des expressions de référence de méthode et des expressions lambda. (Cela inclut les références de constructeur car elles sont notées comme une forme d'expression de référence de méthode dans la spécification).

Donc, en une phrase, non, il n'y a pas d'autre cas d'utilisation pour Java 8.

Comme d'autres l'ont dit, une interface fonctionnelle est une interface qui expose une méthode. Il peut avoir plusieurs méthodes, mais toutes les autres doivent avoir une implémentation par défaut. La raison pour laquelle on l'appelle "interface fonctionnelle" est qu'elle agit effectivement comme une fonction. Puisque vous pouvez passer des interfaces en tant que paramètres, cela signifie que les fonctions sont désormais des «citoyens de premier ordre» comme dans les langages de programmation fonctionnels. Cela présente de nombreux avantages, et vous les verrez beaucoup lorsque vous utilisez l'API Stream. Bien sûr, les expressions lambda en sont la principale utilisation évidente.

Pas du tout. Les expressions Lambda sont le seul et unique point de cette annotation.

Une expression lambda peut être affectée à un type d'interface fonctionnelle, mais il en est de même pour les références de méthode et les classes anonymes.

Une bonne chose au sujet des interfaces fonctionnelles spécifiques java.util.functionest qu'ils peuvent être composés pour créer de nouvelles fonctions (comme Function.andThenet Function.compose, Predicate.and, etc.) en raison des méthodes par défaut pratiques qu'ils contiennent.

Une interface avec une seule méthode abstraite est appelée Interface fonctionnelle. Il n'est pas obligatoire d'utiliser @FunctionalInterface, mais il est recommandé de l'utiliser avec des interfaces fonctionnelles pour éviter l'ajout accidentel de méthodes supplémentaires. Si l'interface est annotée avec l'annotation @FunctionalInterface et que nous essayons d'avoir plus d'une méthode abstraite, cela génère une erreur du compilateur.

package com.akhi;
    @FunctionalInterface
    public interface FucnctionalDemo {

      void letsDoSomething();
      //void letsGo();      //invalid because another abstract method does not allow
      public String toString();    // valid because toString from Object 
      public boolean equals(Object o); //valid

      public static int sum(int a,int b)   // valid because method static
        {   
            return a+b;
        }
        public default int sub(int a,int b)   //valid because method default
        {
            return a-b;
        }
    }

Interface fonctionnelle:

• Introduit dans Java 8
• Interface qui contient une méthode "abstraite unique".

Exemple 1:

   interface CalcArea {   // --functional interface
        double calcArea(double rad);
    }           

Exemple 2:

interface CalcGeometry { // --functional interface
    double calcArea(double rad);
    default double calcPeri(double rad) {
        return 0.0;
    }
}       

Exemple 3:

interface CalcGeometry {  // -- not functional interface
    double calcArea(double rad);
    double calcPeri(double rad);
}   

Annotation Java8 - @FunctionalInterface

• Annotation vérifiez que l'interface ne contient qu'une seule méthode abstraite. Sinon, signalez l'erreur.
• Même si @FunctionalInterface manque, il s'agit toujours d'une interface fonctionnelle (si une seule méthode abstraite). L'annotation permet d'éviter les erreurs.
• L'interface fonctionnelle peut avoir des méthodes statiques et par défaut supplémentaires.
• Par exemple, Iterable <>, Comparable <>, Comparator <>.

Applications de l'interface fonctionnelle:

• Références de méthode
• Expression Lambda
• Références constructeurs

Pour apprendre les interfaces fonctionnelles, apprendre les premières méthodes par défaut dans l'interface, et après avoir appris l'interface fonctionnelle, il vous sera facile de comprendre la référence de méthode et l'expression lambda

Vous pouvez utiliser lambda dans Java 8

public static void main(String[] args) {
    tentimes(inputPrm - > System.out.println(inputPrm));
    //tentimes(System.out::println);  // You can also replace lambda with static method reference
}

public static void tentimes(Consumer myFunction) {
    for (int i = 0; i < 10; i++)
        myFunction.accept("hello");
}

Pour plus d'informations sur Java Lambdas et FunctionalInterfaces

@FunctionalInterface est une nouvelle annotation est publiée avec Java 8 et fournit des types de cible pour les expressions lambda et elle est utilisée lors de la vérification de la compilation de votre code.

Lorsque vous souhaitez l'utiliser:

1- Votre interface ne doit pas avoir plus d'une méthode abstraite, sinon une erreur de compilation sera donnée.

1- Votre interface doit être pure, ce qui signifie que l'interface fonctionnelle est destinée à être implémentée par des classes sans état, exmple de pure est Comparatorinterface car elle ne dépend pas de l'état de l'implémenteur, dans ce cas, aucune erreur de compilation ne sera donnée, mais dans de nombreux cas, vous ne pourra pas utiliser lambda avec ce genre d'interfaces

Le java.util.functionpaquet contient diverses interfaces fonctionnelles à usage général tels que Predicate, Consumer, Function, et Supplier.

Veuillez également noter que vous pouvez utiliser des lambdas sans cette annotation.

À côté d'autres réponses, je pense que la raison principale pour "pourquoi utiliser l'interface fonctionnelle autrement qu'avec des expressions lambda" peut être liée à la nature du langage Java qui est orienté objet.

Les principaux attributs des expressions Lambda sont: 1. Ils peuvent être transmis 2. et ils peuvent être exécutés à l'avenir à un moment précis (plusieurs fois). Maintenant, pour prendre en charge cette fonctionnalité dans les langues, d'autres langues traitent simplement de cette question.

Par exemple, dans Java Script, une fonction (fonction anonyme ou littéraux de fonction) peut être adressée en tant qu'objet. Ainsi, vous pouvez les créer simplement et ils peuvent également être affectés à une variable et ainsi de suite. Par exemple:

var myFunction = function (...) {
    ...;
}
alert(myFunction(...));

ou via ES6, vous pouvez utiliser une fonction fléchée.

const myFunction = ... => ...

Jusqu'à présent, les concepteurs de langage Java n'ont pas accepté de gérer les fonctionnalités mentionnées de cette manière (techniques de programmation fonctionnelle). Ils croient que le langage Java est orienté objet et doivent donc résoudre ce problème via des techniques orientées objet. Ils ne veulent pas manquer la simplicité et la cohérence du langage Java.

Par conséquent, ils utilisent des interfaces, car lorsqu'un objet d'une interface avec une seule méthode (je veux dire une interface fonctionnelle) est nécessaire, vous pouvez le remplacer par une expression lambda. Tel que:

ActionListener listener = event -> ...;