Chapitre 2  Les constructions de base en Java

... conduire par ordre mes pensées, en commençant par les objets les plus simples et les plus aisés à connaître, pour monter peu à peu, comme par degrés, jusques à la connaissance des plus composés ; et supposant même de l'ordre entre ceux qui ne se précèdent point naturellement les uns les autres. Descartes

2.1  Constantes et variables

final double tauxTVA = 1.196;

final String salutation = "Bonjour";

final String salutation = "Guten Tag";

final String salutation = "Buenos dias";

2.2  Typage

• On dispose d'ensembles de base, auxquels correspondent en Java des types de bases¹ :
  • R : double, float
  • Z : byte, short, int, long
  • Bool : boolean
  • caractères : char
  
  
  
• On peut définir de nouveaux ensembles : si on a besoin d'un ensemble de couleurs, on pourra écrire quelque chose du genre class Couleur, comme nous le verrons ultérieurement. Cette capacité à définir de nouveaux ensembles ou types existe dans la grande majorité des langages de programmation.
• On peut définir des produits d'ensemble, comme par exemple Couleur × Bool ou Z × Z × R. Nous verrons que les classes permettent en particulier ce genre de construction.
• On peut définir des fonctions, comme par exemple f : Zp × Z ® Bool, qui s'écrira en Java boolean f(int a, int b).
• Grâce aux listes et autres collections, on peut définir des séquences d'objets.

2.3  Types élémentaires en Java

• boolean : booléen, peut valoir true ou false
• byte : entier sur 8 bits [-128, 127]
• char : caractère Unicode (cf. § F.1) codé sur 16 bits
• short : entier codé sur 16 bits [-32 768, 32 767] (cf. § F.2)
• int : entier codé sur 32 bits
• long : entier codé sur 64 bits
• float : réel codé sur 32 bits, au format IEEE 754 (cf. § F.3)
• double : réel double précision codé sur 64 bits, au format IEEE 754

boolean b = true;
int i = 3;
b = (i != 0);
char c = 'A';
char newline = '\n';
char apostrophe = '\'';
char delete = '\377';
char aleph = '\u05D0';
long somme = 456L;
float val = -87.56;
float cumul = 76.3f;
double pi = 3.14159;
double large = 456738.65D;
double veryLarge = 657E+234;

        boolean b;
        double a2 = 5.2;
        int k = 5;
        int j = k;
        int i = 7;
        char a = i;
        int k = 7;
        int l = t;
        int t = 7;
  

2.4  Expressions

2.4.1  Opérateurs arithmétiques

    int i = 13;
    int j = 5;
    i = i % 5;
    j = j * i + 2;
    int k = (i * 7 + 3) / 5;
  

2.4.2  Opérateurs logiques et relationnels

2.4.3  Opérateurs bit à bit

2.5  L'affectation

  int x = 3;
  int y = 5;             // x == 3, y == 5
  x = y;                 // x == 5, y == 5
  y = 6;                 // x == 5, y == 6 : x et y ne sont pas des variables liées !

  a += 3;                 // équivaut à a = a + 3
  a -= 3;                 // équivaut à a = a - 3
  a *= 3;                 // équivaut à a = a * 3
  a /= 3;                 // équivaut à a = a / 3
  a %= 3;                 // équivaut à a = a % 3
  a <<= 3;                 
  // etc. pour >>=, >>>=, &=, |= et ^=

  a++;                 // équivaut à a += 1 ou à a = a +1
  ++a;                 // équivaut à a++, sauf pour la valeur rendue
  a--;                 // équivaut à a -= 1 ou à a = a -1
  --a;                 // équivaut à a--, sauf pour la valeur rendue

  int x = 3;
  int y = 5;           // x == 3, y == 5
  x = y++;             // x == 5, y == 6
  x = ++y;             // x == 7, y == 7

2.6  Mon premier programme Java

  int solde = 0;     // variable désignant le solde et initialisée à 0
  int montant = 16;  // variable désignant le montant à créditer

  solde += montant;  // l'opération de crédit à proprement parler

public class Banque {
    public static void main(String[] args) {
        int solde = 0;
        int montant = 16;

        solde += montant;
    }
}

// Classe Banque - version 1.0
import java.io.*;       // Importer toutes les fonctionnalités de java.io

public class Banque {
    public static void main(String[] args) {
        int solde = 0;
        System.out.println("Le solde initial est de " + solde + " euros.");
        int montant = 16;

        solde += montant;
        System.out.println("Le nouveau solde est de " + solde + " euros.");
    }
}

  Le solde initial est de 0 euros.
  Le nouveau solde est de 16 euros.

// Classe Banque - version 1.1
import java.io.*;       // Importer toutes les fonctionnalités de java.io

public class Banque {
    public static void main(String[] args) {
        // Conversions mystérieuses...
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ir);

        int solde = 0;
        System.out.println("Le solde initial est de " + solde + " euros.");
        
        System.out.print("Montant à créditer = ");
        System.out.flush();
        String lecture = "";      // la chaîne qu'on va lire, initialisée à rien
        try { // prise en compte des exceptions par try/catch
            lecture = br.readLine();
        } catch (IOException ioe) {}

        int montant = Integer.parseInt(lecture);  // conversion en int de la chaîne lue

        solde += montant;       // on retrouve l'incrémentation classique
        System.out.println("Le nouveau solde est de " + solde + " euros.");
    }
}

Le solde initial est de 0 euros.
Montant à créditer = 43
Le nouveau solde est de 43 euros.

2.7  De la structuration du discours : les instructions de contrôle

• L'appel à une fonction ou à une procédure ; nous verrons les fonctions et les procédures plus tard (§ 3.2), mais c'est en particulier l'instruction qui sert de point de départ à l'exécution d'un programme, par le lancement de la procédure main(), comme nous l'avons vu ci-dessus.
• Une instruction atomique de déclaration d'une variable³ ou d'affectation du résultat d'un calcul à une variable, voire une instruction vide (;). Comme nous l'avons vu intuitivement dans l'exemple que nous avons déroulé au § 2.6, une expression ou une déclaration de variable (avec initialisation éventuelle) "devient" une instruction quand on lui ajoute le signe `;' qui joue le rôle de terminaison d'instruction<sup>4</sup>.
• Une construction conditionnelle (cf. § 2.7.1) ou d'itération (cf. § 2.7.2).
• Un bloc composé ; l'idée est ici que si on a besoin de plusieurs instructions à un même niveau, elles sont regroupées dans un bloc, entre les délimitateurs `{' et `}'. Un bloc composé a sa propre portée lexicale (cf. § 6.1) ; on peut en particulier y définir et y utiliser des variables locales au bloc.

2.7.1  Instructions conditionnelles

• l'aiguillage, qui permet de choisir l'une de deux "branches" d'exécution, suivant la valeur d'une condition ;
• la gare de triage, qui permet de multiples embranchements, suivant les conditions rencontrées.

// Classe Banque - version 1.2
import java.io.*;       // Importer toutes les fonctionnalités de java.io

public class Banque {
    public static void main(String[] args) {
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ir);

        int solde = 0;
        System.out.println("Le solde initial est de " + solde + " euros.");
        
        System.out.print("[D]ébit ou [C]rédit (choix par défaut) ? ");
        String choix = "";
        try {
            choix = br.readLine();
        } catch (IOException ioe) {}

        boolean credit = true;   // variable vraie si c'est un crédit (défaut)

        if (choix.equals("D") || choix.equals("d")) {
            credit = false;
        }
        // sinon on reste à true par défaut, donc crédit

        // Notez l'utilisation de l'opérateur à 3 opérandes ?:
        System.out.print("Montant à " + (credit ? "créditer" : "débiter") + " = ");
            
        System.out.flush();
        String lecture = "";      // la chaîne qu'on va lire, initialisée à rien
        try {
            lecture = br.readLine();
        } catch (IOException ioe) {}

        int montant = Integer.parseInt(lecture);  // conversion en int de la chaîne lue

        if (credit) {
            solde += montant;
        }
        else {
            solde -= montant;
        }
        System.out.println("Le nouveau solde est de " + solde + " euros.");
    }
}

Le solde initial est de 0 euros.
[D]ébit ou [C]rédit (choix par défaut) ? d
Montant à débiter = 124
Le nouveau solde est de -124 euros.

Le solde initial est de 0 euros.
[D]ébit ou [C]rédit (choix par défaut) ? c
Montant à créditer = 654
Le nouveau solde est de 654 euros.

// Classe Banque - version 1.3
import java.io.*;       // Importer toutes les fonctionnalités de java.io

public class Banque {
    public static void main(String[] args) {
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ir);

        int solde = 0;
        System.out.println("Le solde initial est de " + solde + " euros.");
        
        System.out.print("Votre choix : [D]ébit, [C]rédit, [F]in ? ");
        String choix = "";
        try {
            choix = br.readLine();
        } catch (IOException ioe) {}
        boolean fin = false;     // variable vraie si on veut s'arrêter
        boolean credit = false;   // variable vraie si c'est un crédit

        // Récupérer la première lettre de la chaîne saisie
        char monChoix = choix.charAt(0);
        switch(monChoix) {
        case 'C':
        case 'c':       // Même chose pour majuscule et minuscule
            credit = true; 
            fin = false;
            break;     // Pour ne pas continuer en séquence
        case 'd':
        case 'D':
            credit = false;
            fin = false;
            break;
        case 'f':
        case 'F':
            fin = true;
            break;
        default:      // Etiquette spéciale si aucun des cas prévus n'est vérifié
            fin = true;  // On va considérer que par défaut on s'arrête
        }

        // Poser la question uniquement si on n'a pas choisi de finir
        // Notez que toute cette partie reste identique au programme précédent
        // mais elle est maintenant incluse dans une construction if
        if (!fin) {
            System.out.print("Montant à " + (credit ? "créditer" : "débiter") + " = ");
            
            System.out.flush();
            String lecture = "";      // la chaîne qu'on va lire, initialisée à rien
            try {
                lecture = br.readLine();
            } catch (IOException ioe) {}

            int montant = Integer.parseInt(lecture);  // conversion en int

            if (credit) {
                solde += montant;
            }
            else {
                solde -= montant;
            }
        }

        // Dans tous les cas, imprimer le nouveau solde
        System.out.println("Le nouveau solde est de " + solde + " euros.");
    }
}

Le solde initial est de 0 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? d
Montant à débiter = 123
Le nouveau solde est de -123 euros.
  
Le solde initial est de 0 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? f
Le nouveau solde est de 0 euros.

2.7.2  Instructions itératives

• tant qu'une condition reste vérifiée ; on écrit alors :

  tantque	condition faire
  	instructions
  fintantque

  
  
  
• pour tous les éléments d'un ensemble ; on écrira alors quelque chose du genre :

  pour	tout x Î E faire
  	instructions
  finpour

// Classe Banque - version 1.4
import java.io.*;       // Importer toutes les fonctionnalités de java.io

public class Banque {
    public static void main(String[] args) {
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ir);

        int solde = 0;
        System.out.println("Le solde initial est de " + solde + " euros.");
        
        boolean fin = false;     // variable vraie si on veut s'arrêter
        while (!fin) {  // tant qu'on n'a pas demandé de finir
            System.out.print("Votre choix : [D]ébit, [C]rédit, [F]in ? ");
            String choix = "";
            try {
                choix = br.readLine();
            } catch (IOException ioe) {}

            boolean credit = false;   // variable vraie si c'est un crédit

            // Récupérer la première lettre de la chaîne saisie
            char monChoix = choix.charAt(0);
            switch(monChoix) {
            case 'C':
            case 'c':       // Même chose pour majuscule et minuscule
                credit = true; 
                fin = false;
                break;     // Pour ne pas continuer en séquence
            case 'd':
            case 'D':
                credit = false;
                fin = false;
                break;
            case 'f':
            case 'F':
                fin = true;
                break;
            default:
                fin = true;  // On va considérer que par défaut on s'arrête
            }

            if (!fin) {
                System.out.print("Montant à " + 
                                 (credit ? "créditer" : "débiter") + 
                                 " = ");
                System.out.flush();
                String lecture = "";
                try {
                    lecture = br.readLine();
                } catch (IOException ioe) {}

                int montant = Integer.parseInt(lecture);  // conversion en int

                if (credit) {
                    solde += montant;
                }
                else {
                    solde -= montant;
                }
                // N'afficher le nouveau solde que s'il y a eu une opération
                System.out.println("Le nouveau solde est de " + solde + " euros.");
            }
        }
    }
}

Le solde initial est de 0 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? C
Montant à créditer = 500
Le nouveau solde est de 500 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? D
Montant à débiter = 234
Le nouveau solde est de 266 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? D
Montant à débiter = 65
Le nouveau solde est de 201 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? C
Montant à créditer = 67
Le nouveau solde est de 268 euros.
Votre choix : [D]ébit, [C]rédit, [F]in ? F

        do {
            System.out.print("Votre choix : [D]ébit, [C]rédit, [F]in ? ");
            ... // etc.
        } while (!fin);

  for (int i = 0 ; i < 10 ;  i++) {
    System.out.print("Votre choix : [D]ébit ou [C]rédit ? ");
    ... // etc
  }

  int i = 0;
  while (i < 10) {
    System.out.print("Votre choix : [D]ébit ou [C]rédit ? ");
    ... // etc
    i++;
  }

• continue permet de revenir de manière prématurée en début de boucle. Si par exemple on veut éviter d'effectuer une opération de crédit ou de débit si le montant de l'opération est nul, on peut modifier le programme vu précédemment en ajoutant les lignes sur fond grisé ci-dessous :

      ...
      while (!fin) {  // tant qu'on n'a pas demandé de finir
          ...
          if (!fin) {
              System.out.print("Montant à " + 
                               (credit ? "créditer" : "débiter") + 
                               " = ");
              System.out.flush();
              String lecture = "";
              try {
                  lecture = br.readLine();
              } catch (IOException ioe) {}
  
              int montant = Integer.parseInt(lecture);  // conversion en int
  
              if (montant == 0) {
                  continue;    // repartir en début de boucle while(!fin)
              }
  
              if (credit) {
                  solde += montant;
              }
              else {
                  solde -= montant;
              }
              System.out.println("Le nouveau solde est de " + solde + " euros.");
          }
          ...
      }
          
    

  Il va sans dire qu'il faut éviter autant que faire se peut de recourir à ce genre de construction, qui rend le programme considérablement moins lisible.
  
  
• break, que nous avons déjà vu pour la construction switch, permet aussi de sortir d'une boucle d'itération sans repartir par le test de départ. Ainsi, nous aurions pu écrire notre programme différemment, en prévoyant une boucle infinie (construction while (true)) dont on sort explicitement dès que l'utilisateur donne le code de fin. Le programme peut sembler un peu plus élégant de cette manière ; cependant, il ne faut pas oublier qu'il est a priori contre-intuitif et peu explicite d'écrire while (true) quand on sait pertinemment qu'on va sortir de la boucle à un moment donné. Il faut donc utiliser des instructions comme break et continue avec beaucoup de modération...
  
  Donnons néanmoins une version corrigée de notre programme, avec utilisation de break :

  // Classe Banque - version 1.5
  import java.io.*;       // Importer toutes les fonctionnalités de java.io
  
  public class Banque {
      public static void main(String[] args) {
          InputStreamReader ir = new InputStreamReader(System.in);
          BufferedReader br = new BufferedReader(ir);
  
          int solde = 0;
          System.out.println("Le solde initial est de " + solde + " euros.");
          
          boolean fin = false;     // variable vraie si on veut s'arrêter
          while(true) {  // boucle infinie dont on sort par un break
              System.out.print("Votre choix : [D]ébit, [C]rédit, [F]in ? ");
              String choix = "";
              try {
                  choix = br.readLine();
              } catch (IOException ioe) {}
  
              boolean credit = false;   // variable vraie si c'est un crédit
  
              // Récupérer la première lettre de la chaîne saisie
              char monChoix = choix.charAt(0);
              switch(monChoix) {
              case 'C':
              case 'c':       // Même chose pour majuscule et minuscule
                  credit = true; 
                  fin = false;
                  break;     // Pour ne pas continuer en séquence
              case 'd':
              case 'D':
                  credit = false;
                  fin = false;
                  break;
              case 'f':
              case 'F':
                  fin = true;
                  break;
              default:
                  fin = true;  // On va considérer que par défaut on s'arrête
              }
  
              if (fin) {
                  break;    // sortir de la boucle ici
              }
              else {
                  System.out.print("Montant à " + 
                                   (credit ? "créditer" : "débiter") + 
                                   " = ");
                  System.out.flush();
                  String lecture = "";
                  try {
                      lecture = br.readLine();
                  } catch (IOException ioe) {}
  
                  int montant = Integer.parseInt(lecture);  // conversion en int
  
                  if (credit) {
                      solde += montant;
                  }
                  else {
                      solde -= montant;
                  }
                  System.out.println("Le nouveau solde est de " + solde + " euros.");
              }
          }
      }
  }
    

1

Stricto sensu, les types Java entiers et réels représentent bien entendu des sous-ensembles de Z et de R, du fait de la représentation discrète et bornée des nombres en informatique (cf. § F.2 et F.3).

2

Cet exemple illustre bien la différence fondamentale entre une égalité mathématique -- qui n'aurait aucun sens ici -- et l'affectation : ici, on prend la r-valeur de a, on lui ajoute 3, et on stocke le résultat à l'adresse donnée par la l-valeur de cette même variable a.

3

En règle générale, la déclaration d'une variable doit être immédiatement suivie de l'initialisation de cette variable. Sauf cas très particulier, quand vous n'avez aucun moyen de donner une valeur d'initialisation réaliste à une variable, nous vous conseillons d'adopter ce principe.

4

Pour ceux qui connaissent le langage Pascal, il faut noter qu'en Pascal, `;' est un séparateur d'instructions, ce qui implique entre autres que la dernière instruction d'un bloc n'est pas terminée par un `;' -- en Java, en revanche, chaque instruction se termine par un `;'

5

Pour ceux qui sont curieux de savoir comment ça marche, voir § 4.4.

6

Une fois de plus, les esprits curieux peuvent faire un saut en avant jusqu'au § 4.4 pour mieux comprendre cette opération.

7

Au petit détail près que dans un cas la variable i n'existe que lors de l'itération, alors que dans l'autre elle est déclarée avant le début de la boucle et continue donc sa vie à la sortie de l'itération.

8

On peut noter que ces deux instructions break et continue peuvent être suivies d'une étiquette, qui spécifie soit une boucle englobante (pour continue), soit une instruction quelconque englobante (pour break). Dans ce dernier cas, break indique que l'on veut quitter le niveau englobant ainsi spécifié. Nous ne vous conseillons pas d'utiliser ces fonctionnalités plus avancées...