Variables Java

Une variable est un emplacement mémoire nommé avec un type fixe. Une fois déclarée, le type ne peut pas changer, mais la valeur qu'elle contient peut généralement évoluer. Le type contrôle la quantité de mémoire utilisée par la variable, les valeurs autorisées et les opérations que le compilateur permet. Ce chapitre explique comment déclarer des variables, les initialiser, les quatre catégories que Java distingue, ainsi que les règles relatives à final, var et la portée.

Déclarer une variable

La forme de base est un type suivi d'un nom et d'un point-virgule :

type name;

Par exemple, int score; réserve un emplacement de type int nommé score. Le type est l'un des types intégrés de Java (int, double, boolean, char, …) ou n'importe quelle classe ou interface — voir Java Data Types pour la liste complète.

Les déclarations les plus simples :

int score;
String name;
boolean ready;

Ces instructions réservent de la mémoire ; elles n'y placent pas encore de valeur.

Initialiser

Pour affecter une valeur, utilisez = :

int score = 0;
String name = "Ada";
boolean ready = true;

Vous pouvez aussi déclarer et affecter séparément :

int score;
score = 0;

Ou déclarer plusieurs variables du même type en une seule fois :

int x = 1, y = 2, z = 3;

(Une variable par ligne est généralement plus lisible.)

Les variables locales doivent être affectées avant utilisation

Une variable locale — déclarée à l'intérieur d'une méthode — n'a pas de valeur par défaut. Le compilateur refuse de vous laisser la lire tant que vous n'avez pas affecté une valeur :

public static void main(String[] args) {
    int x;
    // System.out.println(x); // compile error: variable x might not have been initialized
    x = 5;
    System.out.println(x);    // OK
}

Il s'agit de l'une des fonctionnalités de sécurité les plus utiles de Java : elle détecte une catégorie de bogues que d'autres langages laissent passer.

Les quatre catégories de variables

Java distingue quatre catégories de variables selon l'endroit où elles sont déclarées :

1. Variables locales — déclarées à l'intérieur d'une méthode ou d'un bloc. N'existent que le temps de l'exécution de la méthode. Pas de valeur par défaut. Doivent être initialisées avant utilisation.
2. Variables d'instance (champs) — déclarées à l'intérieur d'une classe mais en dehors de toute méthode. Une copie par objet. Valeur par défaut 0 / 0.0 / false / null.
3. Variables statiques (variables de classe) — déclarées avec le mot-clé static. Une seule copie partagée par toutes les instances de la classe. Valeur par défaut 0 / false / null.
4. Paramètres — déclarés dans la signature d'une méthode ; reçoivent la valeur transmise par l'appelant.

public class Counter {
    static int totalCounters;   // static (class) variable
    int count;                  // instance variable

    public void add(int delta) { // delta is a parameter
        int doubled = delta * 2; // doubled is a local variable
        count += doubled;
    }
}

Vous retrouverez les variables d'instance et statiques dans les chapitres sur la POO ; pour l'instant, la plupart des variables que vous écrirez seront locales.

final — affecter une seule fois

Préfixer une déclaration avec final fait de la variable une liaison unique. Après la première affectation, elle ne peut plus changer :

final int MAX_RETRIES = 3;
// MAX_RETRIES = 4; // compile error: cannot assign a value to final variable

Utiliser final pour les éléments qui ne sont pas censés changer rend l'intention explicite et permet au compilateur de détecter les réaffectations accidentelles. Par convention, les champs final qui contiennent des constantes fixes sont nommés en UPPER_SNAKE_CASE (voir Java Naming Conventions).

Notez que final fige la liaison, pas l'objet vers lequel elle pointe. Une référence final ne peut pas être réaffectée, mais l'objet vers lequel elle pointe peut toujours être modifié :

final int[] nums = {1, 2, 3};
nums[0] = 99;        // OK — the array contents change
// nums = new int[5]; // compile error — the reference is final

var — laisser le compilateur choisir le type

Depuis Java 10, vous pouvez écrire var à la place d'un type pour les variables locales lorsque le côté droit rend le type évident :

var name = "Ada";          // inferred as String
var score = 0;             // inferred as int
var values = new int[10];  // inferred as int[]

var n'est pas du typage dynamique — la variable conserve un type fixe, c'est le compilateur qui le détermine à votre place. Restrictions :

• Uniquement pour les variables locales.
• Le côté droit doit être présent (var x; est illégal).
• Non autorisé pour les paramètres, les variables d'instance ou les variables statiques.

var est le plus utile lorsque le nom du type est long ou évident d'après le contexte :

var orders = new HashMap<String, List<Order>>();

Utilisez des déclarations de type ordinaires lorsque le type inféré n'est pas évident pour un lecteur.

Portée

Une variable est en portée — visible — de sa déclaration jusqu'à la fin du bloc qui la contient :

public static void main(String[] args) {
    int outer = 1;

    if (outer > 0) {
        int inner = 2;
        System.out.println(outer + inner);   // both visible
    }

    // System.out.println(inner);   // compile error: inner is out of scope
}

Vous ne pouvez pas déclarer deux variables locales avec le même nom dans des portées qui se chevauchent — mais un nom peut être réutilisé dans deux blocs distincts et non superposés :

for (int i = 0; i < 3; i++) { /* i lives here */ }
for (int i = 0; i < 5; i++) { /* a new, separate i */ }  // fine

Maintenir des portées de variables réduites est une bonne pratique : déclarez chaque variable aussi près que possible de son premier usage.

Un exemple fonctionnel

Et ensuite

Java Naming Conventions couvre les règles standard que tout code Java respecte pour les noms de classes, de méthodes, de variables et de constantes.

Pratique