Declarer des variables

Vous avez déjà vu quelques variables. Une variable est un nom donné à un espace mémoire qui stocke des données. Lorsque vous déclarez une variable, vous devez spécifier son type et lui donner un nom. Donner une valeur à une variable s’appelle l’initialisation d’une variable. Pour initialiser une variable, il suffit d’écrire le nom de la variable suivi d’un signe égal, suivi de la valeur souhaitée. Voici un exemple qui montre la déclaration et l’initialisation d’une variable en une ligne :

String nomZoo = "Le Plus Beau Zoo";

Dans les sections suivantes, nous verrons comment définir correctement des variables en une ou plusieurs lignes.

Identification des Identificateurs

Il n’est pas surprenant que Java ait des règles précises concernant les noms des identificateurs. Un identificateur est le nom d’une variable, d’une méthode, d’une classe, d’une interface ou d’un package. Heureusement, les règles pour les identificateurs des variables s’appliquent à tous les autres types que vous pouvez nommer.

Il n’y a que quatre règles à retenir pour les identificateurs légaux :

• Les identificateurs doivent commencer par une lettre, un symbole monétaire ou un symbole ‘_’. Les symboles monétaires incluent le dollar ($), le yuan (¥), l’euro (€), etc.
• Les identificateurs peuvent inclure des chiffres mais ne peuvent pas commencer par eux.
• Un simple underscore ‘_’ n’est pas autorisé comme identificateur.
• Vous ne pouvez pas utiliser un mot réservé Java. Un mot réservé est un mot spécial que Java a mis de côté et que vous n’êtes pas autorisé à utiliser. N’oubliez pas que Java est sensible à la casse.

Mots Réservés en Java

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	short	static	strictfp	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

Il existe d’autres noms que vous ne pouvez pas utiliser. Par exemple, true, false, et null sont des valeurs littérales, donc ils ne peuvent pas être des noms de variables.

Les exemples suivants sont légaux :

long identifiantValide;
float €IdentifiantValide2;
boolean _aussiValidIdentificateur;
char __ToujoursValideQuoiqueMoinsJoli$;

Ces exemples ne sont pas légaux :

int 3DPointClasse;    // les identificateurs ne peuvent pas commencer par un nombre
byte parisAmarseille@;  // @ n'est pas une lettre, un chiffre, $ ou _
String *$cafe;         // * n'est pas une lettre, un chiffre, $ ou _
double public;        // public est un mot réservé
short _;             // un simple underscore n'est pas autorisé

camelCase et snake_case

Bien que vous puissiez faire des choses étranges avec les noms d’identificateurs, évitez-le. Java a des conventions pour que le code soit lisible et cohérent. Par exemple, le camel case a la première lettre de chaque mot en majuscule. Les noms de méthodes et de variables sont généralement écrits en camel case avec la première lettre en minuscule, comme versHaut(). Les noms de classes et d’interfaces sont également écrits en camel case, avec la première lettre en majuscule, comme ListeTableau.

Un autre style s’appelle le snake case. Il utilise simplement un underscore (_) pour séparer les mots. Java utilise généralement le snake case en majuscules pour les constantes et les valeurs enum, comme NOMBRE_DRAPEAUX.

Pour l’instant, chaque déclaration est sur sa propre ligne, voyons ensemble dans la section suivant comment faire une declaration de variable multiple.

Déclaration de Variables Multiples

Les Bases de la Déclaration Multiple

Pour commencer, vous pouvez déclarer et initialiser plusieurs variables dans la même instruction. Prenons un exemple concret. Combien de variables pensez-vous sont déclarées et initialisées dans l’exemple suivant ?

void clotureDuJardin() {
    String chaine1, chaine2;
    String chaine3 = "oui", chaine4 = "non";
}

Dans cet exemple, quatre variables de type String ont été déclarées : chaine1, chaine2, chaine3, et chaine4. En effet, vous pouvez déclarer plusieurs variables dans la même déclaration tant qu’elles sont toutes du même type. De plus, vous pouvez également initialiser n’importe laquelle ou toutes ces valeurs.

Pièges Courants et Cas Particuliers

Maintenant, voici où ça devient intéressant. Examinons attentivement l’exemple suivant :

void peindreCloture() {
    int nombre1, nombre2, nombre3 = 0;
}

À première vue, trois variables ont été déclarées : nombre1, nombre2, et nombre3. Cependant, il y a une subtilité importante : une seule de ces valeurs a été initialisée : nombre3. Les deux autres restent déclarées mais non initialisées.

Voici l’astuce principale : chaque fragment séparé par une virgule est une petite déclaration en soi. Par conséquent, l’initialisation de nombre3 ne s’applique qu’à nombre3. Elle n’a aucun effet sur nombre1 ou nombre2, même s’ils apparaissent dans la même instruction.

Règles de Déclaration et Bonnes Pratiques

Par ailleurs, évitez cette situation courante :

int nombre, String valeur; // NE COMPILE PAS

Ce code ne compile pas pour une raison simple : il tente de déclarer plusieurs variables de types différents dans la même instruction. En effet, le raccourci de déclaration multiple n’est valide que lorsque toutes les variables partagent le même type.

Pour mieux comprendre ces règles, analysons les déclarations suivantes :

boolean bool1, bool2;
String texte1 = "1", texte2;
double decimal1, double decimal2;
int entier1; int entier2;
int entier3; entier4;

Tout d’abord, les lignes avec bool1 et texte1 sont parfaitement légales. Chacune déclare deux variables, avec des initialisations optionnelles. Ensuite, la ligne avec entier1 est également valide, car chaque déclaration est séparée par un point-virgule, créant ainsi deux instructions distinctes.

En revanche, la ligne avec decimal1 pose problème. Même si decimal1 et decimal2 sont du même type, la syntaxe de déclaration n’est pas correcte. La règle est claire : pour une déclaration multiple, le type ne doit être déclaré qu’une seule fois.

Conseils Pratiques pour le Code Professionnel

Pour finir, considérons la dernière ligne avec entier3. Pour mieux comprendre pourquoi elle n’est pas valide, réécrivons-la sur des lignes séparées :

int entier3;
entier4;

Maintenant, il devient évident que la seconde ligne n’est pas une déclaration valide – il manque le type. Dans un contexte professionnel, il est fortement recommandé de limiter vos déclarations à une par ligne. Cette approche rend votre code plus lisible et plus maintenable pour toute l’équipe.