Les variables sont à la base de tous les langages de programmation. Comme leur nom l'indique, les variables font varier l'exécution et de fait lui donne un sens.

A retenir

• Les variables sont toujours typées
• Les identifiants de variables sont composés de caractère alpha-numérique sans espace¹⁾
• Les identifiants de variables commencent par une minuscule ²⁾
• Les identifiants sont CamelCase par convention

On utilise les variables dans les méthodes (et les constructeurs).

Elles n'ont pas besoin d'être déclarée au début des scripts comme en C. Cependant elles doivent être déclarée avant d'être utilisées dans les scripts.

La syntaxe pour déclarer une variable est toujours la même :

// Déclaration
Type identifiant;

// Affectation
identifiant = expression;

// Déclaration et affectation simultanée
Type identifiant = expression;

On peut également déclarer plusieurs variables d'un même type dans une même instruction en les séparants par des virgules :

int a, b, c;

// equivaut à
int a;
int b;
int c;

Cette syntaxe permet également d'affecter des valeurs :

int a=1, b, c=3.14;

// equivaut à
int a = 1;
int b;
int c = 3.14;

Dans les exemples précédents, toutes les variables sont de type int. Les variables sont toujours typées, parmi les types on distingue 2 grandes catégories de type : Les types simples³⁾ et les "type objet"

Les types simples permettent de stoquer des valeurs. D'un point de vue machine, un espace dans la mémoire est réservé pour enregistrer la valeur au moment de l'affectation. Chaque affectation crée un nouvel espace mémoire, même si les valeurs sont identique :

int a = 3.14; // Un espace mémoire est créé pour enregistrer la valeur 3.14
int b = a; // Un autre espace est créé

Dans cet exemple, a et b on des espaces mémoires différents même si la façon dont ils sont affectés laisse à penser qu'il existe un lien physique (numérique) entre a et b, ainsi la modification de a n'a aucun impact sur b, et vice-versa :

int a = 3.14;
int b = a;
a = 0;

System.out.println(a); // affiche 3.14
System.out.println(b); // affiche 0

Parmis les types simples ⁴⁾ on trouve les types liés à la manipulation des nombres.

D'abord les nombres entiers :

int redNumber = 0xF00;
System.out.println(redNumber); // affiche 3840

int octalNumber = 037;
System.out.println(octalNumber); // affiche 31

C'est les nombres à décimales

Un petit exemple simple :

public class DifferenceDoubleFloat 
	{
	public static void main( String[] args )
		{
		// Exemple avec des floats
		float fa = 2, fb = 3, fc = fa / fb;
		System.out.println(fc); // Affiche 0.6666667
		
		// Idem avec des doubles
		double da = 2, db = 3, dc = da / db;
		System.out.println(dc); // Affiche 0.6666666666666666
		}
	}

Comme dans beaucoup d'autres langages, les Booleens sont des valeurs logiques : VRAI et FAUX. La valeur d'un booléen doit être affecté avec les mot clef true et false.

Les types "objet" correspondent à des instances de classe. La mécanique d'affectation est très différente car les variables sont affectées par référence.

Prenons le code suivant :

public class VarReference 
	{
	public static void main( String[] args )
		{
		MaClasse monObjet = new MaClasse()
		MaClasse monAutreObjet = monObjet;
		}
	}

Dans cet exemple, la variable monObjet pointe vers un espace mémoire qui a une instance de MaClasse. Dans la ligne où monAutreObjet est affecté, l'instance de MaClasse n'est pas copié, au final la variable monObjet et monAutreObjet pointe vers le même espace mémoire, ils font référence au même objet.

Vous pouvez déclarer des variables en lui affectant une information qui ne devra pas changer, pour cela on utilise le mot-clef final :

public class DemoFinal
  {
  public static void main( String[] args )
    {
    int nombreDePersonne = 2;
    final int MAX_PERSONNE = 20;
    }
  }

Si par la suite vous chercher à modifier l'affectation de MAX_PERSONNE vous obtiendrez une erreur à la compilation :

public class DemoFinal
  {
  public static void main( String[] args )
    {
    int nombreDePersonne = 2;
    final int MAX_PERSONNE = 20;
    
    // Erreur à la compilation
    MAX_PERSONNE = 25;
    }
  }

Attention, le verrouillage se fait au moment de l'affectation, pas à la déclaration. Ainsi il est tout à fait possible d'écrire :

public class DemoFinal
  {
  public static void main( String[] args )
    {
    int nombreDePersonne = 2;
    int nombreDeGuide = 2
    final int MAX_PERSONNE;
    
    MAX_PERSONNE = 20 * nombreDeGuide;
    }
  }