---
title: La gestion des exceptions
---
# IX. GESTION DES EXCEPTIONS
## 1. Introduction
Lorsqu’on développe des applications en Java ou dans n’importe quel autre langage informatique, on va forcément faire face aux erreurs. Même après avoir corrigé son application grâce aux tests unitaires, il y’a des situations où les bugs sont inévitables.
la sécurité d'une application peut être rendue instable par toute une série de facteurs :
- Des problèmes liés au matériel : par exemple la perte subite d'une connexion à un port, un disque défectueux...
- Des actions imprévues de l'utilisateur. Par exemple, vous ne pouvez pas toujours compter sur le fait que l’utilisateur n’essaiera pas d’effectuer une division par 0.
- Des débordements de stockage dans les structures de données...
Pendant l'exécution d'un programme, les faiblesses peuvent survenir :
- lors des entrées-sorties,
- lors de calculs mathématiques interdits (comme la division par zéro),
- lors de fausses manœuvres de la part de l’utilisateur,
- ou encore lorsque la connexion à un périphérique est inopinément interrompue,
- lors d'actions sur les données.
Le programme doit donc se **défendre** contre de tels incidents potentiels, on appel cette démarche **la programmation défensive**.
:::info
**La programmation défensive** est une attitude de pensée consistant à prévoir que le logiciel sera soumis à des défaillances dues à certains paramètres externes ou internes et donc à prévoir une réponse adaptée à chaque type de situation.
L’objectif principal est d’améliorer la qualité de **robustesse** d’un programme.
:::
En programmation défensive il est possible de protéger directement le code à l’aide de **la notion d’exception**.
L’utilisation des exceptions avec leur mécanisme intégré, autorise la construction rapide et efficace de logiciels robustes.
## 2. Rôle d'une exception ##
Les exceptions représentent le mécanisme de gestion des erreurs intégré au langage Java.
Une exception est chargée de **signaler un comportement exceptionnel** (mais prévu) d’une partie spécifique d’un programme.
Ce mécanisme se compose d'objets représentant les erreurs et d'un ensemble de mots clés qui permettent de détecter et de traiter ces erreurs mais aussi de les lever ou les propager.
Lors de la détection d'une erreur, un objet qui hérite de la classe **Exception** est créé (on dit qu'**une exception est levée**) et propagé à travers la pile d'exécution jusqu'à ce qu'il soit traité.
Par exemple, si on exécute le programme suivant:
```java=
public class TestExceptions {
public static void main(String[] args) {
String str = null;
int len = str.length();
}
}
```
on obtient une sortie telle que la suivante:
```java=
Exception dans le thread "principal" java.lang.NullPointerException
à test.TestExceptions.main(TestExceptions.java:4)
```
Si une exception se produit sans être capturée nulle part, le programme se termine et affiche un message donnant le type de l’exception ainsi qu’une **trace de la pile** (**stack trace**).
Si notre programme a appelé plusieurs méthodes avant de rencontrer un problème, **la trace de la pile** peut nous aider à suivre la trace de notre programme et à trouver la ligne qui a causé l'erreur.
Elle montre la séquence des appels de méthodes effectués jusqu'au moment où l'erreur d'exécution s'est produite.
## 3. Hiérarchie des exceptions en java
En Java, les exceptions sont représentées par des objets de classe **Throwable** dans le package **java.lang**. C'est la classe de base pour le traitement des erreurs.
Elle a deux sous-classes **Error** et **Exception**:
- La classe **Error** représente une erreur grave intervenue dans la machine virtuelle Java ou dans un sous système Java. L'application Java s'arrête instantanément dès l'apparition d'une exception de ce type. Ces exceptions sont considérées comme **non récupérables**, les appelants n'ont pas à les gérer explicitement.
- La classe **Exception** représente des erreurs moins graves, elle est considérée comme récupérable.
Cependant, les objets de la sous-classe **RuntimeException** d'Exception **ne sont pas obligatoirement récupérables**. Ces exceptions sont dites **non contrôlées (unchecked)** parce que le compilateur ne vérifie pas comment elles sont traitées. Elle comporte les exceptions: ArithmeticException, ArrayStoreException, NullPointerException, IndexOutOfBoundsException, ...
Les autres sous-classes de la classe **Exception** sont formées d'exceptions qui **doivent être récupérées** tel que: FileNotFoundException, UnknownHostException, InterruptedException, etc. Ces exceptions sont dites **contrôlées (checked)** parce que le compilateur vérifie comment elles sont traitées.
:::info
Les exceptions définies par le programmeur sont des sous-classes de **Exception**, elles sont donc contrôlées.
:::
## 4. Interception et traitement des exceptions avec try/catch
Lorsqu’une portion de code est susceptible de lancer/lever une exception, il est possible de capturer cette potentielle exception et indiquer le traitement qui doit en être fait.
La capture d’une exception en Java se fait à l’aide du bloc de mots clés **try … catch**
```java=
try {
// les instructions susceptibles de provoquer des exceptions
// incluant éventuellement des appels de methodes
} catch (ExceptionType ex ) {
//les instructions pour gérer cette exception
//(lignes de code réagissant à l’exception ExceptionType)
}
```
Le **bloc try** rassemble les appels de méthodes susceptibles de produire des erreurs ou des exceptions.
Si un événement indésirable survient dans le **bloc try**, la partie non exécutée de ce bloc est abandonnée et le **bloc catch** est traité.
:::info
Le type **ExceptionType** est obligatoirement une classe qui hérite de la classe **Exception**.
:::
Par exemple, l'exécution du programme suivant:
```java=
public static void main(String[] args) {
int tab[] = {1,2,3,4};
try{
tab[4] = 3;
} catch(ArrayIndexOutOfBoundsException ex ){
System.out.println("Erreur d'index");
}
}
```
affiche à la console Erreur d’index:
```java=
Java.lang.ArrayIndexOutOfBoundsException: Index 4 out of bounds for length 4
at TestException.main(...)
```
:::info
Si aucune des instructions du bloc **try** ne lance une exception, le programme ignore la clause **catch**.
:::
## 5. Gérer des exceptions multiples
On peut capturer des exceptions multiples dans un bloc **try** et les gérer ensuite différemment.
Il faut utiliser dans ce cas une **clause catch spécifique à chaque type d'exception**.
Ce mécanisme fonctionne comme un **sélecteur ordonné**, ce qui signifie qu'une **seule clause d'interception est exécutée**.
Dans l’exemple suivant, on prend les deux entrées de type int de l’utilisateur, puis les divisons pour afficher le résultat.
```java=
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
try {
System.out.println("num1: ");
int num1 = sc.nextInt();
System.out.println("num2: ");
int num2 = sc.nextInt();
int dividedNum = num1 / num2;
System.out.println("Résultat de la division: " + dividedNum);
} catch (InputMismatchException e1) {
System.out.println("Erreur! - Entrez un numéro.");
} catch (ArithmeticException e2) {
System.out.println("Erreurr! - Division par 0");
}
}
```
Plusieurs exceptions peuvent être levées comme *InputMismatchException* lorsque la valeur saisie n’est pas de type int et **ArithmeticException** lorsque num2 obtient la valeur zéro car aucun nombre n’est divisé par zéro.
Pour les intercepter toutes les deux, on ecrit deux blocs catch différents avec leurs types d’exception.
Chaque bloc catch est **spécifique à un type d'exception** et englobant le tratement approprié .
:::info
lorsqu’il y a une hiérarchie entre les exceptions à intercepter, on choisira de placer le code de leurs blocs catch dans **l’ordre inverse de la hiérarchie**.
:::
### Gérer plusieurs exceptions dans un bloc catch:
A partir Java SE 7, on peut désormais intercepter plusieurs types d'exceptions dans un **seul bloc catch** en leur applicant le même traitement.
Chaque type d'exception pouvant être gérée par le bloc catch est séparé à l'aide d'une pipe **|**.
```java=
try {
// code
} catch (ExceptionType1 | Exceptiontype2 ex) {
// catch block
}
```
La capture de plusieurs exceptions dans un seul bloc catch réduit la duplication de code et augmente l'efficacité.
Le bytecode généré lors de la compilation de ce programme sera plus petit que le programme ayant plusieurs blocs catch car il n'y a pas de redondance de code. Comme le montre l'exemple suivant:
```java=
public static void main(String[] args) {
try {
int array[] = new int[10];
array[10] = 30 / 0;
} catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
System.out.println(e.getMessage());
}
}
```
## 6. La clause Finally
Une clause **finally** est généralement incluse pour s’assurer que certaines opérations de nettoyage (par exemple, la fermeture des fichiers ouverts) sont effectuées.
Une clause **finally** s’exécute **toujours** lorsque son bloc **try** s’exécute (qu’il y ait ou non une exception).
```java=
public static void main(String[] args) {
int tab[] = {1,2,3,4};
try{
tab[4] = 3;
} catch(ArrayIndexOutOfBoundsException ex ){
System.out.println("Erreur d'index");
}finally{
System.out.println("Les instructions du bloc Finally");
}
System.out.println("Suite du programme");
}
```
Voici les situations qui peuvent se présenter :
- Aucune exception ne se produit pendant l’exécution du try. **La clause finally s’exécute, puis la suite du programme**.
- Aucune exception ne se produit pendant l’exécution du try, mais le block try contient un **transfert de contrôle** (return, break, continue, throw). **La clause finally s’exécute, puis le transfert de contrôle aura lieu**.
- Une exception se produit pendant l’exécution du try, et il existe une clause catch pour cette exception. **La clause catch s’exécute, puis la clause finally, puis le reste du programme**.
- Une exception se produit pendant l’exécution du try, mais il n’y a pas de clause catch pour cette exception. **La clause finally s’exécute, puis l’exception non attrapée est levée**.
- Une exception se produit pendant l’exécution du try, il y a une clause catch pour cette exception, et la clause catch exécute un transfert de contrôle. **La clause catch s’exécute, puis la clause finally, puis le transfert de contrôle a lieu**.
## 7. Déclenchement des exception
Il est possible de déclencher soi-même des exceptions en utilisant l'instruction **throw**, voir même de déclencher des exceptions personnalisées ou non
La JVM peut aussi lever (déclencher/lancer) une exception à votre demande suite à la rencontre d'une instruction throw.
La syntaxe est:
```java=
throw new ExceptionALever();
```
Les sous-classes de Throwable possèdent un second constructeur qui accepte un argument de type chaîne. On peut en profiter pour décrire plus en détail la situation d’exception:
```java=
throw new ExceptionALever("message explicatif");
```
Comme le montre l'exemple suivant:
```java=
public static void main(String args[]){
// Déclencher (lever) l'exception NullPointerException
throw new NullPointerException("demo");
}
```
Ou encore son équivalent:
```java=
public static void main(String args[]){
// instancier un objet de type NullPointerException
NullPointerException ex= new NullPointerException("demo");
// Déclencher (lever) l'exception de type NullPointerException
throw ex;
}
```
Ici, NullPointerException est une exception non contrôlée. Il n'est généralement pas nécessaire de gérer les exceptions non contrôlées.
Dans le cas d'une exception controlée:
```java=
public static void main(String[] args) {
try {
// Déclencher l'exception de type IOException
throw new IOException("File not found");
System.out.println("le reste du code du bloc Try");
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
```
puisqu'il s'agit d'une exception vérifiée (contrôlée), le compélateur nous force à l'intercepter avec le bloc try catch.
Il est possible de repropager une exception qui a été gérée par une instruction catch en utilisant le mot clé throw:
```java=
try {
// Déclencher l'exception de type IOException
throw new IOException("File not found");
System.out.println("le reste du code du bloc Try");
} catch (IOException e) {
throw e;
}
```
## 8. Propager une Exception
Le déclenchement d'une exception provoque d'une part la sortie immédiate de la méthode, et d'autre part le dépilage des appels jusqu'à ce qu'apparaisse un cadre d'invocation d'une méthode contenant un catch.
L'exception est donc propagée le long de la chaîne des invocations tant qu'elle n'est pas récupérée.
Ce mécanisme de propagation est distinct du mécanisme usuel de retour d'une méthode. Si l'exception n'est jamais récupérée, le programme termine anormalement.
**throws** est un mot clé en Java qui est utilisé dans **la signature de la méthode** pour indiquer que cette méthode peut lever l'une des exceptions de type verifiées.
```java=
type method_name(parameters) throws exception_list
// exception_list est une liste séparée par des virgules de tous les
// exceptions qu'une méthode peut lever.
```
L'appelant de cette méthode doit gérer l'exception à l'aide:
- Soit d'un bloc **try-catch**
- Soit en utilisant le mot clé **throws**
Dans le programme suivant, en utilisant le mot-clé throws, on a géré **InterruptedException**:
```java=
// Déléguer une exception de type IllegalAccessException
static void fun() throws IllegalAccessException{
System.out.println("Inside fun(). ");
// Déclencgerv une exception de type IllegalAccessException
throw new IllegalAccessException("demo");
}
public static void main(String args[]){
try{
fun();
}
catch(IllegalAccessException e){
System.out.println("caught in main.");
}
}
```
## 9. Exceptions personnalisées
Java nous offre la possibilité de créer nos propres exceptions qui sont essentiellement des classes dérivées de la classe **Exception**.
La création de notre propre exception est connue sous le nom d'**exception personnalisée**.
Fondamentalement, les exceptions personnalisées sont utilisées pour personnaliser l'exception en fonction des besoins de l'utilisateur.
Afin de créer une **exception personnalisée**, on doit étendre la classe **Exception** qui appartient au package **java.lang**.
Par exemple, la classe MonException dans le code ci-dessous étend la classe Exception:
```java=
// La lasse representant une exception personalisée
class MonException extends Exception {
public MonException(String s)
{
// Appel du constructeur de la classe mère
super(s);
}
}
// La lasse utilisant une exception personalisée
public class Main {
public static void main(String args[]) {
try {
// Déclencher l'exception personalisée MonException
throw new MyException("message");
}
catch (MyException ex) {
// afficher le message de l'objet MonException
System.out.println(ex.getMessage());
}
}
}
```
### Pourquoi utiliser des exceptions personnalisées ?
Les exceptions Java couvrent presque tous les types généraux d'exceptions qui peuvent survenir dans la programmation. Cependant, nous devons parfois créer des exceptions personnalisées
pour des raisons suivantes:
- Pour intercepter et fournir un traitement spécifique à un sous-ensemble d'exceptions Java existantes.
- Exceptions de logique métier : il s'agit des exceptions liées à la logique métier et au workflow. Il est utile pour les utilisateurs de l'application ou les développeurs de comprendre le problème exact.
## 10. Instruction try-with-resources
Des ressources comme des fichiers, des flux, des connexions, ... doivent être fermées explicitement par le développeur pour libérer les ressources sous-jacentes qu'elles utilisent.
Généralement cela est fait en utilisant un bloc **finally** pour garantir leur fermeture dans la quasi-totalité des cas.
A partir Java 7, l'instruction **try avec ressource** permet de définir une ressource qui sera automatiquement fermée à la fin de l'exécution du bloc de code de l'instruction.
Ce mécanisme est aussi désigné par l'acronyme **ARM** (Automatic Ressource Management).
Sa syntaxe est:
```java=
try (resource declaration) {
// Utilisation de la ressource
} catch (ExceptionType ex) {
// catch block
}
```
Comme le montre la syntaxe ci-dessus, on déclare l'instruction **try-with-resources** par:
1. déclarer et instancier la ressource dans la **clause try**.
2. spécifiant et gérant, dans le bloc **catch**, toutes les exceptions qui pourraient être levées lors de la fermeture de la ressource.
:::info
:bulb: L'instruction **try-with-resources** ferme toutes les ressources qui implémentent l'interface **AutoCloseable** .
:::
Prenons un exemple qui implémente l'instruction try-with-resources:
```java=
public static void main(String[] args) {
String line;
try(BufferedReader br = new BufferedReader(new FileReader("test.txt"))) {
while ((line = br.readLine()) != null) {
System.out.println("Line =>"+line);
}
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
```
Dans cet exemple, on a déclaré et instancié le BufferedReader à l'intérieur de l'instruction try-with-resources pour garantir que son instance soit fermée dans le cas où l'instruction try se termine normalement ou dans le cas d'une exception.
# X. INTERFACE FONCTIONNELLE & EXCEPTIONS LAMBDA
## 1. Interface fonctionnelle
Les interfaces fonctionnelles ont été introduites en Java 8.
Une interface fonctionnelle en Java est une interface qui **ne contient qu’une seule méthode abstraite** (non implémentée)
```java=
public interface Operation {
public int calculer(int x);
}
```
Une interface fonctionnelle peut contenir **des méthodes par défaut et statiques** qui ont une implémentation, en plus de la méthode unique non implémentée.
```java=
public interface Operation {
public int calculer(int x);
public default int addition(int a, int b) {
return a + b;
}
public static int soustraction(int a, int b) {
return a - b;
}
}
```
L’interface ci-dessus compte toujours comme une interface fonctionnelle, car elle ne contient qu’une seule méthode non implémentée.
### Annotation @FunctionalInterface :
L’annotation **@FunctionalInterface** est utilisée pour s’assurer que l’interface fonctionnelle ne peut pas avoir plus d’une méthode abstraite.
Si plusieurs méthodes abstraites sont présentes, le compilateur signale un message **"Unexpected @FunctionalInterface annotation"**.
```java=
@FunctionalInterface
public interface Operation {
public int calculer(int x);
}
```
:::info
Cependant, il n'est pas obligatoire d'utiliser cette annotation.
:::
## 2. Les expressions lambda en Java
Java est un langage orienté objet : à l'exception des instructions et des données primitives, tout le reste est objets, même les tableaux et les chaînes de caractères.
Java ne propose pas la possibilité de définir une fonction/méthode en dehors d'une classe ni de passer une telle fonction en paramètre d'une méthode.
Pour faciliter cette mise à oeuvre, **Java 8** propose les expressions lambda.
Une expression lambda est une **fonction anonyme**, c’est-à-dire une fonction qui est déclarée sans être associée à un nom.
le but principal des expressions lambda est de permettre de passer en paramètre un ensemble de traitements.
Elles permettent d’écrire des programmes plus concis et elles permettent de créer des **closures** (fermetures)
Le terme **lambda** est emprunté à la méthode formelle du **lambda-calcul**. Les fonctions lambda sont utilisées dans **la programmation fonctionnelle**.
:::info
:bulb: Dans **la programmation fonctionnelle**, le résultat de traitements est décrit mais pas la façon dont ils sont réalisés. Ceci permet de réduire la quantité de code à écrire pour obtenir le même résultat.
- Avant Java 8, la seule solution était d'utiliser une classe anonyme interne:
```java=
monBouton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
System.out.println("clic");
}
});
```
- Avec Java 8, il est possible d'utiliser une expression lambda:
```java=
monBouton.addActionListener(event -> System.out.println("clic"));
```
:::
Une expression lambda est une **fonction anonyme**, sa définition se fait sans:
- la déclaration explicite du **type de retour**,
- ni de modificateurs d'accès
- ni de nom.
C'est un raccourci syntaxique qui permet de définir une méthode directement à l'endroit où elle est utilisée. Une expression lambda est donc une fonction qui peut être créée sans appartenir à aucune classe.
Une expression lambda permet d'encapsuler un traitement pour être passé à d'autres traitements. Elle peut être transmise comme s’il s’agissait d’un objet et exécutée à la demande.
Elle est particulièrement utile notamment lorsque le traitement n'est utile qu'une seule fois car elle évite d'avoir à écrire une méthode dans une classe.
Une expression lambda est traitée comme une fonction, donc le compilateur ne crée pas de fichier **.class** et infère le type vers l'interface fonctionnelle pour obtenir des informations sur les paramètres utilisés, le type de la valeur de retour, les exceptions qui peuvent être levées.
Les expressions lambda Java sont couramment utilisées pour implémenter des listeners/callbacks, ou dans la programmation fonctionnelle avec l’API Java Stream.
:::warning
Pour résumer, les expressions lambda fournissent les fonctionnalités ci-dessous:
- Traiter la fonctionnalité en tant qu'argument de méthode ou code en tant que donnée.
- Une fonction qui peut être créée sans appartenir à aucune classe.
- Une expression lambda peut être transmise comme s'il s'agissait d'un objet et exécutée à la demande.
:::
### Syntaxe d'une expression lambda:
L'expression lambda introduit un nouvel élément de syntaxe et un nouvel opérateur en langage Java.
Le nouvel opérateur est appelé **opérateur lambda** ou **opérateur flèche** **(->)**.
```java=
(paramètres) -> { traitements; }
```
Dans l'expression lambda:
- le côté gauche de l'expression spécifie les paramètres requis par l'expression (arguments de la méthode).
- tandis que le côté droit correspond au corps lambda, qui spécifie l'action (tratements) de l'expression lambda.
Écrivons une méthode simple qui renvoie simplement une valeur double constante:
```java=
public double getPi() {
return 3.1415;
}
```
L'expression lambda équivalente pour la méthode ci-dessus est:
```java=
() -> 3.1415
```
Si corps lambda est un bloc de code, vous devez toujours retourner une valeur explicite. Mais, si corps lambda est juste une expression, déclaration de retour n'est pas nécessaire.
```java=
() -> {
double pi = 3.1415;
return pi;
}
```
Liste d’arguments peut être:
- Zéro paramètre:
```java=
() -> System.out.println("Zéro paramètre");
```
- Un seul paramètre:
```java=
(a) -> System.out.println("Un seul paramètre: " + a);
```
- Plusieurs paramètres:
```java=
(a, b) -> System.out.println("Plusieurs paramètres: " + a + ", " + b);
```
### Caractéristiques importantes d’une expression lambda:
- **Type facultative** : Pas besoin de déclarer le type d’un paramètre. Le compilateur peut déduire le type de la valeur du paramètre.
```java=
//avec la déclaration de type
(int x, int y) -> x + y;
```
```java=
//sans déclaration de type
(x, y) -> x - y;
```
- **Parenthèse facultative autour du paramètre** :
- Pas besoin de déclarer un seul paramètre entre parenthèses.
```java=
x -> x - 5;
```
- Si vous avez plusieurs paramètres, des parenthèses sont requises.
```java=
(x, y) -> x - y;
```
- **Accolades facultative** :
- Pas besoin d’utiliser des accolades dans le corps d’une expression si le corps contient une seule instruction.
```java=
() -> 3.1415
```
- Si le corps contient plusieurs instructions, des accolades sont requises.
```java=
() -> {
double pi = 3.1415;
return pi;
}
```
- **Le mot clé "return" :**
- Le mot clé « return » est facultatif, Le compilateur renvoie automatiquement la valeur si le corps a une seule expression.
```java=
//sans 'return' et sans les accolades
(int x, int y) -> x / y;
```
- Si on ajoute le mot clé "return", des accolades sont nécessaires pour indiquer que l’expression renvoie une valeur.
```java=
//avec 'return' et les accolades
(int x, int y) -> {
return x * y;
};
```
### Implémentation d'une interface fonctionnelle par une expression Lambda :
L'expression lambda n'est pas exécutée seule. Au contraire, elle constitue la mise en oeuvre de la méthode abstraite définie par l'interface fonctionnelle.
Une expression lambda ne peut être utilisée que dans un contexte où le compilateur peut identifier l'utilisation de son **type cible** (**target type**) qui doit être une **interface fonctionnelle**
<div class="page-break"></div>
```java=
@FunctionalInterface
interface FuncInterface {
// méthode abstraite
public void methAbstraite(int x);
// méthode par defaut
public default void methodeDefault() {
System.out.println("Hello");
}
}
public class Test {
public static void main(String args[]) {
// nous affectons l'expression lambda à
// l'instance de l'interface fonctionnelle
FuncInterface s = (int x) -> System.out.println(2 * x);
s.methAbstraite(5);
s.methodeDefault();
}
}
```
Avant **Java 8**, pour créer un objet de type FuncInterface, on doit l'instnancier puis implémenter sa méthode abstraite, qui était assez longue et compliquée.
```java=
public class Test {
public static void main(String args[]) {
// on instancie FuncInterface en implémentant la méthode abstraite
FuncInterface s = new FuncInterface(){
@Override
public void methAbstraite(int x){
System.out.println(2 * x);
}
}
s.methAbstraite(5);
s.methodeDefault();
}
}
```
:::info
:bulb: Une expression Lambda n’implémente qu’une seule méthode à partir d’une interface Java. Afin de savoir quelle méthode l’expression Lambda implémente, l’interface ne peut contenir qu’une seule méthode non implémentée. En d’autres termes, l’interface doit être une **interface fonctionnelle**.
:::
Une expression lambda sera transformée par le compilateur en une **instance** du type de son **interface fonctionnelle** (**target type**) selon le contexte dans lequel elle est définie :
- soit celle du type à laquelle l'expression est assignée
```java=
//le type cible de l'expression lambda est l'interface fontionnelle ActionListener
ActionListener monAction = event -> System.out.println("clic");
```
- soit celle du type du paramètre à laquelle l'expression est passée
```java=
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
//le type cible de l'expression lambda est l'interface fontionnelle Consumer<T>
list.forEach(x-> System.out.println(x) );
```
L'expression lambda ne contient pas elle-même d'information sur l'interface fonctionnelle qu'elle implémente. Cette interface sera déduite par le compilateur en fonction de son contexte d'utilisation.
### La portée des variables
Une expression lambda se comporte syntaxiquement comme un bloc de code imbriqué.
Comme pour les classes anonymes internes, une expression lambda peut avoir accès à certaines variables définies dans le contexte englobant.
Dans le corps d'une expression lambda, il est donc possible d'utiliser :
- les variables passées en paramètre de l'expression
```java=
FuncInterface s = (int x) -> x*2;
```
- les variables définies dans le corps de l'expression
```java=
FuncInterface s = (int x) -> {
int a=15*x;
return a;
};
```
- les **variables final** définies dans le contexte englobant:
```java=
final int compteur=0;
FuncInterface s = (int x) -> {
int a=15* compteur;
return a;
};
```
- les **variables effectivement final** définies dans le contexte englobant. Ces variables ne sont pas déclarées final mais une valeur leur est assignée et celle-ci n'est jamais modifiée:
```java=
int compteur=0;
FuncInterface s = (int x) -> {
int a=15* compteur;
return a;
};
```
Les paramètres de la méthode englobante ne sont pas déclarées final mais elles sont **effectivement final** donc elles sont utilisables dans l'expression lambda.
```java=
public void afficher(String message, int repetition) {
//nous affectons l'expression lambda à l'instance de l'interface fonctionnelle
Runnable r = () -> {
for (int i = 0; i < repetition; i++) {
System.out.println(message);
}
};
}
```
:::success
L'accès aux variables du contexte englobant est limité par une contrainte forte : **seules les variables dont la valeur ne change pas peuvent être accédées**.
:::
Une erreur de compilation est obtenue si la modification est faite **dans le contexte englobant** de l'expression lambda:
```java=
int compteur=0;
compteur++;
FuncInterface s = (int x) -> {
int a=15* compteur;// erreur de compilation
return a;
};
```
L même erreur de compilation est obtenue si la modification est faite **dans le corps de l'expression lambda**:
```java=
int compteur=0;
FuncInterface s = (int x) -> {
int a=15* compteur++; // erreur de compilation
return a;
};
```
:::info
:bulb: Par contre, Il est possible de passer en paramètre un **objet mutable** et de modifier l'état de cet objet. Le compilateur vérifie simplement que **la référence que contient la variable ne change pas**.
```java=
int[] compteur={1};
FuncInterface s = (int x) -> {
int a=15* compteur[0]++;
return a;
};
```
:::
## 3. Références de méthodes en Java 8
Les références de méthodes permettent d'offrir une syntaxe simplifiée pour invoquer une méthode comme une **expression lambda**.
elles offrent un raccourci syntaxique pour créer une expression lambda dont le but est d'invoquer une méthode ou un constructeur.
Une expression lambda correspond à une **méthode anonyme** dont le type est défini par une **interface fonctionnelle**. Les références de méthodes ont un rôle similaire mais au lieu de fournir une implémentation, une référence de méthode permet d'invoquer une méthode statique ou non ou un constructeur.
Les références de méthodes ou de constructeurs utilisent le nouvel **opérateur "::"**.
Il existe trois types de références de méthode:
- Référence à une méthode statique.
- Référence à une méthode d’instance.
- Référence à une méthode d’une instance arbitraire d’un type
- Référence à un constructeur.
### :small_blue_diamond: Référence à une méthode statique
La référence à une méthode statique permet d'invoquer une méthode statique d'une classe.
Si une expression lambda appelle simplement une méthode statique d’une classe
```java=
(args) -> NomClass.methodeStatic(args)
```
Raccourci si une expression lambda appelle simplement une méthode statique d’une classe
```java=
NomClass::methodeStatic
```
Dans l’exemple suivant, on définit une interface fonctionnelle et référant une méthode statique à sa méthode fonctionnelle show():
```java=
// Interface fonctionnelle
interface Msg{
void show();
}
public class MyClass {
//Méthode static
public static void showMsg(){
System.out.println("Bonjout tout le monde!");
}
public static void main(String[] args) {
// Référence à une méthode statique
Msg msg = MyClass::showMsg;
// Appeler méthode de l'interface
msg.show();
}
}
```
### :small_blue_diamond: Référence à une méthode d'une instance
La référence d'une méthode d'instance permet d'offrir un raccourci syntaxique pour invoquer une méthode d'un objet.
Si une expression Lambda ressemble à :
```java=
(args) -> nomObj.methodeInstance(args)
```
La référence de la méthode d'une instance est comme suit :
```java=
nomObj::methodeInstance
```
Dans l’exemple suivant, on décrit le processus de référencement d’une méthode d’instance. On peut référencer des méthodes par objet de classe et objet anonyme:
```java=
// Interface fonctionnelle
interface Msg{
void show();
}
public class MyClass {
//Méthode non-static
public void showMsg(){
System.out.println("Bonjout tout le monde!");
}
public static void main(String[] args) {
// Création d'objet
MyClass obj = new MyClass();
//Référence à une méthode non statique à l'aide d'une référence
Msg msg1 = obj::showMsg;
// Appeler méthode de l'interface
msg1.show();
//Référence à une méthode non statique à l'aide d'un objet anonyme
Msg msg2 = new MyClass()::showMsg;
// Appeler méthode de l'interface
msg2.show();
}
}
```
### :small_blue_diamond: Référence à une méthode d'une instance arbitraire d'un type
Une référence à une méthode d'instance sur un objet arbitraire d'un type permet d'invoquer une méthode d'une instance qui est précisée dans le premier paramètre fourni.
Si une expression Lambda ressemble à :
```java=
(obj, args) -> obj.instanceMethod(args)
```
Le raccourci de la référence à une méthode d'une instance arbitraire d'un type:
```java=
ObjectType::instanceMethod
```
Ce type de référence de méthodes ne précise pas explicitement l'objet sur lequel la méthode sera invoquée. C'est le premier paramètre de la méthode de l'interface fonctionnelle qui correspond à ce récepteur:
```java=
public static void main(String[] args) {
String[] fruits = {"Melon", "abricot", "fraise", "cerise", "mytille"};
// Référence à une methode d'un objet de type String
Arrays.sort(fruits, String::compareToIgnoreCase);
}
```
L'exemple ci-dessous est le même exemple dans lequel l'utilisation d'une référence de méthode est remplacée par une expression lambda.
```java=
public static void main(String[] args) {
String[] fruits = {"Melon", "abricot", "fraise", "cerise", "mytillee"};
// Utilisation d'une expression Lambda
Arrays.sort(fruits, (s1, s2) -> s1.compareToIgnoreCase(s2) );
}
```
### :small_blue_diamond: Référence à un constructeur
On peutréférencer un constructeur en utilisant le mot-clé "**new**".
On fait référence au constructeur à l’aide de l’interface fonctionnelle.
Si une expression Lambda ressemble à :
```java=
// Si une expression lambda crée simplement un objet
(args) -> new NomClasse(args);
```
La syntaxe d'une référence à un constructeur est de la forme :
```java=
NomClasse::new
```
Il est inutile de préciser la surcharge du constructeur qui sera invoquée : le compilateur la détermine selon le contexte.
La surcharge utilisée sera celle dont les paramètres correspondent le mieux à ceux de la méthode de l'interface fonctionnelle.
Une référence à un constructeur peut être passée en paramètre ou assignée à une variable d'un type d'une interface fonctionnelle.
```java=
public static void main(String[] args) {
Supplier<Personne> supplier = Personne::new;
System.out.println(supplier.get());
}
```
C'est équivalent à l'exemple ci-dessous qui utilise une expression lambda:
```java=
public static void main(String[] args) {
Supplier<Personne> supplier = () -> new Personne();
System.out.println(supplier.get());
}
```
Il est possible d'invoquer un constructeur possédant des paramètres , il faut pour cela que la méthode de l'interface fonctionnelle possède les paramètres qui correspondent à ceux du constructeur invoqué.
```java=
@FunctionalInterface
public interface PersonneSupplier {
Personne creerInstance(String nom, String prenom);
}
public class ProgrammePrincipal {
public static void main(String[] args) {
PersonneSupplier supplier = Personne::new;
Personne personne = supplier.creerInstance("TOTO", "Titi");
System.out.println(personne);
}
}
```
Cet exemple est équivalent à l'exemple suivant qui utilise une expression lambda:
```java=
public class TestConstructeurReference {
public static void main(String[] args) {
PersonneSupplier supplier = (nom, prenom) -> new Personne(nom, prenom);
Personne personne = supplier.creerInstance("TOTO", "Titi");
System.out.println(personne);
}
}
```
Le constructeur qui sera invoqué dépend du contexte d'exécution, le compilateur va inférer les types des paramètres définis dans la méthode de l'interface fonctionnelle pour rechercher le constructeur possédant les mêmes types de paramètres.
## 4. Les Interfaces Fonctionnelles courantes:
Le package **java.util.function** de **Java 8** contient de nombreuses interfaces fonctionnelles intégrées telles que:
### :small_blue_diamond: Consumer:
**Consumer** est une **interface fonctionnelle**, représentant une opération qui accepte un paramètre d'entrée et ne renvoie rien.
La définition de l'interface Consumer:
```java=
@FunctionalInterface
public interface Consumer<T> {
void accept(T t);
default Consumer<T> andThen(Consumer<? super T> after) {
Objects.requireNonNull(after);
return (T t) -> {
accept(t);
after.accept(t);
};
}
}
```
Il a une méthode abstraite appelée **accept()** et une méthode par défaut **andThen()** .
Comme **Consumer** est une interface fonctionnelle, elle peut donc être utilisée comme cible d'affectation pour les expressions lambda .
```java=
public static void main(String args[]){
// Consumer to display a number
Consumer<Integer> display = a -> System.out.println(a);
// Implement display using accept()
display.accept(10);
}
```
La méthode **forEach** de **Iterable** ou **Stream** accepte un **Consumer** comme paramètre.
```java=
public void forEach(Consumer<? super T> action);
```
On peut l'utiliser dans la méthode List.forEach.
```java=
public static void main(String[] args) {
List<String> words = Arrays.asList("falcon", "wood", "rock", "forest");
words.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
}
```
Consumer peut être simplifié:
- avec une expression lambda
```java=
public static void main(String[] args) {
List<String> words = Arrays.asList("falcon", "wood", "rock", "forest");
words.forEach(s -> System.out.println(s));
}
```
- ou une référence de méthode. Si une méthode dispose d'un seul paramètre et ne renvoie rien, sa référence peut être considérée comme un Consumer.
```java=
public static void main(String[] args) {
List<String> words = Arrays.asList("falcon", "wood", "rock", "forest");
words.forEach(System.out::println);
}
```
#### la méthode andThen():
La méthode **andThen(after)** renvoie un Consumer associé.
D'abord, Consumer actuel sera convoqué et after sera appelé par la suite.
```java=
public static void main(String[] args) {
Consumer<String> c = text -> System.out.println(text.toLowerCase());
Consumer<String> after = text -> System.out.println(text.toUpperCase());
c.andThen(after).accept("BonJour");
}
```
:::info
- Si une erreur se produit dans l'une de deux étapes ci-dessus, l'erreur sera transférée à l'appelant.
- Si une erreur se produit au niveau de Consumer actuel, donc after est ignoré.
:::
### :small_blue_diamond: Predicate:
L'interface **Predicate** est une interface fonctionnelle. Elle a une seule méthode abstraite **test** qui accepte un paramètre d'entrée et renvoie une valeur booléenne comme résultat pour l'argument spécifié.
La définition de l'interface **Predicate**:
```java=
@FunctionalInterface
public interface Predicate<T> {
boolean test(T t);
default Predicate<T> and(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) && other.test(t);
}
default Predicate<T> negate() {
return (t) -> !test(t);
}
default Predicate<T> or(Predicate<? super T> other) {
Objects.requireNonNull(other);
return (t) -> test(t) || other.test(t);
}
static <T> Predicate<T> isEqual(Object targetRef) {
return (null == targetRef)
? Objects::isNull
: object -> targetRef.equals(object);
}
}
```
Un programme java simple pour illustrer l'utilisation d'un prédicat:
```java=
public static void main(String[] args) {
// Création d'un predicate
Predicate<Integer> lesserthan = i -> (i < 18);
// Appel de la méthode du prédicat
boolean resultat=lesserthan.test(10);
System.out.println(resultat);
}
```
On peut également passer Predicate comme argument d'une méthode
```java=
public static void main(String[] args) {
boolean resultat = greaterCheck(200, p -> p > 100);
System.out.println(resultat);
}
// Une methode qui accpete un Predicate comme paramètre
public static boolean greaterCheck(int number, Predicate<Integer> predicate) {
return predicate.test(number);
}
```
#### La methode and():
Elle renvoie un Predicate qui exécute en séquence l'instance courante et celle fournie en paramètre en effectuant un **ET logique** sur leurs résultats.
```java=
public static void main(String[] args) {
Predicate<Integer> predicate1 = i -> i > 100;
Predicate<Integer> predicate2 = i -> i < 300;
// chainer deux predicate avec la methode and()
Predicate<Integer> andPredicate = predicate1.and(predicate2);
// Appel de la méthode test du predicate final
boolean resultat = andPredicate.test(200);
System.out.println("200 entre 100 et 300: "+ resultat);
}
```
Si le prédicat courant est false alors celui fourni en paramètre n'est pas évalué.
Une exception levée par l'un des deux est propagée à l'appelant.
Si une exception est levée lors de l'exécution du premier prédicat, le second n'est pas évalué.
#### La méthode or():
Elle renvoie un Precidate qui exécute en séquence l'instance courante et celle fournie en paramètre en effectuant un **OU logique** sur leurs résultats.
```java=
public static void main(String[] args) {
Predicate<Integer> predicate1 = i -> i > 100;
Predicate<Integer> predicate2 = i -> i < 50;
// chainer deux predicate avec la methode or()
Predicate<Integer> orPredicate = predicate1.or(predicate2);
// Appel de la méthode test du predicate final
boolean resultat = orPredicate.test(30);
System.out.println("(30 > 100) ou (30 < 50): "+ resultat);
}
```
Si le prédicat courant est **true** alors celui fourni en paramètre n'est pas évalué.
Une exception levée par l'un des deux est propagée à l'appelant.
Si une exception est levée lors de l'exécution du premier prédicat, le second n'est pas évalué.
#### La méthode negate():
Elle renvoie un Predicate qui exécute l'instance courante en effectuant un **NOT logique** sur son résultat
```java=
public static void main(String[] args) {
Predicate<Integer> predicate = i -> i > 100;
Predicate<Integer> negatePredicate = predicate.negate();
// Appel de la méthode test() de negatePredicate
boolean resultat = NegatePredicate.test(30);
System.out.println("30 is less than 100: "+ resltat);
}
```
#### La méthode isEqual():
Elle renvoie un Predicate qui teste l'égalité de l'objet fourni en paramètre et de celui passé en paramètre de la méthode test() en utilisant la méthode Objects.equals():
```java=
public static void main(String[] args) {
Predicate<String> predicate = Predicate.isEqual("test1");
System.out.println(predicate.test("test1"));
System.out.println(predicate.test("test2"));
}
```
### :small_blue_diamond: Supplier:
Dans Java 8, **Supplier** est une interface fonctionnelle simple représentant une opération qui fournit une valeur à chaque appel.
Supplier dispose d'une seule méthode **get()** et n'a pas de méthode par défaut.
```java=
@FunctionalInterface
public interface Supplier<T> {
T get();
}
```
L'interface Supplier ne permet de renvoyer que des objets.
```java=
public static void main(String[] args) {
Supplier studentSupplier = () -> new Student("TOTO", "Titi");
Student student = studentSupplier.get();
System.out.println(student);
}
```
Plusieurs interfaces fonctionnelles la spécialisent pour retourner des valeurs primitives : **BooleanSupplier**, **DoubleSupplier**, **IntSupplier** et **LongSupplier**.
```java=
public static void main(String[] args) {
DoubleSupplier pi = () -> 3.14116;
System.out.println(pi.getAsDouble());
}
```
### :small_blue_diamond: Function:
L'interface **Function** a une méthode abstraite **apply** qui prend l'argument de type T et renvoie un résultat de type R. son prototype est:
```java=
public interface Function<T,R> {
public R apply(T t);
}
```
- T : indique le type de l'argument d'entrée
- R : désigne le type de retour
Une illustration de l'interface fonctionnelle via la méthode apply():
```java=
public static void main(String args[]){
Function<Integer, Double> s = a -> a / 2.0;
//Appel de la methode Apply
double resultat=s.half.apply(10);
System.out.println(resultat);
}
```
#### La méthode andThen():
La méthode **andThen(after)** renvoie une Function associée qui applique d'abord la fonction actuelle et after sera appelée par la suite.
```java=
public static void main(String[] args){
//la première Function
Function<Integer,Double> functionSqrt = n -> Math.sqrt(n);
//la deuxième Function
Function<Double,Double> functionDouble = n -> 2.0*n;
// Chainer les deux Functions
double resultat=functionSqrt.andThen(functionDouble).apply(5);
System.out.println("Resultat avec andThen: "+resultat);
}
```
Cette méthode lève **NullPointerException** si la fonction **after** est nulle.
#### La méthode compose():
Elle renvoie une fonction associée dans laquelle la fonction en paramètre sera exécutée en premier, puis la première (c'est l'inverse de la méthode **andThen()**)
```java=
public static void main(String[] args){
//la première Function
Function<Integer,Double> functionSqrt = n -> Math.sqrt(n);
//la deuxième Function
Function<Double,Double> functionDouble = n -> 2.0*n;
// Chainer les deux Functions
double resultat=functionSqrt.compose(functionDouble).apply(5);
System.out.println("Resultat avec andThen: "+resultat);
}
```
Si l'évaluation de l'une ou l'autre des fonctions génère une erreur, elle est relayée à l'appelant de la fonction finale.
#### La méthode identity():
La méthode statique **identity()** renvoie une fonction qui renvoie son propre argument
```java=
public static void main(String args[]){
Function<Integer, Integer> i = Function.identity();
System.out.println(i.apply(10));
}
```
Sign in with Wallet
Connect another wallet