Dans les langages de programmation (et dans JAVA), la notions l'expression est très importante car elle introduit ce qu'on appelle l'évaluation d'expression

Cette évaluation s'opère généralement lors d'une affectation ou d'un test de condition. Prenons un exemple très simple :

int nombre = 3;

Dans cette instruction , nous initialisons la variable nombre en lui affectant le résultat de l'évaluation 3. De fait le résultat de l'évaluation est la valeur 3.

Cette évaluation prend plus de sens quand commence à intervenir les opérateurs :

int nombre = 3+2;
// évaluation de 3+2 => 5, nombre vaut 5

La chose à bien retenir c'est que l'expression est évaluée, et c'est le résultat qui est affecté, la preuve :

int a = 3;
int b = 2;
int calcule = a + b;
// a est évalué => 3
// b est évalué => 2
// a + b est évalué => 5
System.out.println(calcule); // 5

// Si nous modifions a, la valeur de 
// calcule ne change pas
a = 0;
System.out.println(calcule); // 5

La plus par du temps, les expressions reposent sur l'utilisation des opérateurs qui sont regroupés en différentes catégories :

• Les opérateurs arithmétiques
• Les opérateurs logiques
• Les opérateurs d'affectation
• Les "Non-classés"

Ces opérateurs vont permettre de faire des calcules mathématiques.

Petit exemple de modulo :

int reste = 7 % 2; // (7/2 = 3, reste 1)
System.out.println(reste); // affiche 1

L'ordre des calcules est le même que dans l’algèbre traditionnel.

• D'abord sont résolu les Divisions, multiplication et modulo
• Puis les additions et les soustractions

Si tous les opérateurs sont du même niveau, le calcule est fait de gauche à droite :

5 + 7 - 2; // Dans l'ordre 12;
3 * 2 * 10 / 6; // Dans l'ordre, 10 

5 + 10 * 10; // ( + (10*10) = 105
1 - 1 * 2 * 5 / 10; // 1 - (1 * 2 * 5 / 10) = 0

Pour modifier l'ordre des priorités, vous pouvez utiliser les parenthèses :

5 * (2 + 3); // 25;

Vous obtenir l’opposé d'un nombre vous pouvez utiliser les signes - / +, ils ont la priorité absolue !

-5 * -(4*5/2); // (-5) * (-(4*5/2))

Dans le langage de tous les jours nous pouvons entendre ce genre de conversations :

 - Tu es passé chercher la commandes ?
 - Je suis encore au bureau

A une question qui attend une valeur booléenne, l'interlocuteur donne une information de lieu. Naturellement, vous évaluons la réponse comme un non.

Le système d'évaluation des expressions en Java dispose d'une mécanique un peu similaire ou il va évaluer les composantes d'un expression pour la résoudre, voyons ce code :

int a = 3;
int b = 2;

double division = a / b; // On s'attend à 1.5, c'est 1

En effet, l'évaluation de l'expression a / b ne tiens pas compte du type de la variable division. Donc lors de l'évaluation de a / b, interpréteur est en présence de 2 variables de type int, donc il évaluera l'expression comme un int au prix d'un arrondi !

Dans le même esprit (c'est vicieux) :

int a = 3;
int b = 2;
double c = 2.5;

double cal = (a / b) + c; // On s'attend à 4, c'est 3.5 !

Même cas que précédemment, Java commence par évaluer a / b en tant que int, ce qui donne 1, puis il additionne 1 + 2.5.

Enfin :

int a = 3;
int b = 2;
double c = 1.25;

double cal = (c * b) + a; // c'est bien 5.5

Dans ce cas l'évaluation de c * b inclue une variable de type int et une de type double, le résultat est évalué comme un double, puis il fait d'addition.

Les opérateurs relationnels permettent de comparer des expressions. Le résultat de la comparaison est retourné sous la forme d'une valeur booléenne (boolean) :

boolean test = 5 > 4; // true
System.out.println("5 supérieur à 4 ? : " +test);

Voici la liste des opérateurs :

Les opérateurs relationnels entre en compte dans la priorité des opérateurs, cette priorité est inférieur aux opérateurs arithmétique. De fait :

boolean test = 4 * 2 == 16 / 2;

boolean test = (4 * 2) == (16 / 2);

int cal;
if( cal = 5 )
  {
  System.out.println("VRAI");
  }

Comme pour les opérateurs relationnels, l'évaluation d'une expression contenant des opérateurs logiques retourne un Booléen.

Il retourne l'inverse de l'évaluation de l'expression qui suit.

boolean test = false;
System.out.println("Inverse de test : " + !test);

Est évaluée comme vrai si une des 2 conditions est vrai :

int a=2, b=3, c=4, d=5;
if( a > b | c < d )
  System.out.println('VRAI');
  
if( a > b || c < d )
  System.out.println('VRAI');

Il existe une nuance entre ces 2 opérateurs, dans le ||, si la première condition est vrai, la deuxième ne sera pas évaluée :

int i = 0;
if( true | i++ > 0 )
  System.out.println('VRAI');

System.out.println(i); // 1 (le i++ a été exécuté)

  
if( true || i++ > 0 )
  System.out.println('VRAI');

System.out.println(i); // 1 (le i++ n'a pas été éxécuté)

Même principe, mais cette fois les 2 conditions doivent être vrai. La version court-circuit avec && n'évaluera pas l'opérande de droite si celle de gauche est fausse.

Retourne VRAI si une seule des 1 conditions est vrai

Il est possible d'affecter plusieurs variables en une seule opération :

int a, b, c;
a = b = c = 10;

les opérateurs ++ et – permettent d'incrémenter ou décrémenter de 1 une variable : Si cet opérateur est placé avant, l'incrémentation a lieu avant évaluation, sinon après :

int num = 5;
int cal = ++num - 5;
// D'abord num est incrémenté : num = 6
// Puis l'expression est évalué : 6 - 5
// num = 6 et cal = 1

// ALORS QUE
int num = 5;
int cal = num++ - 5;
// L'expression est évalué : 5 - 5
// Puis num est incrémenté : num +1
// num = 6 et cal = 0

Ces opérateurs sont des raccourcis à utilisé quand on a une bonne pratique, ils permettent de réaliser une affectation est un calcule en même temps :

int a = 1;

// Au lieu de
a = a + 20;

// On écrit
a += 20;

Ce système fonctionne avec tous les opérateurs arithmétiques : -=, +=, /=, *=, %=.

Autre opérateur raccourcis, il permet de conditionner l'affection par un test, voici sa forme :

exemple = condition ? valeur si vrai : valeur si faux;

int a = 5;
int b = 6;
int lePlusGrand = (a > b)a:b;