Interface fonctionnelle en Java

Elle a été introduite pour la première fois dans Java 8. Une interface fonctionnelle peut être définie comme une interface avec une seule méthode abstraite. Cela signifie que les interfaces fonctionnelles en Java ne fournissent qu'une seule fonctionnalité de base. Cependant, une interface fonctionnelle peut contenir des méthodes statiques et par défaut, en plus d'une seule méthode abstraite. java.util.function.Function, java.util.function.Predicate, UnaryOperator, BinaryOperator, Supplier, Consumer sont des exemples d'interfaces fonctionnelles intégrées à Java.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Syntaxe de l'interface fonctionnelle

Voici une syntaxe de base donnée ci-dessous :

public interface MyFunctionalInterface(){
// abstract method
public void functionalMethod();
}

D'après la syntaxe ci-dessus, nous pouvons voir que l'interface nommée MyFunctionalInterface ne contient qu'une seule méthode non implémentée ; c'est pourquoi elle peut être considérée comme une interface fonctionnelle. Elle peut également contenir des méthodes statiques et par défaut comme celle présentée ci-dessous :

public interface MyFunctionalInterface(){
public default void defaultMethod(){
// default method logic goes here
}
public static void staticMethod(){
// static method logic goes here
}
// abstract method
public void functionalMethod();
}

De plus, une interface fonctionnelle peut être implémentée à l'aide d'une expression Lambda comme la suivante :

MyFunctionalInterface functionalInterface = () ->{
// basic functionality logic goes here
}

On peut également utiliser une annotation ou déclarer une interface comme interface fonctionnelle. Voici comment une interface fonctionnelle peut être déclarée à l'aide d'une annotation :

MyFunctionalInterface functionalInterface = () ->{
// basic functionality logic goes here
}

@FunctionalInterface a été introduit dans Java 8 et est utilisé pour les erreurs au niveau du compilateur au cas où une interface enfreindrait les règles d'une interface fonctionnelle. Déclarer une interface à l'aide de l'annotation @FunctionalInterface rend une interface fonctionnelle, et si plusieurs méthodes abstraites sont utilisées, cela générera une erreur de compilation.

Points importants concernant l'interface fonctionnelle

Voici quelques points importants :

• Une seule méthode abstraite est autorisée dans une interface de fonction. Si l'annotation @FunctionalInterface n'est pas utilisée avec une interface de fonction, alors plusieurs méthodes abstraites peuvent être déclarées, mais dans ce cas, cette interface sera considérée comme non fonctionnelle.
• L'utilisation de l'annotation @FunctionalInterface est facultative ; il n'est utilisé que pour la vérification au niveau du compilateur.
• Une interface fonctionnelle peut contenir n'importe quel nombre de méthodes statiques et par défaut.
• Les méthodes de remplacement de la classe parent n'enfreignent pas les règles d'une interface fonctionnelle.

Exemple :

@FunctionalInterface
public interface MyFunctionalInterface(){
// abstract method
public void functionalMethod();
@Override
public boolean equals(Object object);
//method overridden from parent class
}

Étant donné que l'interface ci-dessus remplace une méthode de la classe parent et ne déclare pas plusieurs méthodes abstraites, elle peut être considérée comme une interface fonctionnelle.

Exemples d'implémentation de l'interface fonctionnelle

Nous allons maintenant voir des exemples de code Java montrant la déclaration et l'utilisation de l'interface fonctionnelle Java.

Exemple n°1

Dans cet exemple, nous montrerons comment l'interface de fonction intégrée java.util.function.function est utilisée. Voici la déclaration de l'interface Function.

Interface :

package java.util.function;
public interface Function<T,R>{
public <R> apply(T inputparams);
}

Afin d'utiliser l'interface ci-dessus, nous devons l'implémenter dans notre classe comme suit.

Code :

import java.util.function.*;
public class FunctionalInterfaceDemo implements Function<Integer, Integer>{
@Override
public Integer apply (Integer n){
return n*n;
}
public static void main (String args[]){
FunctionalInterfaceDemo demo = new FunctionalInterfaceDemo ();
Integer sqroot= demo.apply(12);
System.out.println("Square root of 12 is " + sqroot);
}
}

Sortie :

Exemple n°2

Dans cet exemple, nous verrons comment ces interfaces sont créées à l'aide d'expressions lambda.

Code :

public class FunctionalInterfaceDemo{
public static void main (String args[]){
// creating functional Interface instance
Runnable r = () -> {System.out.println ("Executing Thread........");};
new Thread(r).start();
}
}

Sortie :

Exemple #3

Dans cet exemple, nous verrons l'utilisation d'un autre consommateur d'interface intégré pour parcourir une liste.

Code :

import java.util.function.*;
import java.util.*;
public class FunctionalInterfaceDemo{
public static void main (String args[]){
List<String> list = new ArrayList<String>();
list.add("One");
list.add("Two");
list.add("Three");
list.add("Four");
list.add("Five");
list.add("Six");
// Iterate arraylist using consumer
list.forEach(new Consumer<String>(){
@Override
public void accept(String item){
System.out.println(item);
}
});
}
}

Sortie :

Conclusion

L'article ci-dessus donne une compréhension claire des interfaces fonctionnelles en Java. Le principal avantage de l'utilisation des interfaces fonctionnelles Java 8 est la prise en charge des expressions lambda qui supprime une grande partie du code passe-partout, ce qui entraîne à son tour le développement d'un code petit, efficace et plus propre.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!