41
JAVA 8 INTERFACES FONCTIONNELLES, LAMBDA EXPRESSION, MÉTHODE PAR DÉFAUT ET RÉFÉRENCES DE MÉTHODE, AVEC DES EXEMPLES Dr Mustapha Michrafy M. MICHRAFY Contact de l’auteur : [email protected] [email protected] 1

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

Embed Size (px)

Citation preview

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

JAVA 8 INTERFACES FONCTIONNELLES, LAMBDA EXPRESSION, MÉTHODE PAR DÉFAUT ET RÉFÉRENCES DE MÉTHODE,AVEC DES EXEMPLES

Dr Mustapha Michrafy

M. MICHRAFY

Contact de l’auteur :[email protected]

[email protected]

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

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.

[email protected]. MICHRAFY 2

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

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

[email protected]. MICHRAFY 3

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

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

[email protected]. MICHRAFY 4

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

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

[email protected]. MICHRAFY 5

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

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.

[email protected]. MICHRAFY 6

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

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.

[email protected]. MICHRAFY 7

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

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) { ... }

[email protected]. MICHRAFY 8

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

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 interface avec une méthode par défaut

public interface OperationMath {

// signature de la méthode operation avec une implémentation par défaut

public default boolean operation(int x, int y){ return x+y; }

}

[email protected]. MICHRAFY 9

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

Méthode par défaut : utilisation

// déclaration d’une classe A utilisant la méthode par défautpublic class A implements OperationMath{ }

// déclaration d’une classe A qui surcharge la méthode check de l’interface Apublic 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 fonction mainA a = new A(); A b = new B(); // création des instances de A et Ba.operation(21, 11) ; // appel de la méthode par défaut déclarée dans OperationMathb.operation(21,11) ; // appel le la méthode de la classe B

}

[email protected]. MICHRAFY

public interface OperationMath {// signature de la méthode operation avec une implémentation par défaut public default boolean operation(int x, int y){ return x+y; } // addition

}

10

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

É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’interfacefille. 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 dansl’interface fille, il suffit de redéclarer la méthode avec le qualificatif“abstract ”. Dans ce cas la méthode devient une méthode abstraiteet qui nécessite une implémentation dans les classes filles.

[email protected]. MICHRAFY 11

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

Méthode par défaut : utilisationpublic interface A { public default boolean check(String x){ return (x!=null && !x.isEmpty()) ; } }

public interface B extends A{ }

public interface C extends A {

public default boolean check(String x){

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

[email protected]. MICHRAFY 12

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

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.

[email protected]. MICHRAFY 13

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

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.

[email protected]. MICHRAFY 14

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

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

[email protected]. MICHRAFY 15

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

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.

[email protected]. MICHRAFY 16

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

Interface fonctionnelle : Déclarationpublic interface NomInterface {

public valeurRetour nomMethode([Arguments]);

}

// Exemple 1 d’une déclaration d’une interface fonctionnelle

public interface OperationCheck {

// signature de la méthode check l interface fonctionnelle OperationCheck

public boolean check(String a);

}

// Exemple 2 d’une déclaration d’une interface fonctionnelle

public interface OperationMath {

// signature de la méthode operation de l interface fonctionnelle OperationMath

public int operation(int a, int b);

}

[email protected]. MICHRAFY 17

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

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};

[email protected]. MICHRAFY 18

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

Lambda expression (2) // Exemple 2 d’une déclaration d’une interface fonctionnelle

public interface OperationMath {

// signature de la méthode operation de l’interface fonctionnelle OperationMath

public int operation(int a, int b);

}

OperationMath addition = (int a, int b) -> a + b; // avec le type des arguments d’entréeOperationMath produit = (a, b) -> a * b; // sans déclaration des typesOperationMath 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

[email protected]. MICHRAFY 19

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

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 additionint p = pf.apply(a, b, produit); // utilisation du lambda expression produit

}

public class A {// appliquer prend en un entrée l’interface fonctionnelle OperationMathpublic int apply(int a, int b, OperationMath op){ return op.operation(a,b); }

}

[email protected]. MICHRAFY 20

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

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.

[email protected]. MICHRAFY 21

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

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 2double 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 + 1P2(x) : 2x + 5

[email protected]. MICHRAFY 22

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

Interface fonctionnelle : fonction composéepublic 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 gComposeFonction cf = (f,g) -> ((x)->(f.donnerY(g.donnerY(x))));double x=1;// calculer p1op2(x) et cf(p1,p2)(x) et comparerdouble 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

[email protected]. MICHRAFY 23

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

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.

[email protected]. MICHRAFY 24

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

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

[email protected]. MICHRAFY 25

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

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).

[email protected]. MICHRAFY 26

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

Interface fonctionnelle Function (2)public interface Function<T, R> {

// fonction abstraite applyR apply(T t);// fonction compose pour l’opérateur o qui retourne une fonctiondefault <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 fonctiondefault <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;}

}

[email protected]. MICHRAFY 27

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

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

[email protected]. MICHRAFY 28

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

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.

[email protected]. MICHRAFY 29

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

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);}

}

[email protected]. MICHRAFY 30

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

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 predicatsPredicate<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

[email protected]. MICHRAFY 31

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

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..

[email protected]. MICHRAFY 32

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

Interface fonctionnelle : Consumer(2)public interface Consumer <T> {

// Cette méthode un traitement sur l’objet Tvoid accept (T t);

// Cette méthode applique deux block de traitement sur l’objet Tdefault 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

[email protected]. MICHRAFY 33

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

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 andThenAppel des 3 consumers

[email protected]. MICHRAFY 34

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

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é.

[email protected]. MICHRAFY 35

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

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

[email protected]. MICHRAFY 36

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

Référence vers une méthode d’instanceinterface Distancier { public double distance (Mesure m1, Mesure m2 ) ; }

class Mesure{ 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 static void main (String [] args){Mesure m1 = new Mesure(12), m2 = new Mesure(25) ;Distancier d1 = Mesure::distance1 ; // référence vers la méthode distance1Distancier d2 = Mesure::distance2 ; // référence vers la méthode distance2System.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

[email protected]. MICHRAFY 37

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

Référence vers un constructeurinterface Fabrique<T> { public T getInstance(double x); }

class Mesure{ private double x;public Mesure (double x){ this.x = x }public String toString () { return "Mesure [x=" + x + "]"; }

}

public static void 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

[email protected]. MICHRAFY 38

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

Référence vers une méthode statiqueinterface ICompteur { public T getCompteur(); }

class Mesure{ private int compteur=0;private double x;public Mesure (double x){ this.x = x; compteur++; }public static int 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

[email protected]. MICHRAFY 39

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

Références bibliographiques• API Java 8 , documentation oracle,

https://docs.oracle.com/javase/8/docs/api/

[email protected]. MICHRAFY 40

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

Dr Mustapha MichrafyData Scientist, ATOS

•Contact : [email protected]

[email protected]. MICHRAFY 41