1. Mot-clé var
Quand on commence à écrire du code en Java, on rencontre un système de types strict : chaque variable doit être déclarée explicitement — indiquer son type. C’est utile pour la fiabilité, mais parfois les écritures deviennent lourdes et alourdissent le code. Pour simplifier la vie, Java a ajouté un outil pratique — l’inférence de type (var).
var permet d’écrire un code plus court et plus propre sans sacrifier la sécurité des types : vous écrivez la valeur et le compilateur déduit le type.
Exemple
var age = 23; // le compilateur déterminera le type du nombre 23 et substituera int age
var name = "Anna"; // le compilateur déterminera le type de "Anna" et substituera String name
var price = 99.99; // le compilateur déterminera le type de 99.99 et substituera double price
Pourquoi var est apparu ?
- Lisibilité : pas besoin d’écrire manuellement des types longs (comme HashMap<String, List<Integer>>).
- Flexibilité : permet de changer plus facilement les types à l’avenir : on modifie à droite — à gauche var s’adapte.
- Style moderne : pratiquement tous les projets Java modernes utilisent var là où le type est lisible d’après l’initialisation.
Quand on peut (et devrait) utiliser var
- Quand le type de la variable est évident d’après la partie droite.
- Quand le type est évident (var price = 100; — il est clair que c’est un int).
- Quand le type est trop long ou complexe (par exemple, HashMap<Integer, List<Calendar>>).
Exemple avec un tableau
var numbers = new int[] { 1, 2, 3, 4 };
Exemple avec une méthode
var input = console.nextLine(); // input est une String (la méthode retourne String)
Quand il vaut mieux ne PAS utiliser var
Si le type n’est pas évident d’après la partie droite, le code peut devenir moins compréhensible. Si, dans un mois, vous ne comprenez plus vous-même de quel type il s’agit, mieux vaut l’indiquer explicitement.
var mystery = DoSomethingVeryComplicated(); // QUI ES-TU, mystery ???
Ici, il vaut mieux indiquer explicitement le type :
String result = DoSomethingVeryComplicated();
Règle d’or : utilisez var uniquement là où cela ne nuit pas à la lisibilité !
var — uniquement pour les variables locales
Le mot-clé var fonctionne uniquement pour les variables locales — à l’intérieur des méthodes. Il est interdit d’utiliser var pour :
- les paramètres de méthode ;
- les champs de classe ;
- les constantes.
Comment fonctionne var « sous le capot »
- Le compilateur Java substitue le type correct lors de la compilation.
- Après compilation, il ne reste aucun var.
- Aucune perte de performance : c’est un confort uniquement pour le développeur.
var year = 2025; // au moment de la compilation devient : int year = 2025;
Erreurs typiques lors de l’utilisation de var
Variable non initialisée :
var a; // ERREUR : le compilateur n’a rien pour déduire le type !
Initialisation ambiguë :
var list = null; // ERREUR : le type de null n’est pas défini !
Réutilisation d’une variable avec des types différents :
var value = 5; // value est un int
value = "Cinq"; // ERREUR : value est déjà int !
Comparaison : types explicites et var
| Scénario | Type explicite | var |
|---|---|---|
| Type sans ambiguïté | |
|
| La méthode retourne un type complexe | |
|
| Tableau | |
|
2. Mot-clé final : déclaration de constantes
Une constante est une variable dont la valeur ne peut pas être modifiée après initialisation. Les constantes rendent le code fiable, compréhensible et protègent des modifications accidentelles de nombres et chaînes importants.
- Le nombre Pi (PI = 3.14159…)
- Le nombre maximal d’utilisateurs (MAX_USERS = 1000)
- Nom de l’entreprise (COMPANY_NAME = "CodeGym")
En Java, on utilise le modificateur final pour déclarer une constante. Il indique au compilateur : « après la première affectation — plus de modification possible ! »
final Type CONSTANT_NAME = value;
Syntaxe
final int DAYS_IN_WEEK = 7;
final double PI = 3.1415926535;
final String GREETING = "Salut, Java!";
Points importants :
- Une variable avec final doit être initialisée (immédiatement ou dans le constructeur — si c’est un champ de classe).
- Toute tentative de modifier la valeur entraînera une erreur de compilation.
Exemple : impossible de modifier une variable final
final int MAX_USERS = 100;
MAX_USERS = 200; // Erreur : impossible d’assigner une nouvelle valeur à une variable final
Remarque : si vous décommentez l’affectation — le projet ne compilera pas.
3. static final : constantes au niveau de la classe
En Java, on a souvent besoin de constantes qui ne dépendent pas d’un objet particulier — « communes » à toute la classe. Pour cela, on utilise le duo static + final.
Pourquoi static final ?
- static — la variable appartient à la classe (une seule pour tous).
- final — la valeur ne peut pas être modifiée.
Syntaxe
public static final double PI = 3.1415926535;
public static final int MAX_USERS = 1000;
public static final String COMPANY_NAME = "CodeGym";
Où les déclarer ? En général — au début de la classe (avant les méthodes).
Exemple d’utilisation dans une classe
public class MathUtils
{
public static final double PI = 3.1415926535;
public static double circleLength(double radius)
{
return 2 * PI * radius;
}
}
Appel :
double len = MathUtils.circleLength(5);
System.out.println(len); // 31.4159...
Notez bien : on accède à la constante via le nom de la classe : MathUtils.PI.
4. Différence entre simple final et static final
final — la valeur du champ ne peut pas être modifiée après initialisation, mais chaque objet a sa propre valeur.
static final — une seule constante pour toute la classe, indépendante des objets.
Exemple : différence en pratique
public class User
{
public final String name; // Chaque User a son propre nom (final)
public static final String COMPANY = "CodeGym"; // Une entreprise commune à tous (static final)
public User(String name)
{
this.name = name;
}
}
User u1 = new User("John");
User u2 = new User("Peter");
System.out.println(u1.name); // John
System.out.println(u2.name); // Peter
System.out.println(User.COMPANY); // CodeGym
Conclusion : name — champ individuel immuable, COMPANY — constante commune.
Conventions de nommage des constantes
On nomme généralement les constantes en MAJUSCULES_AVEC_UNDERSCORES.
public static final int MAX_USERS = 1000;
public static final double GRAVITY = 9.81;
public static final String DEFAULT_GREETING = "Hello, world!";
Conseil : si vous voyez un tel nom — n’essayez pas d’en changer la valeur dans le code : le compilateur ne le permettra pas.
5. Pratique : déclaration et utilisation des constantes
Exemple : classe avec constantes
public class CircleCalculator
{
public static final double PI = 3.1415926535;
public static double getLength(double radius)
{
return 2 * PI * radius;
}
public static double getArea(double radius)
{
return PI * radius * radius;
}
}
Utilisation :
public class Main
{
public static void main(String[] args)
{
double r = 5.0;
System.out.println("Longueur du cercle : " + CircleCalculator.getLength(r));
System.out.println("Aire du cercle : " + CircleCalculator.getArea(r));
}
}
Résultat :
Longueur du cercle : 31.415926535
Aire du cercle : 78.5398163375
Tentative de modification de la constante
CircleCalculator.PI = 3.14; // Erreur de compilation : cannot assign a value to final variable PI
6. Particularités et nuances
Constantes pour les objets
On peut déclarer final pour des références d’objets, mais cela ne rend pas l’objet immuable ! Cela interdit seulement d’assigner une autre référence à la variable.
final StringBuilder sb = new StringBuilder("Hello");
sb = new StringBuilder("World"); // Erreur : impossible d’assigner un nouvel objet
sb.append(", Java!"); // Autorisé — l’état de l’objet change
System.out.println(sb); // Hello, Java!
Conclusion : final protège la référence, pas l’objet. Pour une véritable immuabilité, utilisez des classes immuables (par exemple, String, List.of(), etc.).
Utiliser des constantes plutôt que des « nombres magiques »
Mauvaise pratique :
double area = 3.1415 * r * r; // C’est quoi 3.1415 ? Pourquoi ce nombre précisément ?
Bonne pratique :
double area = PI * r * r; // On comprend immédiatement que le nombre Pi est utilisé
7. Erreurs typiques lors du travail avec les constantes et var
Erreur n°1 : tenter de modifier la valeur d’une variable final. Si une variable est déclarée avec final, une nouvelle affectation entraînera une erreur de compilation.
Erreur n°2 : tenter de déclarer une constante via var. Pour les constantes, utilisez toujours un type explicite avec final ou static final. var — uniquement pour les variables locales.
Erreur n°3 : mauvais nommage des constantes. Les constantes doivent être en MAJUSCULES_AVEC_UNDERSCORES. Une écriture comme final int maxUsers = 100; nuit à la lisibilité.
Erreur n°4 : oublier la portée. Une constante déclarée dans une méthode n’est visible que dans celle-ci. Pour l’utiliser dans toute la classe, déclarez-la au niveau de la classe en tant que static final.
Erreur n°5 : croire que final rend l’objet immuable. final fige la référence, pas l’état de l’objet — ce sont deux choses différentes.
GO TO FULL VERSION