Les variables en Java : déclaration, affectation et portée expliquées

Qu'est-ce qu'une variable

Une variable est une boîte nommée qui contient une valeur. En Java, chaque variable possède un type fixe - décidé au moment de sa déclaration - et ce type ne change jamais. C'est ce qui rend Java à typage statique : le compilateur connaît le type de chaque variable avant l'exécution du programme, et il refusera de compiler du code qui place une valeur du mauvais type dans une boîte.

Une déclaration comporte trois parties : le type, le nom et (généralement) une valeur initiale.

public class Main {
    public static void main(String[] args) {
        int age = 30;
        String name = "Ada";
        boolean isActive = true;

        System.out.println(name + " is " + age + ", active: " + isActive);
    }
}

Lisez int age = 30; comme « crée un int nommé age et mets 30 dedans ». Le point-virgule termine l'instruction, exactement comme la page sur les commentaires l'a montré pour chaque instruction.

Déclarer maintenant, affecter plus tard

Vous pouvez séparer une déclaration de sa première affectation. Le type n'apparaît qu'une fois, à la déclaration ; ensuite, vous affectez avec seulement le nom et = :

public class Main {
    public static void main(String[] args) {
        int score;        // déclarée, pas encore de valeur
        score = 95;       // affectée maintenant
        score = 100;      // réaffectée - parfaitement valide

        System.out.println(score);
    }
}

Une règle qui piège les débutants : vous devez affecter une valeur à une variable locale avant de la lire. Le compilateur suit cela et rejette le code qui lit une variable locale non initialisée :

int score;
System.out.println(score);   // compile error: variable score might not have been initialized

Ce n'est pas une contrainte gênante mais une fonctionnalité : elle attrape toute une catégorie de bugs avant même que le programme ne s'exécute.

Règles et conventions de nommage

Java impose quelques règles strictes, puis ajoute des conventions par-dessus. Les règles : un nom peut contenir des lettres, des chiffres, _ et $, mais ne peut pas commencer par un chiffre, ne peut pas être un mot-clé réservé (comme int ou class) et est sensible à la casse (age et Age sont deux variables différentes).

Les conventions que tout le monde suit :

• Les variables et les méthodes utilisent le camelCase : firstName, totalScore.
• Les constantes utilisent le UPPER_SNAKE_CASE : MAX_USERS.
• Les noms doivent décrire la valeur : count, pas c ; userEmail, pas x.

public class Main {
    public static void main(String[] args) {
        int itemCount = 3;
        double pricePerItem = 4.50;
        double totalPrice = itemCount * pricePerItem;

        System.out.println("Total: " + totalPrice);
    }
}

Des noms clairs ne sont pas de la décoration : ils déterminent la façon dont votre futur vous lira le code. totalPrice = itemCount * pricePerItem est explicite d'une manière que t = c * p ne sera jamais.

Sûreté de typage : la boîte conserve son type

Comme le type est verrouillé à la déclaration, vous ne pouvez pas placer une valeur du mauvais type dans une variable. Cela attrape les erreurs à la compilation :

int age = 30;
age = "thirty";   // compile error: incompatible types - String cannot become int

L'affectation entre types numériques suit les règles d'élargissement (widening) : un type plus petit s'écoule automatiquement vers un plus grand, mais pas l'inverse. Nous couvrirons cela en détail dans les pages sur les types de données et la conversion de types ; pour l'instant, sachez simplement que le compilateur veille.

Le mot-clé var

Depuis Java 10, vous pouvez écrire var à la place du type et laisser le compilateur l'inférer à partir de la valeur de droite :

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        var name = "Ada";              // inféré comme String
        var count = 5;                 // inféré comme int
        var prices = new ArrayList<Double>();

        prices.add(9.99);
        System.out.println(name + " " + count + " " + prices);
    }
}

var n'est pas du typage dynamique - name est tout autant un String que si vous aviez écrit String name, et vous ne pourrez toujours pas lui affecter un int par la suite. Cela ne fait qu'épargner de la frappe. Le hic : var a besoin d'un initialiseur pour inférer, donc var x; est illégal, et il ne fonctionne que pour les variables locales - jamais pour les champs, les paramètres de méthode ou les types de retour. Utilisez-le là où le type est évident d'après le côté droit ; écrivez le type explicitement quand cela apporte de la clarté.

Les constantes avec final

Lorsqu'une valeur ne doit jamais changer après avoir été définie, marquez-la final. Toute tentative de réaffectation devient une erreur de compilation :

public class Main {
    public static void main(String[] args) {
        final double TAX_RATE = 0.20;
        double price = 50.0;

        System.out.println("Tax: " + price * TAX_RATE);

        // TAX_RATE = 0.25;   // ne compilerait pas - impossible de réaffecter une variable final
    }
}

final exprime une intention (« c'est une valeur fixe ») et laisse le compilateur la protéger pour vous. Faites-y appel chaque fois qu'une valeur est conceptuellement une constante - taux, limites, clés de configuration - afin qu'une réaffectation accidentelle soit attrapée plutôt que de partir en silence comme un bug.

La portée des variables

Une variable n'existe qu'à l'intérieur du bloc - le { ... } - où elle est déclarée, et elle meurt à l'accolade fermante. C'est sa portée. Une variable déclarée à l'intérieur d'une boucle ou d'un bloc if est invisible à l'extérieur :

public class Main {
    public static void main(String[] args) {
        int total = 0;

        for (int i = 1; i <= 3; i++) {
            int square = i * i;     // 'square' ne vit qu'à l'intérieur du corps de cette boucle
            total += square;
        }

        System.out.println("Total: " + total);
        // System.out.println(square);   // erreur - 'square' est hors de portée ici
    }
}

i et square appartiennent tous deux à la boucle et disparaissent à sa fin ; total est déclarée dans le bloc externe, elle survit donc. La leçon pratique : déclarez chaque variable dans le plus petit bloc qui en a besoin. Une portée étroite signifie moins de noms qui se disputent votre attention et moins de risques de mal utiliser une valeur loin de l'endroit où elle a été définie.

Suite : les types de données

Chaque variable de cette page a commencé par un type - int, double, String, boolean. La page suivante détaille les types de données de Java : les huit types primitifs, la taille de chacun, la différence entre primitifs et objets, et quel type choisir selon les cas.