Chapitre 5 : Contrôle du flux, exceptions et assertions

Elle se traduit en français par le si-sinon et permet d'exécuter une ou plusieurs instructions selon que la condition de test est vraie ou fausse. Dans le cas d'une structure if-else, la condition de test peut être n'importe quelle instruction qui résulte à une valeur booléenne.

• Le format basique d'une instruction avec if est le suivant :

   

  Sélectionnez

  if(expression-booléenne){
      //fait quelque chose si l'expression booléenne est à true
  }

• Le format d'une instruction avec if-else est le suivant (le bloc else est optionnel) :

   

  Sélectionnez

  if(expression-booléenne){
       //fait quelque chose si l'expression booléenne est à true
  } else {
       //fait quelque chose si l'expression booléenne est à false 
  }

• Les accolades ne sont pas obligatoires lorsque vous souhaitez gérer une seule instruction dans un bloc if ou else.

• Règles d'utilisation des blocs else et else if :

• Toute expression qui donne lieu à une valeur booléenne peut être utilisée comme condition de test avec le if :

1. On peut avoir zéro ou un bloc else pour un if donné ;
2. On peut avoir zéro ou plusieurs else ifs pour un if donné ;

3. Une fois qu'une condition est vérifiée, tous les autres blocs sont ignorés.

    

   Sélectionnez

   if((x > 3) && (y < 2) | doStuff()){}
   boolean doStuff(){}

4. Seules les expressions booléennes sont utilisées comme condition de test pour le if :

int trueInt = 1; if(trueInt) //illégal

Elle est très utile lorsque vous voulez gérer plusieurs blocs avec des if imbriqués. Afin de contourner la lourdeur des if/else-if/if, la structure switch propose d'énumérer la liste des cas possibles dans une syntaxe assez claire et intelligible.

• Exemple de transformation d'une structure de contrôle if/else en bloc switch :

  Sélectionnez int x = 3; if(x == 1){ //fait quelque chose } else if(x == 2){ //fait quelque chose }else { //valeur par défaut //fait quelque chose }

  Sélectionnez int x = 3; switch(x){ case 1 : break; case 2 : break; default : }

• Le mot clé break est optionnel et permet de sortir de la structure conditionnelle. Son inclusion ou exclusion cause de grands changements dans l'exécution d'un switch.

• Le mot clé default permet de spécifier l'instruction ou le bloc de code qui devra être exécuté s'il n'existe pas de case correspondant à la valeur de l'expression de test. Il peut être placé en début, au milieu ou à la fin d'une structure switch.

• La forme générale d'une instruction switch est la suivante :

   

  Sélectionnez

  switch(expression) {
    case constante 1 : bloc de code à exécuter « si expression = constante 1 »;
    case constante 2 : bloc de code à exécuter « si expression = constante 2 »;
    default : bloc de code à exécuter par défaut ;
  }

• L'expression de test pour une structure switch doit être de type char, byte, short, int ou enum (dans la version 7 de Java SE, il est possible d'utiliser le type String comme type de l'expression de test). Ce qui signifie que, à défaut d'utiliser une expression de type enum, seules les variables qui peuvent être automatiquement transformées en int sont admises. Dans le cas contraire (si vous utilisez une expression de type long, float, double, boolean) vous aurez une erreur de compilation.

• On peut utiliser un wrapper comme expression de test. Mais cela n'est valable que pour les wrappers correspondant aux types primitifs admis, à savoir : Character, Byte, Short et Integer :

   

  Sélectionnez

  switch(new Integer(4)) {
      case 4 : 
  }

• La constante d'un case doit être de même type que l'expression de test. De plus, cette constante doit être clairement établie à la compilation. Ce qui signifie qu'on peut seulement utiliser des constantes ou des variables final auxquelles on a affecté une valeur littérale. Il ne suffit pas que la variable soit final, elle doit aussi avoir une valeur à sa création :

   

  Sélectionnez

  final int a = 1;
  finale in b;//pas de valeur à la compilation
  b = 2;//on affecte la valeur à l'exécution
  int x = 0;
  switch(x){
      case a: //ok
      case 3: //ok
      case b: //erreur de compilation 
      case new Integer(5) : //compile error
  }

• La structure switch teste uniquement l'égalité.

• Il peut se poser un problème lorsqu'on utilise des variables de taille inférieure au type int :

   

  Sélectionnez

  byte g = 2;
  switch(g) {
     case 23:
     case 128://erreur de compilation, car 128 est très grand pour le type byte 
  }

• Il n'est pas autorisé d'avoir plus d'un case avec la même valeur de test, cela conduit à une erreur de compilation :

   

  Sélectionnez

  int temp = 90;
  switch(temp) {
      case 80 :
      case 80 : //erreur de compilation
      case 90 :
  }

• Les instructions case sont évaluées du premier case (après le mot clé switch) au dernier case du bloc. Et le premier case qui correspond à l'expression du switch est le point d'entrée de l'exécution de la structure.

• À la rencontre d'un mot clé break, le programme sort du switch pour exécuter l'instruction qui le suit. Si aucun break n'est rencontré, le programme va exécuter tous les case restants jusqu'à ce qu'il rencontre un break oujusqu'à ce qu'il atteigne la fin du bloc switch :

   

  Sélectionnez

  int x = 1;
  switch(x) {
      case 1 : System.out.print("1 ");
      case 2 : System.out.print("2 ");
      case 3 : System.out.print("3 ");
  }

• Le résultat de ce programme sera : 1 2 3 pour la simple raison qu'aucune instruction break n'a été rencontrée.

• Le cas par défaut (default) fonctionne comme les case.

• Les boucles avec while sont indiquées pour des scénarios où l'on n'a pas une idée du nombre de fois qu'un bloc ou une instruction devrait être exécuté.

• Le format d'une boucle while est le suivant :

   

  Sélectionnez

  while(expression-booléenne){
  }

• Une boucle while est exécutée, si et seulement si l'expression de test est à true.

• L'expression de test d'une boucle while doit être déclarée avant son utilisation :

   

  Sélectionnez

  while(boolean b = true){//erreur de compilation
  }

• Pour l'exécution d'une seule instruction, on peut se passer des accolades :

   

  Sélectionnez

  int x = 0, y = 10;
  while (++x < y)
     System.out.println("nombre de fois : " +x +" fois !!!");

• Exemple de boucle while :

boolean b = true;
int i = 0;
while(b){
   if(i == 5){
      b = false;
   }  
   System.out.println("i : "+ i++);
}

• C'est une variante de la boucle while. L'une des particularités de cette boucle vient du fait que la condition de test est vérifiée après l'exécution du bloc placé dans la boucle. Ceci dit, une boucle do…while sera toujours exécutée au moins une fois.
• De plus, une boucle do…while se termine par un point-virgule « ; ».

• Le format d'une boucle do…while est le suivant :

   

  Sélectionnez

  do {
  }while(booleanExpression);//Se rassurer qu'il y a le “;” après le while

• De même que pour la boucle while, on peut se passer des accolades pour l'exécution d'une seule instruction. Cependant, si l'on met plus d'une instruction entre le do et le while sans accolades, une erreur va se produire à la compilation :

int x = 0, y = 10;
do
   System.out.println("nombre de fois : " +x +" fois !!!");
while (++x < y);

• La boucle for est vraiment utile lorsque le nombre d'itérations est connu.
• La déclaration d'une boucle for contient trois parties :

• Les trois parties sont séparées par un point-virgule (« ; ») et sont indépendantes les unes des autres :

   

  Sélectionnez

  for(/*Initialisation*/; /*condition*/; /*iteration*/){}
   => for(int i = 0; i<5; i++){}

• Initialisation

   

  Sélectionnez

  for(int x = 0, y = 3; y > 3; y++){}

• L'utilisation d'une variable déclarée dans une boucle for est limitée au bloc d'instructions défini dans la boucle :

for(int x = 1; x < 2; x++){
    System.out.println(" x: "+x);//legal
}
System.out.println(" x:"+x);//Illégal, impossible d'accéder à la variable x hors de la boucle

• Condition

for(int x = 0; ((((x < 10) && (y-- > 2)) | x == 3)); x++){} //c'est légal
for(int x = 0; (x > 5), (y < 2); x++){} //Illégal, plusieurs expressions ont été déclarées

• Itération

   

  Sélectionnez

  for(int i = 0; i < 4; 
     System.out.println(" first print "), System.out.println(" second print")){}

• L'expression d'itération est exécutée après chaque exécution du contenu de la boucle :

   

  Sélectionnez

  for(int x = 0; x < 1; x++){//contenu de la boucle
     System.out.println(" first print "), System.out.println(" second print")){} }

• En cas d'absence des instructions qui forcent la sortie d'un programme (break, return, Exception, System.exit()), l'évaluation de l'expression d'itération et l'évaluation de la condition de test sont toujours les dernières instructions exécutées dans une boucle for.

   

  Sélectionnez

  for(;;){}//elle va se comporter comme une boucle infinie 
  for(; i < 10; ){}//elle va se comporter comme une boucle while

• Les trois parties (initialisation, condition, itération) d'une boucle for sont indépendantes les unes des autres. Elles n'ont donc pas besoin d'avoir systématiquement les mêmes variables :

int b = 3; 
for(int a = 1; b != 1; System.out.println("Iterate")){ b = b - a;}

• Elle a été introduite dans la version 6 du JDK et permet de simplifier le parcours des tableaux et des collections.

• À la différence d'une simple boucle for qui a trois parties, le for-each n'en a que deux :

   

  Sélectionnez

  int [] a = {1,2,3}; 
  for(int n : a){
    System.println("value : "+n);
  }

• Le format d'un for-each est le suivant : for(déclaration : expression).

• La déclaration doit être de type compatible avec les éléments du tableau ou de la collection.

• L'expression doit pouvoir être évaluée à un(e) tableau(collection). Elle peut donc être un(e) tableau(collection) ou une méthode qui retourne un(e) tableau(collection) :

for(Object obj : listOf()){//la méthode retourne une liste d'objets
   System.out.println(obj);
}
List listOf(){}

On les utilise très souvent pour les boucles for ou while en conjonction avec les instructions break ou continue pour définir à quel niveau devra s'appliquer le break ou le continue.

• Une étiquette doit être placée juste avant la boucle à étiqueter suivie des deux-points (« : ») :

   

  Sélectionnez

  foo:
  for(int x = 3; x<20;x++){
      while(y > 7){ y--; break foo;}
  }

• L'utilisation des étiquettes sur une boucle est nécessaire uniquement dans les situations où nous avons des boucles imbriquées et que nous voulons indiquer la boucle sur laquelle le break ou le continue doit être appliqué.

• Dans l'exemple suivant, l'instruction break va faire sortir le programme de la boucle étiquetée (la boucle for) et non de la boucle qui lui est directement proche (boucle while) :

   

  Sélectionnez

  foo:
  for(int x = 3; x<20;x++){
      while(y > 7){ y--; break foo;}
  }

• Une étiquette doit respecter les critères d'une variable Java valide (voir chapitre 1).

• Pour utiliser une étiquette avec un break ou un continue, on fait simplement suivre l'instruction break ou continue de l'étiquette puis on met un point-virgule :

outer:
for(;;){
    while(true){
        System.out.print("while  ");
        break outer;
    }
    System.out.print("for  ");//ne sera pas affiché
}
System.out.print("out  ");
Ce code produit : while out
     
outer:
for(int i = 0; i < 2; i++){
    for(;;){
        System.out.print("for 1 ");
        continue outer;
    }
    System.out.print("for 2");
}
System.out.print("out");
Ce code produit: for 1 for 1 out

V-A-1. Gestion des exceptions à l'aide du bloc try-catch▲

V-A-2. Utilisation du mot clef finally▲

V-A-3. Propagation des exceptions non traitées▲

V-B-1. Hiérarchie des exceptions▲

• Les classes qui dérivent de la classe Error permettent de présenter des situations qui ne devraient pas apparaître durant l'exécution normale d'une application (par exemple le manque de mémoire).

• Il n'est pas obligatoire de gérer les exceptions de type Error :

   

  Sélectionnez

  //Exception de type Error, pas de problème
  void faireQuelquechose(){
     
   throw new AssertionError();
  }
  
  //Exception de type RuntimeException, pas de problème
  void faireQuelquechose(){
     throw new NullPointerException();
  }
  
  // Problème, l'exception doit être soit entourée d'un bloc try-catch soit   // listée au niveau de la méthode à l'aide du mot clé throws
  void faireQuelquechose(){//erreur lors de la compilation
     throw new Exception();
  }

• Techniquement, une erreur n'est pas une exception pour la simple raison qu'une erreur hérite de la classe java.lang.Error tandis qu'une exception hérite de la classe java.lang.Exception.

• La classe Throwable met à la disposition des sous-classes, un ensemble de méthodes utiles pour la gestion des exceptions. Exemple : la méthode printStackTrace().

• Les exceptions de type Exception, Error, RuntimeException et Throwable peuvent être levées à l'aide du mot clé throw et peuvent bien être gérées dans un bloc catch.

V-B-2. Gestion des groupes d' exceptions▲

//le bloc catch va gérer toute exception qui hérite directement ou indirectement de la classe Exception (Ex : FileNotFoundException, IOExeption, NullPointerException,…).
try{}catch(Exception ex){}

V-B-3. La déclaration des blocs catch▲

• L'ensemble des exceptions qu'une méthode peut générer doit être déclaré ou géré (à moins que l'exception soit une sous-classe de la classe RuntimeException ou Error).

• Le mot clé throws permet de déclarer la liste des exceptions qu'une méthode peut générer :

   

  Sélectionnez

  void myFunction() throws MyException1, MyException2 {}

• Toute méthode qui peut générer une exception doit déclarer l'exception. À moins que l'exception soit une sous-classe de RuntimeException.

• Chaque méthode doit, soit gérer (à l'aide d'un bloc catch), soit déclarer (à l'aide du mot clé throws) toute exception de type checked exception. RuntimeException et Error et les sous-classes associées sont des exceptions de type unchecked exception.

• Les exceptions de type unchecked exceptions n'ont pas besoin d'être gérées ou déclarées.

• Un checked exception doit obligatoirement être géré quelque part dans le code, dans le cas contraire le code ne pourra pas être compilé.

• Pour créer une exception personnalisée, il suffit d'hériter de la classe Exception ou d'une de ses sous-classes :

   

  Sélectionnez

  class MyException extends Exception{}

• Lorsqu'une exception est propagée dans un bloc try ou catch, s'il existe un bloc finally, les instructions de ce bloc seront d'abord exécutées avant que le contrôle ne soit passé à la méthode appelante.

• Si vous propagez un checked exception, vous devez, soit le déclarer, soit le traiter :

//It is illegal, you must declare the throw exception
void  doStuff(){try{}catch(Exception e){ throw e;}}

• Dans la pratique, les assertions permettent de mettre en œuvre la programmation par contrat.
• La programmation par contrat est une technique de programmation dans laquelle les interactions entre les objets sont régies par des règles. Elle consiste à indiquer au niveau des classes d'objets les invariants (conditions qui doivent être vérifiées tout au long de la vie d'un objet) et au niveau des méthodes, des préconditions (contraintes à respecter à l'appel d'une méthode) et postconditions (contraintes à respecter après l'exécution d'une méthode).

• Pour matérialiser le concept de programmation par contrat, considérons l'exemple (purement simpliste) d'une classe qui remplit un tableau de racines carrées :

   

  Sélectionnez

  public class RacineCarree {
     private double[] racine = new double[20]; // invariant : racine  != null
     
     public RacineCarree(){
        assert(racine != null);//on s'assure que l'invariant est toujours vrai
     }
     
     public double[] fillRacine(){
        double[] values = new double[racine.length];
        for(int i = 0; i < racine.length; i++){
           values[i] = sqrt(racine[i]);
         }
        
        return values;
     }
     
     private double racineCarree(double value){
        assert(value >= 0);//pré-condition
  
         double resultat = sqrt(value);
  
         assert(resultat == sqrt(value));//post condition 
        
        return resultat;
     }
  }

• Les codes d'assertion sont ignorés au déploiement de l'application.

• On fait toujours une assertion pour savoir si une hypothèse est vraie. Si c'est le cas alors pas de problème. Mais dans le cas contraire (si l'hypothèse n'est pas vérifiée), l'erreur AssertionError sera propagée.

• Il existe deux types de test d'assertion :

   

  Sélectionnez

  private void doStuff(){ assert(y > x);}

• Simple, en plus de l'expression booléenne, ce type d'assertion comporte une seconde expression qui sera associée à l'erreur pour apporter plus de détails. Les deux expressions sont séparées par les deux points (« : ») :

private void doStuff(){assert(y > x) : "Y is " + y + " x is " + x;}

• Les deux types d'assertions propagent une erreur de type AssertionError. Mais la version simple permet d'apporter plus de détails pour faciliter le débogage.
• Les codes d'assertions sont activés pendant les tests ou le débogage, mais ils sont désactivés (ignorés par la JVM) lorsque l'application est déployée.

• Une assertion peut avoir une ou deux expressions selon que vous utilisez le type « simple » ou le « type très simple ».
• La première expression d'une instruction assert doit toujours être équivalente à une valeur booléenne.
• La seconde expression est utilisée dans le cas d'une assertion de type simple, elle peut être toute expression qui résulte à une valeur. Elle est utilisée pour générer un message qui apporte plus de détails en vue de faciliter le débogage.
• Exemples d'expressions légales et illégales :

int aReturn(){return 1;}
int x = 1;
boolean b = true;
//legal expression
assert(x==1);
assert(b);
assert true;
assert(x == 1) : x;
assert(x == 1) : aReturn();
//illegal expression
assert(x = 1);//none are boolean
assert(x);
asser(0);
assert(x==1) : ;// none of these return a value
assert(x==1); : noReturn();
assert(x==1) : validdAssert va;int aReturn(){return 1;}
int x = 1;
boolean b = true;
//legal expression
assert(x==1);
assert(b);
assert true;
assert(x == 1) : x;
assert(x == 1) : aReturn();
//illegal expression
assert(x = 1);//none are boolean
assert(x);
asser(0);
assert(x==1) : ;// none of these return a value
assert(x==1); : noReturn();
assert(x==1) : validdAssert va;

• Avant Java 1.4, le mot assert pouvait être utilisé comme un identifiant en Java. Mais depuis la version Java 1.4, assert est devenu un mot clé.
• Le compilateur Java 6 considère le mot assert comme un mot clé. Une erreur est générée si assert est utilisé comme un identifiant.
• Si vous utilisez assert comme identifiant dans le code, vous devez le compiler en utilisant l'option : « - source 1.3 ».
• assert peut uniquement être utilisé comme identifiant dans Java 1.3, dans les versions supérieures la compilation échoue.
• assert ne peut pas être utilisé comme un mot clé dans la version Java 1.3.
• Une fois que les assertions ont été placées dans le code, vous pouvez les activer ou les désactiver à la compilation. Par défaut, elles sont désactivées.

• Vous pouvez activer les assertions à la compilation comme suit :

   

  Sélectionnez

  java -ea TestCass 
  or
  java -enableassertions TestClass

• Vous pouvez désactiver les assertions à la compilation comme suit :

   

  Sélectionnez

  java -da TestClass 
  or
  java -disableassertions TestClass. 
  //Ne pas oublier que les assertions sont désactivées par défaut

• Les lignes de commandes pour les assertions peuvent être utilisées de plusieurs façons :

• Avec un nom de classe pour activer ou désactiver les assertions dans une classe spécifique.

• Vous pouvez désactiver les assertions dans une seule classe, mais, vous pouvez les activer pour toutes les autres classes comme suit :

   

  Sélectionnez

  java -ea -da:com.TestClass . 
  That means, enable assertions in general, but disable them in com.TestClass

• Vous pouvez faire de même pour un package comme suit :

   

  Sélectionnez

  java -ea -da:com...  . 
  //That means, enable assertions in general but disable 
  //them in the package com and all of subpackages

• Vous pouvez activer les assertions dans toutes les classes sauf dans les classes système comme suit :

java -ea -dsa

• Il n'est pas conseillé (même si c'est possible) de gérer les erreurs d'assertion (AssertionErrors).
• AssertionError est une sous-classe de la classe Throwable, donc elle peut être gérée dans un bloc try-catch. Mais ce n'est pas conseillé.

• Il est inapproprié d'utiliser les assertions pour valider les arguments des méthodes publiques. L'instruction suivante est inappropriée :

   

  Sélectionnez

  public void doStuff(int x){ assert ( x > 0);}

• Si vous voulez valider les arguments d'une méthode publique, vous devez probablement utiliser les exceptions telles que IllegalArgumentException ou NumberFormatException.

• Il est approprié d'utiliser les assertions pour valider les arguments des méthodes privées.

• Il est approprié d'utiliser les assertions dans les méthodes publiques pour tester un cas dont on est sûr qu'il ne se produira jamais :

   

  Sélectionnez

  switch(x) {
      case 1: y = 3; break;
      case 2: y = 9; break;
      default : assert false;
  }

• Il est inapproprié de modifier les variables dans une assertion :

public void doStuff(){ assert(modifyThing()); }
public boolean modifyThing(){y = x++; return true;}

1. Erreurs
   Dans une boucle for-each, il faut déclarer la variable qui devra contenir chaque objet à l'intérieur de l'instruction. Donc il faudra remplacer for(y : x) par for(int y : x). Puis supprimer/commenter la déclaration de la variable y avant l'instruction forafin d'éviter les conflits de noms entre les deux variables locales.
2. Solution
   Le résultat est : 1 2 3 4 5.

1. Erreurs
   Une variable non-statique ne peut pas être directement employée dans une méthode statique. Vous devez donc rendre la variable « s » statique : static String s = « - »;.
2. Solution

Le résultat est : -A B C D.

1. Erreurs
   L'expression de test pour une structure switch doit être une constante de type char, byte, short, int ou enum. Et cette constante doit être clairement établie à la compilation. Pour cela, vous allez remplacer new Integer(4) par 4 et faire précéder la déclaration de la variable p de final (final static int p = 6;).
2. Solution

Le résultat est : 3 4 4 5 5 .

Lorsque y = 0, x = 3. Étant donné qu'il n'y a pas de break entre case 3 et case 4, le programme ajoutera 3 4 à s. Lorsque y = 1, x = 4. Le programme ajoute 4 à s et sort du switch à cause du break. Lorsque y = 2, x = 5. Le programme exécute case 5 puis case (p = 6) et ajoute à s 5 5 car, aucun break ne les sépare. Le tout donne 3 4 4 5 5.

1. Erreurs
   Il n'y a aucune erreur.
2. Solution

Le résultat est : 1 1 3 3 9 9. À chaque fois que j = 1, le programme sort de la seconde boucle et à chaque fois que x vaut 5,6 ou 7, le programme passe à la valeur suivante de j sans imprimer x.

1. Erreurs
   Il n'est pas possible de mettre des traitements directement à la suite des in throw et return. Cela produit une erreur de compilation, car ils ne seront jamais exécutés. IL faudra donc mettre l'instruction s += « 1 »; avant l'instruction throw.
   Si l'on a un bloc try avec plusieurs blocs catch, le catch avec l'exception la plus spécifique devra toujours être placée au-dessus de celles qui sont générales (super-classe). Il faudra donc permuter les blocs catch, car NullPointerException hérite de Exception.
2. Solution

La solution est : s = 1245.