JAVA8
INTERFACES FONCTIONNELLES, LAMBDAEXPRESSION, MÉTHODE
PAR DÉFAUTET RÉFÉRENCES DE MÉTHODE,
AVEC DES EXEMPLES
Dr Mustap...
Contexte
Cette étude a été présentée dans le cadre
du séminaire « Data Science principes,
méthodes, outils et applications...
Plan
• Objectif
• Pré-requis
• Méthode par défaut
• Interface fonctionnelle
• Lambda expression
• API des interfaces fonct...
Objectif
Cette étude vise à présenter les interfaces
fonctionnelles introduites par Java 8 ainsi
que leur utilisation via ...
Prérequis
• Connaissance du langage Java
• Connaissance de l’approche objet
• Notions de programmation fonctionnelle
datas...
Motivations
• Java a introduit les interfaces fonctionnelles et les
lambda expressions depuis la version 8.
• Ces nouvelle...
Méthode par défaut : principe
• Java 8 offre la possibilité de définir une ou plusieurs
méthodes par défaut dans une inter...
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...
Méthode par défaut : syntaxe (2)
// déclaration d une interface avec méthode par défaut
public Interface nomInterface {
pu...
Méthode par défaut : utilisation
// déclarationd’une classeA utilisantla méthode par défaut
public classA implements Opera...
É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 étend...
Méthode par défaut : utilisation
public interface A { public defaultboolean check(String x){ return (x!=null && !x.isEmpty...
Méthode par défaut : duplication non
autorisée
• L'implémentation par une classe de deux interfaces
possédant une méthode ...
Méthodes statiques dans les interfaces
• Java 8 offre la possibilité de créer des méthodes statiques
dans une interface.
•...
Interface fonctionnelle
• Java permet de définir une interface fonctionnelle qui
représente une signature d’une méthode et...
Interface fonctionnelle : étapes
• Déclarer une interface fonctionnelle.
• Utiliser l’interface fonctionnelle dans la sign...
Interface fonctionnelle : Déclaration
public interface NomInterface {
public valeurRetour nomMethode([Arguments]);
}
// Ex...
Lambda expression (1)
• Les lambda expressions permettent d’instancier les interfaces
fonctionnelles, c.-à-d. de leur four...
Lambda expression (2)
// Exemple 2 d’une déclarationd’une interfacefonctionnelle
public interface OperationMath {
// signa...
Lambda expression : exemple
public interface OperationMath {// déclaration d’une interface fonctionnelle
public int operat...
Interface fonctionnelle : fonction d’ordre
supérieur (1)
• Avec Java 8, grâce aux interfaces fonctionnelles, une
fonction ...
Interface fonctionnelle : fonction d’ordre
supérieur (2)
public interface PolynomePD {
public abstract double donnerY(doub...
Interface fonctionnelle : fonction composée
public interface ComposeFonction {
public PolynomePD compose(PolynomePD x, Pol...
Interface fonctionnel standard (1)
• Java 8 a introduit l’API relative aux interfaces
fonctionnelles dans le package java....
Interface fonctionnel standard (2)
• Function - prend un T en entrée et retourne un R
• Predicate - prend un T en entrée e...
Interface fonctionnelle Function (1)
• Cette interface déclare quatre méthodes :
1. apply : méthode abstraite qui nécessit...
Interface fonctionnelle Function (2)
public interface Function<T, R> {
// fonction abstraite apply
R apply(T t);
// foncti...
Interface Functionnelle Function (3)
public class MainFunction {
public static void main(String[] args) {
Function<String,...
Interface fonctionnelle Predicat (1)
• Cette interface offre cinq méthodes :
1. test : méthode abstraite qui nécessite une...
Interface fonctionnelle : Predicate (2)
public interface Predicate<T> {
// La méthode abstraite de l’interface
boolean tes...
Interface fonctionnelle Predicate (3)
public static void main(String[] args) {
Predicate<String> isNull = (x) -> (x!=null)...
Interface fonctionnelle Consumer (1)
• Cette interface propose 2 méthodes :
1. accept : méthode abstraite qui nécessite un...
Interface fonctionnelle : Consumer(2)
public interface Consumer<T> {
// Cette méthode un traitement sur l’objet T
void acc...
Interface fonctionnelle : Consumer (3)
public class Climat {
double temp, lon, lat;
public Climat(double temp, double lon,...
Références de méthode : motivation
• Les lambda expressions permettent de créer des
méthodes anonymes. Or, souvent, une la...
Références de méthode : typologie
• Quatre types de référence possibles :
• Référence vers une méthode statique
• Référenc...
Référence vers une méthode d’instance
interface Distancier { public double distance (Mesure m1, Mesure m2 ) ; }
classMesur...
Référence vers un constructeur
interface Fabrique<T> { public T getInstance(double x); }
classMesure{
private double x;
pu...
Référence vers une méthode statique
interface ICompteur { public T getCompteur(); }
classMesure{
private int compteur=0;
p...
Références bibliographiques
• API Java 8 , documentation oracle,
https://docs.oracle.com/javase/8/docs/api/
datascience.km...
Dr Mustapha Michrafy
Data Scientist, ATOS
•
Contact : datascience.km@gmail.com
datascience.km@gmail.comM. MICHRAFY 41
Prochain SlideShare
Chargement dans…5
×

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

602 vues

Publié le

Ce document vise à présenter java 8 et lambda expression.
Les points abordés sont les interfaces fonctionnelles, fonction d'ordre supérieur, lambda expression, référence de méthode et méthode par défaut. Chaque notion est accompagnée par des exemples. Les codes sources seront disponibles sur git.

Publié dans : Données & analyses
0 commentaire
3 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

Aucun téléchargement
Vues
Nombre de vues
602
Sur SlideShare
0
Issues des intégrations
0
Intégrations
8
Actions
Partages
0
Téléchargements
13
Commentaires
0
J’aime
3
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive

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

  1. 1. 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
  2. 2. 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
  3. 3. 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 datascience.km@gmail.comM. MICHRAFY 3
  4. 4. 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 datascience.km@gmail.comM. MICHRAFY 4
  5. 5. Prérequis • Connaissance du langage Java • Connaissance de l’approche objet • Notions de programmation fonctionnelle datascience.km@gmail.comM. MICHRAFY 5
  6. 6. 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. datascience.km@gmail.comM. MICHRAFY 6
  7. 7. 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. datascience.km@gmail.comM. MICHRAFY 7
  8. 8. 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) { ... } datascience.km@gmail.comM. MICHRAFY 8
  9. 9. 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; } } datascience.km@gmail.comM. MICHRAFY 9
  10. 10. 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 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; } // addition } 10
  11. 11. É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. datascience.km@gmail.comM. MICHRAFY 11
  12. 12. 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 datascience.km@gmail.comM. MICHRAFY 12
  13. 13. 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. datascience.km@gmail.comM. MICHRAFY 13
  14. 14. 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. datascience.km@gmail.comM. MICHRAFY 14
  15. 15. 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 datascience.km@gmail.comM. MICHRAFY 15
  16. 16. 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. datascience.km@gmail.comM. MICHRAFY 16
  17. 17. 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 public interface OperationMath { // signaturede la méthode operation de l interface fonctionnelleOperationMath public int operation(inta, int b); } datascience.km@gmail.comM. MICHRAFY 17
  18. 18. 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 }; datascience.km@gmail.comM. MICHRAFY 18
  19. 19. Lambda expression (2) // Exemple 2 d’une déclarationd’une interfacefonctionnelle public interface OperationMath { // 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 datascience.km@gmail.comM. MICHRAFY 19
  20. 20. 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); }} datascience.km@gmail.comM. MICHRAFY 20
  21. 21. 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. datascience.km@gmail.comM. MICHRAFY 21
  22. 22. 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); } public static void main(String[] args) { FabriquePolynomePremierDegre fppd = (a,b) -> {return (x) -> a*x+b;}; FabriquePolynomePremierDegre fppd1 = (a,b) -> ((x) -> (a*x+b)); PolynomePD p1 = fppd.donnerPolynome(1,1); PolynomePD p2 = fppd.donnerPolynome(2,5); 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 datascience.km@gmail.comM. MICHRAFY 22
  23. 23. Interface fonctionnelle : fonction composée public interface ComposeFonction { public PolynomePD compose(PolynomePD x, PolynomePD y); } public static void main(String[] args) { FabriquePolynomePremierDegre fppd = (a,b) -> {return (x) -> a*x+b;}; PolynomePD p1 = fppd.donnerPolynome(1,1); PolynomePD p2 = fppd.donnerPolynome(2,5); // 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 datascience.km@gmail.comM. MICHRAFY 23
  24. 24. 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. datascience.km@gmail.comM. MICHRAFY 24
  25. 25. 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 datascience.km@gmail.comM. MICHRAFY 25
  26. 26. 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). datascience.km@gmail.comM. MICHRAFY 26
  27. 27. 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;} } datascience.km@gmail.comM. MICHRAFY 27
  28. 28. Interface Functionnelle Function (3) public class MainFunction { public static void main(String[] args) { 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 datascience.km@gmail.comM. MICHRAFY 28
  29. 29. 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. datascience.km@gmail.comM. MICHRAFY 29
  30. 30. 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); } } datascience.km@gmail.comM. MICHRAFY 30
  31. 31. Interface fonctionnelle Predicate (3) public static void main(String[] args) { 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 datascience.km@gmail.comM. MICHRAFY 31
  32. 32. 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.. datascience.km@gmail.comM. MICHRAFY 32
  33. 33. 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 datascience.km@gmail.comM. MICHRAFY 33
  34. 34. 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 + "]";} } public static void main(String[] args) { 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 datascience.km@gmail.comM. MICHRAFY 34
  35. 35. 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é. datascience.km@gmail.comM. MICHRAFY 35
  36. 36. 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 datascience.km@gmail.comM. MICHRAFY 36
  37. 37. 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 datascience.km@gmail.comM. MICHRAFY 37
  38. 38. 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(); } Méthode d’interface Constructeur Référence vers un constructeur datascience.km@gmail.comM. MICHRAFY 38
  39. 39. 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 d’interface Méthode statique Référence vers une méthode statique datascience.km@gmail.comM. MICHRAFY 39
  40. 40. Références bibliographiques • API Java 8 , documentation oracle, https://docs.oracle.com/javase/8/docs/api/ datascience.km@gmail.comM. MICHRAFY 40
  41. 41. Dr Mustapha Michrafy Data Scientist, ATOS • Contact : datascience.km@gmail.com datascience.km@gmail.comM. MICHRAFY 41

×