Portée des variables en Java

Portée des variables

La portée d'une variable désigne les parties du code source où elle est utilisable. Ce peut être par exemple, le projet entier, le fichier dans lequel la variable est déclarée, ou simplement une partie spécifique de ce fichier.

Dans ce cours nous utiliserons le terme de variable globale pour désigner une variable dont la portée est celle du fichier où elle est déclarée.

Inversement, nous dirons qu'une variable est locale si sa portée se restreint à une partie seulement du fichier où elle est déclarée.

En Java, une manière d'obtenir une variable globale est de la déclarer dans la zone de déclaration que nous avons définie dans le cours précédent.

Jusqu'à présent toutes les variables que vous avez utilisées dans les exercices de ce cours sont donc des variables globales: elles peuvent être utilisées dans tout le fichier source.

Pour obtenir une variable locale, il faut la déclarer à l'intérieur d'un sous-programme.

Pour l'instant, nous n'avons pas défini ce qu'est un sous-programme de manière générale. Par contre, vous connaissez les procédures évènementielles qui représentent une catégorie particulière de sous-programme.

Nous allons donc, pour l'instant, baser nos explications concernant la portée des variables en utilisant uniquement les procédures évènementielles. Gardez toutefois à l'esprit que ces explications seront valables pour n'importe quel type de sous-programme.

Pour illustrer la différence entre une variable locale et une variable globale, nous commencerons par quelques exemples de programmes.

Ces différents exemples de programmes se trouvent dans le répertoire Java-Exemple-Sous-Programme. Vous pouvez donc les ouvrir et les exécuter pour vous aider à mieux comprendre.

Exemple 1

Cet exemple ce trouve dans le dossier:

 Exemple-Java-Sous-Programme/Global

Voici le formulaire du programme:

et voici un extrait du code de ce programme:

public class Global ... {
    
    int x;
    ....
    private void BT_AffecterActionPerformed (...) {                                            
        x = 1961;
    }                                           

    private void BT_AfficherActionPerformed(...) {                                            
        es.Afficher(x, CT_X);
    }

Dans ce premier exemple, la variable x est déclarée à l'extérieur de tout sous-programme. Il s'agit donc d'une variable globale.

Cela a les conséquences suivantes:

x peut être utilisée dans tout le fichier de code où elle est déclarée et par conséquent, à l'intérieur de toute les procédures définies dans ce fichier. Dans notre exemple, la variable x est utilisée dans les deux procédures évènementielles BT_AffecterActionPerformed et BT_AfficherActionPerformed. La procédure BT_AffecterActionPerformed affecte la valeur 1961 à x et la procédure BT_AffecterActionPerformed affiche la valeur de x.
x a une durée de vie égale à celle de l'exécution du programme: dès le démarrage du programme, de l'espace mémoire est alloué à la variable x. Lorsque le programme s'arrête, cet espace mémoire n'est plus réservé à la variable et on peut donc considérer qu'elle cesse d'exister. Pour vous en convaincre, lancez le programme, affecter la valeur 1961 à x. Vérifiez que x a bien la valeur 1961. Arrêter le programme et relancer le. Vous constarez que x n'a plus la valeur 1961, mais la valeur zéro (car c'est valeur par défaut des variables de type entier).

Exemple 2

Cet exemple ce trouve dans le dossier:

 Exemple-Java-Sous-Programme/Local0

Nous déclarons cette fois-ci la variable x à l'intérieur de la procédure BT_AffecterActionPerformed. On constate alors que le projet n'est pas compilable. Le compilateur java détecte une erreur :

Cette erreur est localisée dans l'instruction es.Afficher(x, CT_X) de la procédure BT_AfficherActionPerformed.

Comment expliquer cette erreur ?

Le problème vient du fait qu'une variable locale n'est accessible qu'à l'intérieur du sous-programme où elle est déclarée. Autrement dit, la portée d'une variable locale est limitée à ce sous-programme.

Dans notre exemple, x n'est donc définie qu'à l'intérieur de la procédure BT_AffecterActionPerformed et nul part ailleurs.

Exemple 3

Cet exemple ce trouve dans le dossier:

 Exemple-Java-Sous-Programme/Local1

Il s'agit d'une version légèrement modifiée du programme précédent, dans laquelle la variable x est déclarée dans la zone de déclaration ainsi qu'à l'intérieur de la procédure BT_AffecterActionPerformed:

public class Local1 ... {
    
  int x = 1935;
  .....
  private void BT_AffecterActionPerformed(...) {                                            
    int x = 1961;
  }                                           

  private void BT_AfficherActionPerformed(...) {                                            
     es.Afficher(x, CT_X);
  }

Cet exemple ne provoque aucun message d'erreur.

Vous vous demandez peut-être comment une telle chose est possible, car a priori une variable ne peut pas être déclarée deux fois. On devrait avoir un message d'erreur. Or il n'en est rien !

En réalité, il y a deux variables distinctes: la variable x déclarée en global et celle déclarée en local dans la procédure BT_AffecterActionPerformed.

Bien qu'elles portent le même nom, ces deux variables sont totalement indépendantes.

Mais si le compilateur java rencontre une instruction utilisant x, comment peut-il savoir de quelle variable il s'agit ?

Il s'en sort de la manière suivante:

l'affectation x = 1961, dans BT_AffecterActionPerformed doit agir sur la variable locale x car x est défini dans cette procédure.
par contre, l'instruction es.Afficher(x, CT_X) dans BT_AfficherActionPerformed agit sur la variable globale x car cette procédure ne contient aucune déclaration de la variable x.

De manière générale:

La déclaration locale est prioritaire sur la déclaration globale.

Autrement dit, si une variable globale est redéclarée à l'intérieur de certains sous-programmes alors:

à l'intérieur de ces sous-programmes, c'est la déclaration locale qui l'emporte.

à l'intérieur d'un sous-programme dans laquelle cette variable n'est pas redéclarée, c'est la déclaration globale qui est prise en compte.

A présent, faites l'expérience suivante:

lancez le programme et cliquez sur le bouton Afficher X. Vous constaterez qu'il affiche la valeur 1935 .

cliquez sur le bouton Affecter la valeur 1961 à X, puis sur Afficher X. Vous constaterez, que la valeur affichée est toujours 1935. Il semblerait donc que la variable x n'a pas été modifiée.

Comment expliquer ceci ?

Lorsque vous lancez le programme, la JVM affecte la valeur 1935 à la variable x déclarée en globale. Lorsque vous cliquez ensuite sur le bouton Afficher X, elle exécute la procédure BT_AfficherActionPerformed dans laquelle ne figure aucune déclaration locale de la variable x. Cette procédure affiche donc la valeur de la variable globale x qui vaut 1935.

Lorsque vous cliquez sur le bouton Affecter la valeur 1961 à X, elle exécute la procédure BT_AffecterActionPerformed dans laquelle x est déclarée en local. Cette même procédure affecte la valeur 1961 à x. Mais comme x est déclarée dans cette procédure, cette affectation agit sur la variable x déclarée dans cette procédure et non pas sur la variable x déclarée en global.

Enfin, lorsque vous recliquez sur le bouton Afficher X, il exécute la procédure BT_AfficherActionPerformed dans laquelle ne figure aucune déclaration locale de la variable x. Cette procédure affiche donc la valeur de la variable globale x qui est toujours égale à 1935.

Principes généraux

Définition

Par définition, une variable est locale si elle est déclarée à l'intérieur d'un sous-programme. Elle est globale dans le cas contraire.

Portée

Une variable globale est utilisable par tous les sous-programmes contenus dans le fichier où elle est déclarée.

Une variable locale, au contraire, n'est utilisable qu'à l'intérieur du sous-programme dans lequel elle est déclarée.

Durée de vie

La durée de vie d'une variable globale est égale à celle du programme. La zone mémoire allouée pour cette variable lui reste allouée tant que le programme s'exécute.

Par contre:

Pour une variable locale la durée de l'allocation mémoire est celle de l'exécution du sous-programme dans laquelle elle est déclarée. Autrement dit, une fois la procédure exécutée l'ordinateur ne peut absolument pas se souvenir de sa dernière valeur !

Durant l'exécution d'un programme, une variable locale peut donc avoir plusieurs vies: elle renait chaque fois que le sous-programme contenant sa déclaration s'exécute et meurt chaque fois qu'il se termine.

Déclarations multiples

Avec les variables locales, il devient de possible de déclarer plusieurs fois une variable de même nom.

Si une "même" variable est déclarée en local et en global (voir exemple3):

Dans les sous-programmes où cette variable n'est pas déclarée, c'est la déclaration globale qui est prise en compte.
A l'intérieur des sous-programmes ou cette variable est déclarée, c'est la déclaration locale qui est prise en compte.

Nous n'avons pas présenté d'exemple de ce type, mais il est également possible de déclarer plusieurs variables de même nom dans des sous-programmes distincts. Tout se passe alors comme si on avait donné des noms de variables distincts pour ces différentes déclarations. Autrement dit:

Si une variable de même nom est déclarée localement plusieurs fois, chaque déclaration locale engendre une variable totalement indépendante des autres.