Java est resté à jamais un langage de programmation orienté objet. Par langage de programmation orienté objet, nous pouvons déclarer que tout ce qui est présent dans le langage de programmation Java tourne dans les objets, à l'exception de certains types de données primitifs et méthodes primitives pour des raisons d'intégrité et de simplicité. Il n'y a pas que des fonctions présentes dans un langage de programmation appelé Java. Les fonctions du langage de programmation Java font partie d'une classe, et si quelqu'un souhaite les utiliser, il doit utiliser la classe ou l'objet de la classe pour appeler n'importe quelle fonction.
Interfaces fonctionnelles Java
UN interface fonctionnelle est une interface qui ne contient qu'une seule méthode abstraite. Ils ne peuvent avoir qu’une seule fonctionnalité à afficher. À partir de Java 8, expression lambda peut être utilisé pour représenter l’instance d’une interface fonctionnelle. Une interface fonctionnelle peut avoir un certain nombre de méthodes par défaut. Exécutable , ActionListener , et Comparable sont quelques exemples d’interfaces fonctionnelles.
L'interface fonctionnelle est également reconnue comme Interfaces de méthodes abstraites uniques . Bref, on les appelle aussi Interfaces SAM . Les interfaces fonctionnelles en Java sont la nouvelle fonctionnalité qui offre aux utilisateurs l'approche de la programmation fondamentale.
Des interfaces fonctionnelles sont incluses dans Java SE 8 avec des expressions Lambda et des références de méthodes afin de rendre le code plus lisible, plus propre et plus simple. Les interfaces fonctionnelles sont des interfaces qui garantissent qu’elles n’incluent précisément qu’une seule méthode abstraite. Les interfaces fonctionnelles sont utilisées et exécutées en représentant l'interface avec un annotation appelée @InterfaceFonctionnelle . Comme décrit précédemment, les interfaces fonctionnelles ne peuvent contenir qu’une seule méthode abstraite. Cependant, ils peuvent inclure n’importe quelle quantité de méthodes par défaut et statiques.
Dans les interfaces fonctionnelles, il n'est pas nécessaire d'utiliser le mot-clé abstract car il est facultatif d'utiliser le mot-clé abstract car, par défaut, la méthode définie à l'intérieur de l'interface est uniquement abstraite. Nous pouvons également appeler des expressions Lambda comme instance d'interface fonctionnelle.
Exemple d'interfaces fonctionnelles Java
Exemple 1:
Avant Java 8, nous devions créer des objets de classe internes anonymes ou implémenter ces interfaces.
Java
// Java program to demonstrate functional interface> class> Test {> >public> static> void> main(String args[])> >{> >// create anonymous inner class object> >new> Thread(>new> Runnable() {> >@Override> public> void> run()> >{> >System.out.println(>'New thread created'>);> >}> >}).start();> >}> }> |
>
>Sortir
New thread created>
Exemple 2 :
À partir de Java 8, nous pouvons attribuer expression lambda à son objet d'interface fonctionnel comme ceci :
Java
// Java program to demonstrate Implementation of> // functional interface using lambda expressions> class> Test {> >public> static> void> main(String args[])> >{> >// lambda expression to create the object> >new> Thread(() ->{> >System.out.println(>'New thread created'>);> >}).start();> >}> }> |
>
>Sortir
New thread created>
@Annotation d'interface fonctionnelle
L'annotation @FunctionalInterface est utilisée pour garantir que l'interface fonctionnelle ne peut pas avoir plus d'une méthode abstraite. Dans le cas où plusieurs méthodes abstraites sont présentes, le compilateur signale un message « Annotation @FunctionalInterface inattendue ». Cependant, il n’est pas obligatoire d’utiliser cette annotation.
Vous trouverez ci-dessous la mise en œuvre du sujet ci-dessus :
Java
// Java program to demonstrate lambda expressions to> // implement a user defined functional interface.> @FunctionalInterface> interface> Square {> >int> calculate(>int> x);> }> class> Test {> >public> static> void> main(String args[])> >{> >int> a =>5>;> >// lambda expression to define the calculate method> >Square s = (>int> x) ->x * x;> >// parameter passed and return type must be> >// same as defined in the prototype> >int> ans = s.calculate(a);> >System.out.println(ans);> >}> }> |
>
>Sortir
25>
Quelques interfaces fonctionnelles Java intégrées
Depuis Java SE 1.8, de nombreuses interfaces sont converties en interfaces fonctionnelles. Toutes ces interfaces sont annotées avec @FunctionalInterface. Ces interfaces sont les suivantes –
- Runnable -> Cette interface contient uniquement la méthode run(). Comparable -> Cette interface contient uniquement la méthode compareTo(). ActionListener -> Cette interface contient uniquement la méthode actionPerformed(). Callable -> Cette interface contient uniquement la méthode call().
Java SE 8 comprenait quatre principaux types d'interfaces fonctionnelles qui peut être appliqué dans plusieurs situations comme mentionné ci-dessous :
- Fournisseur de fonction de prédicat consommateur
Parmi les quatre interfaces précédentes, les trois premières interfaces, à savoir Consommateur, Prédicat et Fonction, comportent également des ajouts fournis ci-dessous :
- Consommateur -> Bi-Consommateur
- Prédicat -> Bi-Prédicat
- Fonction -> Bi-Fonction, Opérateur Unaire, Opérateur Binaire
1. Consommateur
L'interface consommateur de l'interface fonctionnelle est celle qui n'accepte qu'un seul argument ou un argument gentrifié. L'interface consommateur n'a aucune valeur de retour. Cela ne renvoie rien. Il existe également des variantes fonctionnelles du Consumer : DoubleConsumer, IntConsumer et LongConsumer. Ces variantes acceptent des valeurs primitives comme arguments.
Outre ces variantes, il existe également une autre variante de l'interface Consumer connue sous le nom de Bi-Consumer.
Bi-Consommation – Bi-Consumer est la variante la plus intéressante de l’interface Consumer. L'interface consommateur ne prend qu'un seul argument, mais de l'autre côté, l'interface Bi-Consumer prend deux arguments. Consumer et Bi-Consumer n’ont aucune valeur de retour. Il ne renvoie également rien, tout comme l'interface Consumer. Il est utilisé pour parcourir les entrées de la carte.
Syntaxe / Prototype d'interface fonctionnelle consommateur –
Consumer consumer = (value) ->System.out.println(value);>
Cette implémentation de l'interface fonctionnelle Java Consumer imprime la valeur passée en paramètre à l'instruction print. Cette implémentation utilise la fonction Lambda de Java.
2. Prédicat
En logique scientifique, une fonction qui accepte un argument et, en retour, génère une valeur booléenne comme réponse est appelée prédicat. De même, dans le langage de programmation Java, une interface fonctionnelle de prédicat de Java est un type de fonction qui accepte une valeur ou un argument unique, effectue une sorte de traitement sur celui-ci et renvoie une réponse booléenne (Vrai/Faux). L'implémentation de l'interface fonctionnelle Predicate encapsule également la logique de filtrage (un processus utilisé pour filtrer les composants de flux sur la base d'un prédicat fourni) en Java.
Tout comme l'interface fonctionnelle Consumer, l'interface fonctionnelle Predicate possède également quelques extensions. Il s'agit de IntPredicate, DoublePredicate et LongPredicate. Ces types d'interfaces fonctionnelles de prédicat n'acceptent que des types de données ou des valeurs primitives comme arguments.
Bi-Prédicat – Bi-Predicate est également une extension de l'interface fonctionnelle Predicate, qui, au lieu d'un, prend deux arguments, effectue certains traitements et renvoie la valeur booléenne.
Syntaxe de l'interface fonctionnelle du prédicat -
public interface Predicate { boolean test(T t); }> L'interface fonctionnelle du prédicat peut également être implémentée à l'aide d'une classe. La syntaxe pour l'implémentation de l'interface fonctionnelle de prédicat à l'aide d'une classe est donnée ci-dessous :
public class CheckForNull implements Predicate { @Override public boolean test(Object o) { return o != null; } }> L'interface fonctionnelle du prédicat Java peut également être implémentée à l'aide d'expressions Lambda. Un exemple d’implémentation de l’interface fonctionnelle Predicate est donné ci-dessous –
Predicate predicate = (value) ->valeur != null;>
Cette implémentation d'interfaces fonctionnelles en Java utilisant des expressions Java Lambda est plus gérable et efficace que celle implémentée à l'aide d'une classe car les deux implémentations font le même travail, c'est-à-dire renvoient le même résultat.
3. Fonction
Une fonction est un type d'interface fonctionnelle en Java qui ne reçoit qu'un seul argument et renvoie une valeur après le traitement requis. Il existe de nombreuses versions d'interfaces de fonction car un type primitif ne peut pas impliquer un argument de type général, nous avons donc besoin de ces versions d'interfaces de fonction. De nombreuses versions différentes des interfaces de fonctions sont instrumentales et sont couramment utilisées dans les types primitifs comme double, int, long. Les différentes séquences de ces types primitifs sont également utilisées dans l'argumentation.
Ces versions sont :
Bi-fonction
La Bi-Fonction est essentiellement liée à une Fonction. De plus, il prend deux arguments, alors que Function en accepte un.
Le prototype et la syntaxe de Bi-Function sont donnés ci-dessous –
@FunctionalInterface public interface BiFunction { R apply(T t, U u); ....... }> Dans le code d'interface ci-dessus, T et U sont les entrées, et il n'y a qu'une seule sortie qui est R.
Opérateur unaire et opérateur binaire
Il existe également deux autres interfaces fonctionnelles appelées Opérateur Unaire et Opérateur Binaire. Ils étendent tous deux respectivement la fonction et la bi-fonction. En termes simples, l'opérateur unaire étend la fonction et l'opérateur binaire étend la bi-fonction.
Le prototype de l'opérateur unaire et de l'opérateur binaire est mentionné ci-dessous :
je. Opérateur unaire
@FunctionalInterface public interface UnaryOperator extends Function { ……... }> ii . Opérateur binaire
@FunctionalInterface public interface BinaryOperator extends BiFunction { ……... }> Nous pouvons comprendre, dans l'exemple ci-dessus, que l'opérateur unaire n'accepte qu'un seul argument et ne renvoie qu'un seul argument. Néanmoins, dans Unary Operator, les valeurs d'entrée et de sortie doivent être identiques et du même type.
D'un autre côté, l'opérateur binaire prend deux valeurs et renvoie une valeur comparable à Bi-Function mais similaire à un opérateur unaire, les types de valeurs d'entrée et de sortie doivent être identiques et du même type.
4. Fournisseur
L'interface fonctionnelle du fournisseur est également un type d'interface fonctionnelle qui ne prend aucune entrée ou argument et renvoie pourtant une seule sortie. Ce type d'interface fonctionnelle est généralement utilisé dans la génération paresseuse de valeurs. Les interfaces fonctionnelles des fournisseurs sont également utilisées pour définir la logique de génération de toute séquence. Par exemple – La logique derrière la série de Fibonacci peut être générée à l’aide du Stream. méthode generate, qui est implémentée par l'interface fonctionnelle du fournisseur.
Les différentes extensions de l'interface fonctionnelle Fournisseur contiennent de nombreuses autres fonctions fournisseurs telles que BooleanSupplier, DoubleSupplier, LongSupplier et IntSupplier. Le type de retour de toutes ces spécialisations supplémentaires est uniquement leurs primitives correspondantes.
La syntaxe/le prototype de l'interface fonctionnelle du fournisseur est :
@FunctionalInterface public interface Supplier{ // gets a result …………. // returns the specific result ………… T.get(); }> Vous trouverez ci-dessous la mise en œuvre du sujet ci-dessus :
Java
// A simple program to demonstrate the use> // of predicate interface> import> java.util.*;> import> java.util.function.Predicate;> class> Test {> >public> static> void> main(String args[])> >{> >// create a list of strings> >List names = Arrays.asList(> >'Geek'>,>'GeeksQuiz'>,>'g1'>,>'QA'>,>'Geek2'>);> >// declare the predicate type as string and use> >// lambda expression to create object> >Predicate p = (s) ->s.commenceAvec(>'G'>);> >// Iterate through the list> >for> (String st : names) {> >// call the test method> >if> (p.test(st))> >System.out.println(st);> >}> >}> }> |
>
>Sortir
10 ml c'est combien
Geek GeeksQuiz Geek2>
Points/Observations importants ns :
Voici quelques points importants concernant les interfaces fonctionnelles en Java :
- Dans les interfaces fonctionnelles, une seule méthode abstraite est prise en charge. Si l'annotation d'une interface fonctionnelle, c'est-à-dire @FunctionalInterface n'est pas implémentée ou écrite avec une interface de fonction, plusieurs méthodes abstraites peuvent être déclarées à l'intérieur de celle-ci. Cependant, dans cette situation comportant plusieurs fonctions, cette interface ne sera pas appelée interface fonctionnelle. C'est ce qu'on appelle une interface non fonctionnelle.
- L’annotation @FunctionalInterface n’est pas nécessaire car elle est uniquement volontaire. Ceci est écrit car cela aide à vérifier le niveau du compilateur. En plus de cela, c’est facultatif.
- Un nombre infini de méthodes (qu'elles soient statiques ou par défaut) peuvent être ajoutées à l'interface fonctionnelle. En termes simples, il n'y a pas de limite à une interface fonctionnelle contenant des méthodes statiques et par défaut.
- Le remplacement des méthodes de la classe parent ne viole pas les règles d'une interface fonctionnelle en Java.
- Le java.util.fonction Le package contient de nombreuses interfaces fonctionnelles intégrées dans Java 8.