Fiche de Révision : Instructions et Expressions en Java

Introduction

En Java, la maîtrise des instructions et des expressions est fondamentale pour écrire des programmes efficaces et compréhensibles. Ces deux notions constituent la base de la structure d’un programme Java. Cette fiche couvre les concepts clés, les types d’expressions, les instructions principales, ainsi que leur utilisation et leur syntaxe.

1. Définitions Clés

Instruction (Statement) : unité élémentaire d’exécution en Java. Une instruction réalise une action. Elle se termine toujours par un point-virgule ;.
Expression : combinaison de variables, constantes, opérateurs et appels de méthodes qui produit une valeur.

Important : Toute instruction peut contenir une ou plusieurs expressions, mais une expression n’est pas forcément une instruction.

2. Les Expressions en Java

2.1. Types d’Expressions

Expressions littérales
Valeurs constantes directement codées, par exemple :
- 5 (int)
- 3.14 (double)
- "Hello" (String)
- 'a' (char)
- true (boolean)
Expressions de variables
Utilisation d’une variable pour représenter une valeur, par exemple :
```
int x = 10;
int y = x + 5;  // x est une expression ici
```
Expressions arithmétiques
Combinaisons d’opérateurs arithmétiques : +, -, *, /, %.
Exemple :
```
int result = (a + b) * c / 2;
```
Expressions logiques
Utilisation d’opérateurs logiques : && (and), || (or), ! (not).
Exemple :
```
boolean test = (a > b) && (c != d);
```
Expressions relationnelles
Opérateurs : ==, !=, <, >, <=, >=.
Exemple :
```
boolean isEqual = (x == y);
```
Expressions d’appel de méthode
Exemple :
```
int length = "Java".length();
```
Expressions ternaires
Opérateur ternaire ?: permettant une forme concise de condition :
```
int max = (a > b) ? a : b;
```

2.2. Priorité et Associativité des Opérateurs

Les opérateurs ont une priorité qui détermine l’ordre d’évaluation.
Les opérateurs arithmétiques suivent la priorité classique :
() > * / % > + -
Les opérateurs logiques et relationnels ont leur propre priorité.
L’associativité définit dans quel sens les opérateurs sont évalués (généralement de gauche à droite).

3. Les Instructions en Java

3.1. Instructions de base

Instruction d’affectation
Assigne une valeur à une variable.
```
int x = 5;
x = x + 2;
```
Instruction d’expression
Une expression utilisée seule, par exemple un appel de méthode.
```
System.out.println("Bonjour");
```

Instruction conditionnelle (if / else)
Permet de choisir l’exécution selon une condition booléenne.

if (x > 0) {
    System.out.println("Positif");
} else {
    System.out.println("Négatif ou zéro");
}

Instruction de boucle
- for : boucle avec initialisation, condition, incrémentation.
- while : boucle conditionnelle.
- do-while : boucle exécutée au moins une fois.
Exemple for :
```
for (int i = 0; i < 10; i++) {
    System.out.println(i);
}
```
Instruction de saut
- break : sort d’une boucle ou d’un switch.
- continue : passe à l’itération suivante.
- return : termine une méthode et optionnellement retourne une valeur.

3.2. Instruction switch

Permet de gérer plusieurs cas selon la valeur d’une expression discrète (int, String, enum).

switch (day) {
    case "Lundi":
        System.out.println("Début de semaine");
        break;
    case "Vendredi":
        System.out.println("Fin de semaine");
        break;
    default:
        System.out.println("Jour ordinaire");
}

3.3. Blocs d’instructions

Un ensemble d’instructions peut être regroupé dans un bloc délimité par { ... }.
Cela permet de structurer le code et de définir des portées de variables.

4. Relations entre Instructions et Expressions

[Diagramme]

Une expression retourne une valeur, utilisée dans une instruction.
Une instruction peut être une expression complète ou un contrôle de flux.
Les blocs regroupent les instructions pour organiser le programme.

5. Exemples Concrets

Exemple 1 : Calcul de la moyenne

int a = 15, b = 20, c = 25;
int somme = a + b + c;             // Expression arithmétique dans une affectation
double moyenne = somme / 3.0;     // Division flottante
System.out.println("Moyenne : " + moyenne);

Exemple 2 : Condition avec expression ternaire

int age = 18;
String status = (age >= 18) ? "Adulte" : "Mineur";
System.out.println(status);

Exemple 3 : Boucle avec instruction d’expression

for (int i = 0; i < 5; i++) {
    System.out.println("i = " + i);
}

6. Bonnes Pratiques

Toujours terminer une instruction par un point-virgule ;.
Utiliser des expressions simples dans les conditions pour conserver la lisibilité.
Favoriser les blocs {} même pour une seule instruction dans une condition ou boucle.
Utiliser des noms de variables explicites pour les expressions.
Éviter les expressions trop complexes en les décomposant en plusieurs instructions.

7. Conclusion

Les instructions et les expressions sont au cœur du langage Java. Comprendre leur fonctionnement permet de construire des programmes robustes, lisibles et efficaces. Une instruction exécute une action tandis qu’une expression calcule une valeur. Leur combinaison judicieuse permet de contrôler le flux du programme et de manipuler les données.

Références

Oracle Java Tutorials – The Java™ Tutorials
Java Language Specification – https://docs.oracle.com/javase/specs/

Cette fiche vous aidera à mieux comprendre et utiliser les instructions et expressions en Java dans vos projets et exercices.

Instructions et expressions en Java