• 15 heures
  • Facile

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 19/05/2021

Écrivez votre premier code Lambda

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Nous avons vu dans les parties précédentes de ce cours comment instancier des variables et obtenir ainsi ce qu’on appelle une référence. Il peut s'agir :

  • d'une référence vers un type primitif, par exemple int cpt = 0; 

  • ou d'une référence vers une instance d’objet, par exemple  FigureGeo myFigureGeo  = new FigureGeo();

Dans ce chapitre, nous allons voir qu'une référence peut également porter sur un bloc de code !

Écrivez une fonction Lambda

Depuis Java 8, il est désormais possible d’obtenir une référence vers une méthode. C’est ce qu’on appelle une closure en anglais. Et en Java, c’est la fonctionnalité Lambda qui en est l’expression. Les Lambda sont une nouvelle manière d’écrire du code compact (et plus lisible).

Au-delà d'un code plus compact, un des des grands intérêts des expressions Lambda est d’avoir une alternative aux appels de méthodes à partir de classes anonymes. Sans entrer dans les détails, avant les Lambda, on utilisait souvent les classes anonymes dans le seul but de redéfinir et d’appeler la méthode d’une classe à un endroit bien précis de notre code.

Prenons un exemple :

public class MaClassPrincipale {
public static void main(String... args) {
Bird bird = new Bird() {
@Override //sert simplement à indiquer que nous redéfinissons la méthode fly()
void fly() {
System.out.println("Vole grâce à ses deux ailes...");
}
}; // Attention à ne pas oublier le “;”
// À ce moment (et uniquement à ce moment), nous redéfinissons la manière de voler d’un oiseau. Ensuite nous l'utilisons.
bird.fly(); // Va afficher "Vole grâce à ses deux ailes..."
// À noter qu’il est toujours possible de passer des paramètres à une méthode d’une classe anonyme
}
}

Bien entendu, la classe  Bird  pourrait avoir bien d’autres méthodes qu’on serait tenté d’utiliser de la même manière. Mais croyez-moi, ça devient vite ingérable et on fait l’impasse sur la force de la POO. 😉

Pour arriver au closures et utiliser les Lambda, Java 8 a introduit ce qu’on appelle les interfaces fonctionnelles. Celles-ci n’ont (ou n’auront) qu’une seule méthode abstraite. À l’exécution du code Lambda, Java fait en sorte de déterminer la méthode à appeler.

Ayez à l’esprit qu’une expression Lambda est en quelque sorte la redéfinition d'une méthode d'une interface fonctionnelle sans avoir à faire une classe anonyme.

Allez, voyons à quoi ressemble un code Lambda (une redéfinition de l’unique méthode d’une interface fonctionnelle) :

() -> action  ou

(parametre, ...) -> une action  ou

(parametre, ...) -> {traitement, retourner quelque chose} .

Voici un premier exemple :

//Votre interface “fonctionnelle”
public interface Etudiant {
void donnerNom();
}
//Utilisation
public static void main(String[] args) {
Etudiant et = () -> {System.out.println("Toto");};
et.donnerNom();//Affichera Toto
}

Un autre exemple : nous faisons évoluer l’unique méthode de l’interface fonctionnelle.

public interface EtudiantEvolue {
void donnerNom(String nom);
}
//Utilisation
public static void main(String[] args) {
EtudiantEvolue et = (leNomAafficher) -> {System.out.println(“Je me nomme+ leNomAafficher);};
et.donnerNom("Je me nomme Jean");//Cette fois, on affichera Jean
}

Une expression Lambda, c'est toujours :    <liste de paramètre> -> <le corps de la fonction> . Détaillons chaque élément :

  • <liste de paramètre>  : indique les paramètres en entrée de l'unique méthode de l'interface fonctionnelle. Ils seront saisis entre  ()  et il n'est pas obligatoire d'indiquer leurs types ;

  • ->  : c'est le marqueur de l'expression Lambda. Il sépare la liste des paramètres du corps de la fonction ;:

  • <le corps de la fonction>  : entre  {}  ou pas, s'il n'y a qu'une expression courte.

Le corps d’une expression Lambda

Le corps d'une expression Lambda est défini à droite de l'opérateur  ->. Il peut être :

  • une expression unique ;

  • un bloc de code composé d'une ou plusieurs instructions entourées par des accolades.

Le corps de l'expression doit respecter certaines règles :

  • il peut n'avoir aucune, une seule ou plusieurs instructions ;

  • lorsqu'il ne contient qu'une seule instruction, les accolades ne sont pas obligatoires et la valeur de retour est celle de l'instruction si elle en possède une ;

  • lorsqu'il y a plusieurs instructions, elles doivent obligatoirement être entourées d'accolades ;

  • la valeur de retour est celle de la dernière expression ou  void  si rien n'est retourné.

Si le corps est simplement une expression, celle-ci est évaluée et le résultat de cette évaluation est renvoyé s'il y en a un.

À vous de jouer !

Passons à la pratique ! Dans les deux vidéos de démonstration suivantes,  vous allez voir comment écrire votre propre "interface fonctionnelle" et l'utiliser dans l'écriture d'une expression Lambda.

Commençons par écrire notre interface fonctionnelle :

Poursuivons avec l'écriture d'expressions Lambda :

En résumé

Dans ce chapitre, vous avez découvert l'écriture des expressions Lambda en Java. Elles permettent de satisfaire le concept de closure en permettant d'obtenir une référence portant sur un bloc de code. Dans la vidéo de démonstration, vous verrez de manière concrète et pas à pas comment écrire votre propre "interface fonctionnelle" et l'utiliser dans l'écriture d'une expression Lambda.

Passons au dernier chapitre pour reprendre les notions que nous avons abordées dans cette troisième partie !

Exemple de certificat de réussite
Exemple de certificat de réussite