Apprenez à programmer en Java

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 aux "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("Jean");//Cette fois, on affichera Jean
}

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

• <liste de paramètres>  : 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.

En résumé 

• Une expression Lambda est une référence vers un bloc de code.

• Une interface fonctionnelle est une interface qui n’a qu’une seule méthode abstraite.

• On peut utiliser une expression Lambda pour implémenter une interface fonctionnelle sans déclarer de classe abstraite.

Téléchargez la fiche résumé du cours

C'est bientôt la fin de ce cours, mais avant, je vous propose un dernier quiz pour tester vos connaissances. C'est parti !