Capsule : Notion de variables

Variable et constante

Reprenons l’algorithme d’Al-Khwârizmî pour la résolution d’équation du deuxième degré. Dans la description qu’il en fait, il commence par décrire la forme générale du problème : « Un carré et des racines égaux à un nombre […] ». En langage mathématique moderne, on écrit cet énoncé plutôt sous la forme : x2 + ax = b où les symboles « a » et « b » sont les données du problème. On appelle ces données « variable » car leurs valeurs varient d’un exemple particulier du problème (une instance du problème) à un autre. Ainsi, dans l’exemple qu’il propose, Al‑Khwârizmî attribue la valeur 10 à la variable a et la valeur 39 à la variable b, mais l’algorithme fonctionne tout aussi bien avec d’autres valeurs.

Dans l’exemple de la recette de cuisine, la quantité de chaque ingrédient est donnée pour un certain nombre de personnes (p. ex. quatre). Mais nous pouvons réaliser cette recette pour un nombre de personnes quelconque, simplement en ajustant proportionnellement les quantités. Puisqu’on peut le faire varier, le nombre de personnes est une variable. En revanche, les rapports entre la quantité de chaque ingrédient et le nombre de personnes spécifiés dans la recette (c’est‑à‑dire les quantités pour une personne) sont des données qui demeurent inchangées quoiqu’il arrive. Ces données sont appelées constante, c’est‑à‑dire des valeurs qui ne varient jamais. Un autre exemple de constante bien connu est le nombre π qui représente le rapport de la circonférence d’un cercle à son diamètre ; ce rapport est toujours le même, quel que soit le cercle.

Dans le contexte de la programmation, une variable est également l’association d’un nom (identificateur) et d’une valeur. Le plus souvent, ce terme est utilisé dans le même sens que celui décrit plus haut. Toutefois, avec un langage de programmation impérive (comme Java), les variables sont parfois utilisées pour garder des résultats intermédiaires dont la valeur peu changer au cours de l’exécution. Pour illustrer cela, revenons une fois encore à l’algorithme de résolution d’une équation du deuxième degré et écrivons-le sous la forme suivante :

  1. Définir la valeur de la variable a (demander à l’utilisateur);
  2. Définir la valeur de la variable b (demander à l’utilisateur);
  3. Prends la moitié de la valeur de la variable a;
  4. multiplie le résultat par lui-même;
  5. ajoute la valeur de la variable b au résultat;
  6. extrais la racine du résultat;
  7. ôte la moitié de la valeur de la variable a au résultat;
  8. le résultat est la racine recherchée.

À chaque étape de l’algorithme on obtient un résultat que l’on utilise dans l’étape suivante mais qui peut ensuite être oublié. Dans un tel cas, la valeur variable résultat peut être remplacé à la fin chaque étape de calcul. La figure 1 montre une implémentation possible de cet algorithme en Java.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package ch.epaifribourg.ict.m403;

import java.util.Scanner;

public class QuadraticEquation {

    public static void main(String [] args) {
        
        // Crée un objet Scanner pour lire des caractères au clavier.
        Scanner input = new Scanner(System.in);

        // Affiche un message qui demande à l’utilisateur de saisir 
        // la valeur de la variable a.
        System.out.print("Veuillez saisir la valeur de la variable a : ");
        // Lis la valeur au clavier et attribue cette 
        // valeur à la variable a.
        double a = input.nextDouble();
        
        // Affiche un message qui demande à l’utilisateur de saisir 
        // la valeur de la variable b.
        System.out.print("Veuillez saisir la valeur de la variable b : ");
        // Lis la valeur au clavier et attribue cette 
        // valeur à la variable a.
        double b = input.nextDouble();
        
        // Déclare la variable result.
        double result;

        // Prends la moitié de la valeur de la variable a et 
        // attribut le résultat à la variable result.
        result = a / 2;

        // Multiplie la valeur de la variable result par elle-même et 
        // attribut le résultat à la variable result.
        result = result * result;

        // Ajoute la valeur de la variable b à celle de la variable 
        // result et attribut le résultat à la variable result.
        result = result + b;

        // Extrais la racine de la valeur de la variable result et
        // attribut le résultat à la variable result.
        result = Math.sqrt(result);

        // Ôte la moitié de la valeur de la variable a de la valeur de la 
        // variable result et attribut le résultat à la variable result.
        result = result - a / 2;

        // La valeur de la variable result est le nombre que cherché.
        System.out.println("La racine est : " + result);
    }
}
Fig. 1 – Code du programme QuadraticEquation

On appelle affectation, l’instruction permet de remplacer la valeur d’une variable par une nouvelle une valeur ou le résultat d’un calcul. Si une variable contient déjà une valeur, l’affectation a pour effet d’écraser cette valeur par une nouvelle. Nous reviendrons sur cette opération de manière plus détaillée.

Déclaration et type de données

La plupart des langages de programmation impératifs (dont Java) exigent que l’on déclare les variables que l’on va utiliser dans un programme pour faciliter la détection d’erreurs. En effet, si on ne déclare pas les variables, le compilateur n’a aucun moyen de dire si une variable avec un nom qu’il ne connaît pas encore est une nouvelle variable ou si c’est un nom que l’on a mal orthographier. Par exemple, si la déclaration des variables n’était pas exigée, le code de la figure 2 serait valide et la variable resutl (result mal orthographié) serait considérée comme une nouvelle variable et la variable result resterait inchangée. La déclaration des variables permet d’éviter ce genre d’erreurs souvent difficile à détecter.

1
2
3
4
5
6
7
8
9
10
11
12
        ...

        // Extrais la racine de la valeur de la variable result et
        // attribut le résultat à la variable result.
        resutl = Math.sqrt(result); // <--- la valeur est affectée à la variable result 
                                    //      au lieu de result

        // Ôte la moitié de la valeur de la variable a de la valeur de la 
        // variable result et attribut le résultat à la variable result.
        result = result - a / 2;
        
        ...
Fig. 2 – Erreur dans l’écriture de la variable result

De plus, la syntaxe de bon nombre de langages, dont Java, exige que l’on spécifie le type de donnée d’une variable. Le type de données, ou simplement type, définit un ensemble de valeurs (par exemple les nombres entiers entre -128 et +127) et un ensemble d’opérations que l’on peut appliquer à ces valeurs. Si le type de donnée d’une variable est spécifiée et qu’on essaie d’appliquer à cette variable une opération qui ne serait pas définie par le type, le compilateur peut facilement nous informer.

Types de données en Java

En Java il existe un très grand nombre de types de données, mais pour commencer nous allons considérer uniquement les types qui représentent des nombres, des valeurs booléennes (vrai ou faux) et des textes (chaîne de caractères).

Les types qui permettent de représenter des nombres entiers sont au nombre de quatre :

  • byte (8 bits)
  • short (16 bits)
  • int (32 bits)
  • long (64 bits)

Les types qui permettent de représenter des nombres à virgule sont au nombre de deux :

  • float (précision de 7 chiffres significatifs)
  • double (précision de 15 chiffres significatifs)

Les autres types que nous allons couramment utiliser sont :

  • char (un seul caractère UNICODE)
  • boolean (une valeur true ou false)
  • String (n’importe quelle chaîne de caractères)
  • Scanner (un objet qui permet de lire des valeurs au clavier)

Attention, le nom des types byte, short, int, long, float, double, char et boolean, appelés types primitifs, commence par une minuscule, le nom de tous autres types commence par une majuscule.

Déclaration en Java

En Java, la déclaration d’une variable à la syntaxe suivante :

<nom du type> <nom de la variable>

Selon la syntaxe de Java, le nom de variable doit commencer par une lettre, doit être composé uniquement de lettre et de chiffres et ne doit pas contenir d’espace.

Par convention, le nom d’une variable doit être écrit en lower camel case, c’est-à-dire que le nom doit commencer par une minuscule et si le nom se compose de plusieurs mots, on met en majuscule la première lettre de chaque mot.