2.3 Branchements et aiguillages

Ces instructions composées permettent l'exécution conditionnelle d'instructions.

2.3.0.0.1 Branchement

Cette instruction permet de n'exécuter des instructions que si une condition booléenne est vraie. Sa forme la plus simple a une condition et une branche ; la condition doit figurer entre des parenthèses, et son type doit être boolean ; la branche est une instruction, simple ou composée, généralement un bloc d'instructions (donc placé entre les accolades { et }) ; elle n'est exécutée que si la valeur de la condition est true. Par exemple :

    if (delta < 0) {
      System.out.println("Pas de solution réelle");
    }

Dans la forme à deux branches, la première branche est exécutée quand la valeur de la condition est true ; la seconde est exécutée quand cette valeur est false. Par exemple :

    if (delta < 0) {
      System.out.println("Pas de solution réelle");
    } else {
      System.out.println("Au moins une solution réelle");
    }

Enfin, la branche else peut elle-même contenir un if (et ainsi de suite), ce qui conduit à l'imbrication suivante :

    if (delta < 0) {
      System.out.println("Pas de solution réelle");
    } else if (delta == 0) {
      double x1 = -b/(2*a);
      System.out.println("Une solution x1 = " + x1);
    } else {
      double 
        r = Math.sqrt(delta),
        x1 = (-b - r)/(2*a),
        x2 = (-b + r)/(2*a);
      System.out.println(
        "Deux solutions" +
        "x1 = "  + x1 + ", x2 = " + x2);
    }

2.3.0.0.2 Aiguillage

Il est souvent utile d'exécuter des instructions en fonction de la valeur d'un entier ou d'un caractère ; Java offre une instruction d'aiguillage à cette fin. L'exemple suivant pourrait servir, avec quelques lignes supplémentaires, à compter les voyelles et les consonnes d'un texte :

    switch (c) {
      case 'a': 
      case 'e': 
      case 'i': 
        voyelles = voyelles + 1;
        break;
      case 'b': 
      case 'c': 
      case 'd': 
        consonnes = consonnes + 1;
        break;
      default: 
        autres = autres + 1;
    }

L'instruction d'aiguillage switch est formée à partir d'une expression exp et d'un bloc d'instructions étiquetées :

    switch (exp) {
      ...
    }

L'expression doit être de l'un des types byte, short, int, long ou char ; les instructions du bloc peuvent être étiquetées par un case ou par default :

      case const: ... ;
      default: ... ;

La valeur de l'expression exp est successivement comparée à la valeur de chacune des expressions constantes const figurant à droite de case. Dès qu'il y a un cas d'égalité, l'instruction suivant ce case est exécutée, ainsi que toutes les instructions suivantes, jusqu'à la fin du bloc ou jusqu'à un échappement : les instructions break ou return. Si aucune égalité n'est vérifiée, ce sont les instructions qui suivent le cas default qui sont exécutées.

Dans les usages courants du switch, chaque cas (non-vide) est terminé par un échappement :

    switch (exp) {
      case ...: ... ; break ;
      case ...: ... ; break ;
      default : ... ;
    }