Chapitre 3 - Contrôle du flux du programme

pages : 1 2 3 4 5 6

Noter que le type boolean est totalement limité. On peut lui assigner les valeurs true et false, on peut tester sa vérité ou sa fausseté, mais on ne peut ni additionner des booléens ni effectuer un autre type d'opération avec eux.

On peut observer l'effet de la promotion des types char, byte, et short avec l'application d'un opérateur arithmétique sur l'un d'entre eux. Le résultat est un int, qui doit être explicitement transtypé vers le type original (c'est à dire une conversion rétrécissante qui peut entraîner une perte d'information) afin de l'affecter à une variable de ce type. Avec les valeurs int, toutefois, il n'est pas besoin de transtyper, puisque tout ce qu'on obtient est toujours un int. N'allez cependant pas croire qu'on peut faire n'importe quoi en toute impunité. Le résultat de la multiplication de deux ints un peu trop grands peut entraîner un débordement. L'exemple suivant en fait la démonstration :

//: c03:Overflow.java
// Surprise! Java ne contrôle pas vos débordements.

public class Overflow {
  public static void main(String[] args) {
    int big = 0x7fffffff; // plus grande valeur int
    prt("big = " + big);
    int bigger = big * 4;
    prt("bigger = " + bigger);
  }
  static void prt(String s) {
    System.out.println(s);
  }
} ///:~

Voici le résultat :

big = 2147483647
bigger = -4

La compilation se déroule sans erreur ni avertissement ; il n'y a pas d'exception lors de l'exécution : Java est puissant, mais tout de même pas à ce point-là.

Les affectations composées ne nécessitent pas de transtypage pour les types char, byte, ou short, bien qu'elles entraînent des promotions qui ont le même résultat que les opérations arithmétiques directes. Cette absence de transtypage simplifie certainement le code.

On remarque qu'à l'exception du type boolean, tous les types primitifs peuvent être transtypés entre eux. Il faut rester attentif à l'effet des conversions rétrécissantes en transtypant vers un type plus petit, sous peine de perdre de l'information sans en être averti.

Le Contrôle d'exécution

Java utilisant toutes les instructions de contrôle de C, bien des choses seront familières au programmeur C ou C++. La plupart des langages de programmation procéduraux possèdent le même type d'instructions de contrôle, et on retrouve beaucoup de choses d'un langage à un autre. En Java, les mots clefs sont if-else, while, do-while, for, et une instruction de sélection appelée switch. Toutefois Java ne possède pas le goto très pernicieux (lequel reste le moyen le plus expéditif pour traiter certains types de problèmes). Il est possible d'effectuer un saut ressemblant au goto, mais bien plus contraignant qu'un goto classique.

true et false

Toutes les instructions conditionnelles utilisent la vérité ou la fausseté d'une expression conditionnelle pour déterminer le chemin d'exécution. Exemple d'une expression conditionnelle : A == B. Elle utilise l'opérateur conditionnel == pour déterminer si la valeur A est équivalente à la valeur B. L'expression renvoie la valeur true ou false. Tous les opérateurs relationnels vus plus haut dans ce chapitre peuvent être utilisés pour créer une instruction conditionnelle. Il faut garder à l'esprit que Java ne permet pas d'utiliser un nombre à la place d'un boolean, même si c'est autorisé en C et C++ (pour lesquels la vérité est « différent de zéro » et la fausseté « zéro »). Pour utiliser un non-boolean dans un test boolean, tel que if(a), il faut d'abord le convertir en une valeur boolean en utilisant une expression booléenne, par exemple if(a != 0).

if-else

L'instruction if-else est sans doute le moyen le plus simple de contrôler le déroulement du programme. La clause else est optionnelle, et par suite l'instruction if possède deux formes :

if(expression booléenne)
instruction

ou bien :

if(expression booléenne)
instruction
else
instruction

L'expression conditionnelle expression booléenne doit fournir un résultat de type boolean. instruction désigne soit une instruction simple terminée par un point-virgule, soit une instruction composée, c'est à dire un groupe d'instructions simples placées entre deux accolades. Par la suite, chaque utilisation du mot « instruction » sous-entendra que l'instruction peut être simple ou composée.

Voici un exemple d'instruction if-else : la méthode test( ) détermine si une estimation est supérieure, inférieure ou équivalente à une valeur donnée :

//: c03:IfElse.java
public class IfElse {
  static int test(int testval, int target) {
    int result = 0;
    if(testval > target)
      result = +1;
    else if(testval < target)
      result = -1;
    else
      result = 0; // Identique
    return result;
  }
  public static void main(String[] args) {
    System.out.println(test(10, 5));
    System.out.println(test(5, 10));
    System.out.println(test(5, 5));
  }
} ///:~

Par convention, on indente le corps d'une instruction de contrôle de flux, afin que le lecteur détermine plus facilement son début et sa fin.

return

Le mot clef return a deux buts : il spécifie la valeur que la méthode doit retourner (si elle n'a pas un type de retour void) et provoque le renvoi immédiat de cette valeur. Voici la méthode test( ) ci-dessus, réécrite en utilisant cette propriété :

//: c03:IfElse2.java
public class IfElse2 {
  static int test(int testval, int target) {
    int result = 0;
    if(testval > target)
      return +1;
    else if(testval < target)
      return -1;
    else
      return 0; // Identique
  }
  public static void main(String[] args) {
    System.out.println(test(10, 5));
    System.out.println(test(5, 10));
    System.out.println(test(5, 5));
  }
} ///:~

Ce livre a été écrit par Bruce Eckel ( télécharger la version anglaise : Thinking in java )
Ce chapitre a été traduit par Jean-Pierre Vidal ( groupe de traduction )
télécharger la version francaise (PDF) | Commandez le livre en version anglaise (amazon) | télécharger la version anglaise

pages : 1 2 3 4 5 6

Penser en Java 2nde édition

Thinking in Java