Interface fonctionnelle, Lambda expression, méthode par défaut, référence de méthode, avec des exemples

JAVA8
INTERFACES FONCTIONNELLES, LAMBDAEXPRESSION, MÉTHODE
PAR DÉFAUTET RÉFÉRENCES DE MÉTHODE,
AVEC DES EXEMPLES
Dr Mustapha Michrafy
M. MICHRAFY
Contact de l’auteur :
datascience.km@gmail.com
datascience.km@gmail.com1

Contexte
Cette étude a été présentée dans le cadre
du séminaire « Data Science principes,
méthodes, outils et applications » au
laboratoire Cermsem.
datascience.km@gmail.comM. MICHRAFY 2

Plan
• Objectif
• Pré-requis
• Méthode par défaut
• Interface fonctionnelle
• Lambda expression
• API des interfaces fonctionnelles standards
• Référence de méthode
• Références bibliographiques

Objectif
Cette étude vise à présenter les interfaces
fonctionnelles introduites par Java 8 ainsi
que leur utilisation via les lambda
expressions, les références de méthode et
les méthodes par défaut

Prérequis
• Connaissance du langage Java
• Connaissance de l’approche objet
• Notions de programmation fonctionnelle

Motivations
• Java a introduit les interfaces fonctionnelles et les
lambda expressions depuis la version 8.
• Ces nouvelles possibilités du langage permettent :
• de produire du code compact et concis,
• de produire du code lisible et facile à maintenir,
• de dégager la logique applicative (métier) d’un programme.

Méthode par défaut : principe
• Java 8 offre la possibilité de définir une ou plusieurs
méthodes par défaut dans une interface.
• La méthode par défaut sera appelée ssi la classe
implémentant l’interface ne l’implémente pas.
• Les méthodes par défaut remplacent avantageusement
les classes abstraites en fournissant une implémentation
par défaut de la logique de traitement.
• Les méthodes par défaut permettent au développeur de
librairies de fournir des implémentations par défaut.
• Une méthode par défaut est aussi utile pour partager la
même implémentation entre classes similaires.

Méthode par défaut : syntaxe (1)
• Pour déclarer une méthode par défaut, il suffit de faire
précéder son nom par « default » et d’en fournir une
implémentation dans l’interface.
Syntaxe :
default typeRetour nomMethode([arguments]) {
Corps
}
Exemples :
• public default boolean check(String x) { … }
• public default int addition(int a, int b) { ... }

Méthode par défaut : syntaxe (2)
// déclaration d une interface avec méthode par défaut
public Interface nomInterface {
public default valeurRetour nomMethodeParDefaut ([arguments]){ // traitement }
public valeurRetour nomMethode([arguments])
}
// Exemple d’une interfaceavec une méthode par défaut
public interface OperationMath {
// signaturede la méthode operation avec une implémentation par défaut
public default boolean operation(intx, int y){ return x+y; }
}

Méthode par défaut : utilisation
// déclarationd’une classeA utilisantla méthode par défaut
public classA implements OperationMath{ }
// déclaration d’une classe A qui surcharge la méthode check de l’interface A
public class B implements OperationMath{
public default int operation(nt x, int y){ return x-y ;} // soustraction
}
public static void main(String[] args) { // Appel dans une fonctionmain
A a = new A(); A b = new B(); // créationdes instances de A et B
a.operation(21, 11) ; // appel de la méthode par défaut déclarée dans OperationMath
b.operation(21,11) ; // appel le la méthode de la classe B
}
datascience.km@gmail.comM. MICHRAFY
// signaturede la méthode operation avec une implémentation par défaut
public default boolean operation(intx, int y){ return x+y; } // addition
}
10

Étendre les méthodes par défaut
• La méthode par defaut est considérée comme une methode par
défaut dans l’interface étendue si elle n’a pas été surchargée.
• Il est aussi possible redéfinir la méthode par défaut dans l’interface
fille. Dans ce cas, le qualifiquatif “default” est nécessaire lors de la
déclaration dans l’interface fille.
• Pour annuler le comportement par défaut d’une méthode dans
l’interface fille, il suffit de redéclarer la méthode avec le qualificatif
“abstract”. Dans ce cas la méthode devient une méthode abstraite
et qui nécessite une implémentation dans les classes filles.

Méthode par défaut : utilisation
public interface A { public defaultboolean check(String x){ return (x!=null && !x.isEmpty()) ; }}
public interface B extends A{ }
public interface C extends A {
public default boolean check(Stringx){
return (x!=null && !x.isEmpty()) && x.matches("[0-9]{5}"); }}
public interface D extends A { public abstract boolean check(String x); }
L’interface D ne dispose pas de méthode par défaut
L’interface C a redéfinit la méthode par défaut
L’interface B a la méthode par défaut celle qui est dans l’interface A

Méthode par défaut : duplication non
autorisée
• L'implémentation par une classe de deux interfaces
possédant une méthode par défaut portant même
signature n'est pas autorisée, sauf si la classe
surcharge la méthode par défaut en question.
• En effet, la classe se trouve, dans le premier cas, dans
l'incapacité de déterminer quelle interface doit fournir
l'implémentation de la méthode par défaut à exploiter.
• Le cas échéant, une erreur se produira à la compilation.

Méthodes statiques dans les interfaces
• Java 8 offre la possibilité de créer des méthodes statiques
dans une interface.
• Une méthode statique d’une interface est considérée
comme méthode de toutes les classes implémentant
l’interface en question.
• Les méthodes statiques sont utiles pour proposer des
méthodes utilitaires liées à une interface.
• La majorité des interfaces fonctionnelles standards
possèdent des méthodes statiques.

Interface fonctionnelle
• Java permet de définir une interface fonctionnelle qui
représente une signature d’une méthode et ne disposant que
d’une seule méthode abstraite.
• Une interface fonctionnelle doit disposer d’une et une seule
méthode abstraite et 0, 1 ou plusieurs méthodes par défaut.
• La méthode abstraite de l’interface fonctionnelle ne doit pas
avoir d’implémentation par défaut.
• L’interface fonctionnelle permet de passer en paramètre une
méthode comme :
• référence vers une méthode statique
• référence vers une méthode d’une instance
• référence vers un constructeur
• lambda expression

Interface fonctionnelle : étapes
• Déclarer une interface fonctionnelle.
• Utiliser l’interface fonctionnelle dans la signature ou dans
le corps d’une méthode.
• Instancier l’interface fonctionnelle par l’intermédiaire d’une
lambda expression.
• Faire appel à une méthode utilisant l’interface
fonctionnelle.

Interface fonctionnelle : Déclaration
public interface NomInterface {
public valeurRetour nomMethode([Arguments]);
}
// Exemple1 d’une déclarationd’une interface fonctionnelle
public interface OperationCheck{
// signaturede la méthode check l interfacefonctionnelleOperationCheck
public boolean check(Stringa);
}
// Exemple2 d’une déclarationd’une interface fonctionnelle
// signaturede la méthode operation de l interface fonctionnelleOperationMath
public int operation(inta, int b);
}

Lambda expression (1)
• Les lambda expressions permettent d’instancier les interfaces
fonctionnelles, c.-à-d. de leur fournir une implémentation.
• La déclaration d’une lambda expression nécessite de préciser
l’interface fonctionnelle associée.
• Les arguments d’entrée et la valeur de retour de la lambda
expression doivent respecter la signature de la méthode de l’interface
fonctionnelle associée.
• Le symbole « -> » sépare les arguments d’entrée et le corps du
traitement proposé par la lambda expression.
Syntaxe :
NomInterface nomLambdaExpression = ([arguments]) -> {
// traitement
};

Lambda expression (2)
// Exemple 2 d’une déclarationd’une interfacefonctionnelle
// signaturede la méthode operation de l’interface fonctionnelleOperationMath
public int operation(inta, int b);
}
OperationMath addition = (int a, int b) -> a + b; // avec le type des arguments d’entrée
OperationMath produit = (a, b) -> a * b; // sans déclaration des types
OperationMath soustration = (int a, int b) -> {return a - b;}; // avec typage et return
Nom de
l’interface
Nom du lambda
expression
Arguments
d’entrée
Corps du lambda
expression
Signature de la
méthode

Lambda expression : exemple
public interface OperationMath {// déclaration d’une interface fonctionnelle
public int operation(int a, int b); // la méthode à implémenter
}
public static void main(String[] args) {
A pf = new A();
OperationMath addition = (int a, int b) -> a + b;
OperationMath produit = (a, b) -> a * b;
int s = pf.apply(a, b, addition); // utilisation du lambda expression addition
int p = pf.apply(a, b, produit); // utilisation du lambda expression produit
}
public class A {// appliquer prend en un entrée l’interface fonctionnelle OperationMath
public int apply(int a, int b, OperationMath op){ return op.operation(a,b); }}

Interface fonctionnelle : fonction d’ordre
supérieur (1)
• Avec Java 8, grâce aux interfaces fonctionnelles, une
fonction peut être un argument d’une autre fonction.
• On peut aussi affecter une fonction à une variable via une
interface fonctionnelle ou une lambda expression.
• De même, il est possible d’utiliser une fonction – une
interface fonctionnelle - comme valeur de retour d’une
fonction.
• Plus généralement, il devient possible de définir une
fonction qui prend en entrée une fonction et renvoie une
fonction.

Interface fonctionnelle : fonction d’ordre
supérieur (2)
public interface PolynomePD {
public abstract double donnerY(double x);
}
public interface FabriquePolynomePremierDegre {
public abstract PolynomePD donnerPolynome(double a, double b);
}
FabriquePolynomePremierDegre fppd = (a,b) -> {return (x) -> a*x+b;};
FabriquePolynomePremierDegre fppd1 = (a,b) -> ((x) -> (a*x+b));
PolynomePD p1 = fppd.donnerPolynome(1,1);
double x = 1;
double p1_x = p1.donnerY(x); // retourne 2
double p2_x = p2.donnerY(x); // retourne 7
}
Fonction en valeur de retour
Interface fonctionnelle
2 façons de déclarer
une fonction en valeur
de retour
Construire 2 polynômes :
P1(x) : x + 1
P2(x) : 2x + 5

Interface fonctionnelle : fonction composée
public interface ComposeFonction {
public PolynomePD compose(PolynomePD x, PolynomePD y);
}
FabriquePolynomePremierDegre fppd = (a,b) -> {return (x) -> a*x+b;};
// cf est le composé de f et g
ComposeFonction cf = (f,g) -> ((x)->(f.donnerY(g.donnerY(x))));
double x=1;
// calculer p1op2(x) et cf(p1,p2)(x) et comparer
double p2_x=p2.donnerY(x),p1p2x = p1.donnerY(p2_x);
double cf_x = cf.compose(p1, p2).donnerY(x);
System.out.println("p1p2x = " + p1p2x + " | cf_x = " + cf_x);
} // sortie : p1p2x = 8.0 | cf_x = 8.0
2 fonctions en entréeretour est une fonction
Expression de la
fonction composée
Appel de la fonction
composé, passage
deux fonctions

Interface fonctionnel standard (1)
• Java 8 a introduit l’API relative aux interfaces
fonctionnelles dans le package java.util.function
• Cette API est exploitée par l’API STREAM.
• Cette API propose 44 interfaces fonctionnelles.
• La connaissance de cette API favorise la communication
entre les différents membres du projet.

Interface fonctionnel standard (2)
• Function - prend un T en entrée et retourne un R
• Predicate - prend un T en entrée et retourne un
booléen
• Consumer - prend un T en entrée et pas de valeur
de retour
• Supplier - ne prend rien en entrée et retourne un T
• BinaryOperator - prend deux T en entrée et
retourne un T

Interface fonctionnelle Function (1)
• Cette interface déclare quatre méthodes :
1. apply : méthode abstraite qui nécessite une implémentation.
Prend en entrée un T et retourne un R.
2. identity : méthode par défaut statique qui renvoie la fonction
Identité : T ⇒ T.
3. compose : méthode par défaut qui renvoie la composée de la
fonction F (implémentée dans apply) et G : FoG. Prend en
entrée un argument de type Function et renvoie une valeur de
type Function.
4. andThen : méthode par défaut, similaire à la méthode compose,
qui retourne la composée GoF de la fonction G donnée en
entrée et de F (implémentée dans apply).

Interface fonctionnelle Function (2)
public interface Function<T, R> {
// fonction abstraite apply
R apply(T t);
// fonction compose pour l’opérateur o qui retourne une fonction
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
Objects.requireNonNull(before);
return (V v) -> apply(before.apply(v));
}
// fonction andThen qui compose deux fonctions et retourne une fonction
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
Objects.requireNonNull(after);
return (T t) -> after.apply(apply(t));
}
// la fonction identité.
static <T> Function<T, T> identity() {return t -> t;}
}

Interface Functionnelle Function (3)
public class MainFunction {
Function<String, String> toUpper = (x) -> (x.toUpperCase());
Function<String, String> after = (x) -> (x.split("-")[0]);
Function<String, String> before = (x) -> (x.split("-")[1]);
String nomC = "Dupond-Pascal";
String nomC_format = toUpper.apply(nomC); // renvoie DUPOND-PASCAL
String nom = toUpper.andThen(after).apply(nomComplet); // renvoie DUPOND
String prenom = toUpper.compose(before).apply(nomComplet); // renvoie PASCAL
} Appel à apply de toUpper
Appel à la fonction andThen pour toUpper o after
Appel à la fonction compose before o toUpper
3 interfaces Function

Interface fonctionnelle Predicat (1)
• Cette interface offre cinq méthodes :
1. test : méthode abstraite qui nécessite une implémentation.
Prend en entrée un T et retourne un booléen.
2. and: méthode par défaut qui représente le ET logique. Prend en
entrée un prédicat et renvoie un prédicat.
3. negate : méthode par défaut qui représente la négation logique.
Renvoie le prédicat Non P.
4. or : méthode par défaut qui implémente le OU logique.
5. isEqual : méthode par défaut statique, qui implémente
l’opérateur logique « = ». Prend entrée un T et renvoie un
prédicat.

Interface fonctionnelle : Predicate (2)
public interface Predicate<T> {
// La méthode abstraite de l’interface
boolean test(T t);
// Cette méthode implémente <<ET>>
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
// Cette méthode implemente l'operateur <<Non P>>
default Predicate<T> negate() { return (t) -> !test(t); }
// Cette methode implémente l'operateur <<OR>>
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
//cette méthode implémente l’operateur ==
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef) ? Objects::isNull: object -> targetRef.equals(object);
}
}

Interface fonctionnelle Predicate (3)
Predicate<String> isNull = (x) -> (x!=null);
Predicate<String> isEmpty = (x) -> (x.isEmpty()==false);
Predicate<String> isCP = (x) -> (x.matches("[0-9]{5}"));
// fonctions sont composées à partir de deux predicats
Predicate<String> isNullAndEmpty = isNull.and(isEmpty);
Predicate<String> isCPValide = isNullAndEmpty.and(isCP);
String x = "75", y="75009";
boolean rx= isNullAndEmpty.test(x);
boolean ry = isCPValide.test(y);
System.out.println("rx = " + rx + " | ry = " + ry); // retourne rx = true | ry = true
}
Création d’un nouveau prédicat en utilisant And pour les
prédicats isNull , isEmpty
Appel à la méthode test des deux prédicats

Interface fonctionnelle Consumer (1)
• Cette interface propose 2 méthodes :
1. accept : méthode abstraite qui nécessite une implémentation.
Prend en entrée un T et ne retourne pas de valeur. Cette
méthode sert à effectuer une opération à effet de bord sur son
argument d’entrée.
1. andThen : méthode par défaut qui effectue le traitement d’un
consumer G après le consumer F implémenté dans la méthode
accept. Prend en entrée un Consumer et renvoie un Consumer.
Utilisée si l’on souhaite appliquer plusieurs opérations à effet de
bord dans un ordre prédéfini..

Interface fonctionnelle : Consumer(2)
public interface Consumer<T> {
// Cette méthode un traitement sur l’objet T
void accept(T t);
// Cette méthode applique deux block de traitement sur l’objet T
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> {
accept(t);
after.accept(t);
};
}
}
Observer l’ordre du traitement de chaque Consumer

Interface fonctionnelle : Consumer (3)
public class Climat {
double temp, lon, lat;
public Climat(double temp, double lon, double lat) {
super();
this.temp = temp; this.lon = lon; this.lat = lat;
}
public String toTemperature(){return "Climat [temp=" + temp + "]";}
public String toLonLat() {return "Climat [lon=" + lon + ", lat=" + lat + "]";}
}
Consumer<Climat> toTemp = (x) -> System.out.println(x.toTemperature());
Consumer<Climat> toXY = (x) -> System.out.println(x.toLonLat());
Consumer<Climat> toTempXY = toTemp.andThen(toXY);
Climat climat = new Climat(18, 2.3488000, 48.8534100);
toTemp.accept(climat); // Climat [temp=18.0]
toXY.accept(climat); // Climat [lon=2.3488, lat=48.85341]
toTempXY.accept(climat); // affiche les résultats donnés par toTemp et toXY
}
Deux consumers
Consumer composé à l’aide de andThen
Appel des 3 consumers

Références de méthode : motivation
• Les lambda expressions permettent de créer des
méthodes anonymes. Or, souvent, une lambda
expression pointe ou utilise des méthodes existantes.
• Java 8 a introduit les références de méthode pour
répondre au besoin de faire référence dans une lambda
expression à une méthode existante via son nom.
• Une référence de méthode associe une « instance »
d’une interface fonctionnelle à un code existant.
• Les références de méthode favorisent la réutilisabilité du
code existant ainsi que sa lisibilité.

Références de méthode : typologie
• Quatre types de référence possibles :
• Référence vers une méthode statique
• Référence vers un constructeur
• Référence vers une méthode d’instance
• Référence vers une méthode d’un objet arbitraire de type particulier
• La syntaxe d’une référence de méthode consiste à utiliser le nom
de la classe ou de l’instance de la classe, suivi de l'opérateur « :: »
et du nom de la méthode à référencer

Référence vers une méthode d’instance
interface Distancier { public double distance (Mesure m1, Mesure m2 ) ; }
classMesure{
private double x;
public Mesure (double x){ this.x = x }
public double distance1(Mesure m) { return this.x - m.x; }
public double distance2(Mesure m) { return Math.abs(this.x- m.x) ; }
}
public staticvoid main (String [] args){
Mesure m1 = new Mesure(12), m2 = new Mesure(25) ;
Distancier d1 = Mesure::distance1; // référence vers la méthode distance1
Distancier d2 = Mesure::distance2; // référence vers la méthode distance2
System.out.println("distance1 entre m1 et m2 = " + d1.distance(m1, m2)) ;
System.out.println("distance2 entre m1 et m2 = " + d2.distance(m1, m2)) ;
}
Méthode d’interface
Méthodes d’instance
Références vers des méthodes d’instance

Référence vers un constructeur
interface Fabrique<T> { public T getInstance(double x); }
classMesure{
private double x;
public Mesure (double x){ this.x = x }
public String toString() { return "Mesure [x=" + x + "]"; }
}
public staticvoid main (String [] args){
Fabrique<Mesure> fm = Mesure::new;
Mesure m = fm.getInstance(17);
System.out.println ("dm = " + d1.toString();
}
Constructeur
Référence vers un constructeur

Référence vers une méthode statique
interface ICompteur { public T getCompteur(); }
classMesure{
private int compteur=0;
private double x;
public Mesure (double x){ this.x = x; compteur++;}
public staticint getNbInstance(){ return compteur; }
}
public static void main (String [] args){
ICompteur compt = Mesure::getNbInstance ;
Mesure m1 = new Mesure(3), m2=new Mesure(7);
System.out.println ("nombre d instance = " + compt.getCompteur()) ;
}
Méthode statique
Référence vers une méthode statique

Références bibliographiques
• API Java 8 , documentation oracle,
https://docs.oracle.com/javase/8/docs/api/

Dr Mustapha Michrafy
Data Scientist, ATOS
•
Contact : datascience.km@gmail.com

Interface fonctionnelle, Lambda expression, méthode par défaut, référence de méthode, avec des exemples

Contenu connexe

Tendances (20)

En vedette (20)

Similaire à Interface fonctionnelle, Lambda expression, méthode par défaut, référence de méthode, avec des exemples (20)

Interface fonctionnelle, Lambda expression, méthode par défaut, référence de méthode, avec des exemples