# Java Variables : déclaration, initialisation, types et exemples

Les variables en Java sont des conteneurs qui peuvent stocker certains [types de données Java](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/types-de-donnees-java/). Elles sont réparties en variables locales, variables d’instance et variables statiques. Si la taille d’une variable ne peut pas être modifiée ultérieurement en Java, son contenu, en revanche, peut être, lui, adapté après coup.

## Les variables Java, c’est quoi au juste ?

Dans tout langage de programmation, il y a des variables qui sont utilisées pour travailler à l’intérieur d’un code et donc d’un programme. Il s’agit plus précisément de **conteneurs dans lesquels sont stockées certaines données d’un type, et uniquement de ce type**. En Java, les variables peuvent stocker d’une part des [types de données primitifs](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-primitives/) comme des nombres entiers, des nombres à virgule, des valeurs de vérité (`true` et `false`) ou encore des chiffres isolés et d’autre part des types de données complexes comme [string Java](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-strings/). Les variables Java ont une taille déterminée et clairement définie qui ne peut pas être modifiée ultérieurement. Leur contenu peut toutefois être modifié après coup. Découvrez ci-dessous les différentes variables accompagnées d’exemples.

## Déclarer et initialiser une variable Java

Tout d’abord, voyons comment les variables sont déclarées en Java et comment elles sont initialisées par la suite. Ce processus est identique pour tous les types. Pour la **déclaration**, il faut **deux paramètres** : d’abord le type de données qui doit être stocké dans cette variable ; puis le nom de la variable Java.

Pour **l’initialisation** qui suit, **trois facteurs** sont importants : outre le type de données et le nom de la variable, il faut une valeur. L’initialisation permet donc d’attribuer une valeur à la variable qui était vide jusque-là. La syntaxe se présente comme suit :

```java
Datentyp Name = Valeur;
```

## Les trois types de variables en Java

Les variables Java peuvent être réparties en trois catégories différentes : les variables locales, les variables d’instance et les variables statiques.

### Les variables locales

Si `var` Java est déclarée **dans le corps de fonction**, on parle de variable locale. Elle ne peut être utilisée qu’à l’intérieur d’une méthode, d’un constructeur ou d’un bloc. Voici, dans l’exemple suivant, une variable locale en pratique :

```java
public class Main {
	public static void main(String[] args) {
		int var = 5;
		System.out.println("La variable locale est : " + var);
	}
}
```

L’indication obtenue se présente ainsi :

```java
La variable locale est : 5
```

### Les variables d’instance

Si `var` Java est déclarée **dans la classe, mais en dehors de la méthode, du constructeur ou d’un bloc**, on parle de variable d’instance. Cette dernière est créée lorsque vous créez un objet avec le mot-clé `new`. Contrairement aux variables locales, les variables d’instance ont des valeurs par défaut. Celles-ci sont 0 ou 0.0 pour les types numériques, `false` pour les types booléens et zéro pour les références d’objets. Leur utilisation est illustrée dans l’exemple suivant. Pour ce faire, imaginons un groupe de personnes souhaitant participer à un cadeau d’anniversaire et dressons la liste de la contribution de chacune d’entre elles.

```java
public class Cadeau {
	public String nom;
	private double contribution;
	public Cadeau (String personne) {
		nom = personne;
	}
	public String getNom() {
		return nom;
	}
	public void setNom(String nom) {
		this.nom = nom;
	}
	public double getContribution() {
		return contribution;
	}
	public void setContribution(double ContributionParticipant) {	
		contribution = ContributionParticipant;
	}
	public static void main(String[] args) {
		Cadeau Participant = new Cadeau ("Pierre");
		Participant.setContribution(10);
		System.out.println("Nom: " + Participant.getNom());
		System.out.println("Contribution = " + Participant.getContribution());
		Cadeau Participant2 = new Cadeau ("Isabelle");
		Participant2.setContribution(15);
		System.out.println("Nom: " + Participant2.getNom());
		System.out.println("Contribution = " + Participant2.getContribution());
	}
}
```

La sortie pour cet extrait de code est la suivante :

```java
Nom: Pierre
Contribution = 10.0
Nom: Isabelle
Contribution = 15.0
```

### Les variables statiques

Si les deux autres variables Java ne peuvent pas être déclarées comme statiques, il en va, par définition, autrement pour la variable statique. Celle-ci est déclarée **en dehors d’une méthode, d’un constructeur ou d’un bloc** et appartient donc à la classe et non à une instance. Elle est donc utilisée en commun par toutes les instances de la classe. Son allocation mémoire a lieu au moment où la classe est mise en mémoire. Voici un exemple de code :

```java
public class Cadeau {
	public static String Participant = "Pierre";
	public static void main(String[] args) {
		System.out.println("Participant : " + Cadeau.Participant);
	}
}
```

L’indication obtenue est :

```java
Participant : Pierre
```

## Comment créer différentes variables ?

La procédure pour créer des variables Java est toujours relativement similaire. Voici des exemples des types de variables les plus courants avec des explications sur leurs particularités.

### boolean

Un [boolean](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/booleen-java/) ne peut contenir que les valeurs de vérité **`true` (vrai) ou `false` (faux)**. La variable est déclarée de la manière suivante :

```java
public class Main {
	public static void main(String[] args) {
		boolean Les_frites_sont_délicieuses = true;
		System.out.println(Les_frites_sont_délicieuses);
	}
}
```

Voici l’indication générée :

```java
true
```

### int

`int` est le type de données le plus utilisé **pour les nombres entiers**. Pour déclarer des variables Java de ce type, procédez comme suit :

```java
public class Main {
	public static void main(String[] args) {
		int x = 10;
		System.out.println(x);
	}
}
```

L’indication obtenue est :

```java
10
```

### float

`float` est utilisé **pour les nombres décimaux**. La variable correspondante est déclarée ainsi :

```java
public class Main {
	public static void main(String[] args) {
		float x = -17.03f;
		System.out.println(x);
	}
}
```

La sortie se présente ainsi :

```java
-17.03
```

### char

`char` contient un **caractère unique**, entouré par des guillemets simples. Voici un exemple de code correspondant.

```java
public class Main {
	public static void main(String[] args) {
		char x = 'S';
		System.out.println(x);
	}
}
```

La sortie aura la forme suivante :

```java
S
```

### String

Outre les types de données primitifs ci-dessus, les variables Java peuvent également contenir des **chaînes de caractères complètes** ou des strings. Ces chaînes sont entourées de doubles guillemets. En voici un exemple :

```java
public class Main {
	public static void main(String[] args) {
		String exemple = " Voici un exemple de String en Java.";
		System.out.println(exemple);
	}
}
```

La sortie se présente ainsi :

```java
Voici un exemple de String en Java.
```


This is a markdown version of: [https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-variables/](https://www.ionos.com/fr-be/digitalguide/sites-internet/developpement-web/java-variables/) for AI/LLM consumption.