Conditions

1.4 Conditions

On appelle traitement conditionnel une portion de code qui n’est pas exécutée systématiquement.

1.4.1 Le bloc `if`

Principe

En pseudo-code un traitement conditionnel se rédige de la sorte :

Si la condition est vérifiée, alors les instructions sont exécutées, sinon, elles ne sont pas exécutées. L’exécution de l’algorithme se poursuit alors en ignorant les instructions se trouvant entre le alors et le finSi.

En java un traitement conditionnel se formule de la sorte :

if (<condition>) 
{
        <instructions>
}

Notez bien qu’il n’y a pas de point-virgule après la parenthèse du if.

Opérateurs de comparaison

La formulation d’une condition se fait souvent à l’aide des opérateurs de comparaison. Les opérateurs de comparaison disponibles sont :

== : égalité
!= : non-égalité
<, <= : inférieur à, respectivement strict et large
>, >= : supérieur à, respectivement strict et large

Par exemple, la condition a == b est vérifiée si et seulement si a et b ont la même valeur au moment où le test est évalué. Par exemple,

System.out.println("Saisissez une valeur");
int i = scanner.nextInt();
if (i == 0)
{
        System.out.println("Vous avez saisi une valeur nulle.");
}
System.out.println("Au revoir !");

Si au moment où le test i == 0 est évalué, la valeur de i est bien 0, alors le test sera vérifié et l’instruction System.out.println("Vous avez saisi une valeur nulle."); sera bien exécutée. Si le test n’est pas vérifié, les instructions du bloc sous la portée du if sont ignorées.

1.4.2 Si ... Alors ... Sinon

Il existe une forme étendue de traitement conditionnel, on la note en pseudo-code de la façon suivante :

Les instructions délimitées par alors et sinon sont exécutées si le test est vérifié, et les instructions délimitées par sinon et finSi sont exécutées si le test n’est pas vérifié. On traduit le traitement conditionnel étendu de la sorte :

En java un traitement conditionnel étendu se formule de la sorte :

if (<condition>)
{
        <instructions1>;
}
else
{
        <instructions2>;
}

Par exemple,

System.out.println("Saisissez une valeur");
int i = scanner.nextInt();
if (i == 0)
{
        System.out.println("Vous avez saisi une valeur nulle.");
}
else
{
        System.out.println("La valeur que vous avez saisi, " + i +
                               ", n'est pas nulle.");
}

Notez la présence de l’opérateur de comparaison ==. Si vous utilisez = pour comparer deux valeurs, ça ne compilera pas !

Connecteurs logiques

On formule des conditions davantage élaborées en utilisant des connecteurs et et ou. La condition A et B est vérifiée si les deux conditions A et B sont vérifiées simultanément. La condition A ou B est vérifiée si au moins une des deux conditions A et B est vérifiée. Le et s’écrit && et le ou s’écrit ||. Par exemple, voici un programme C qui nous donne le signe de i × j sans les multiplier.

System.out.println("Saisissez deux valeurs numériques : ");
float i = scanner.nextFloat();
float j = scanner.nextFloat();
System.out.print("Le produit de " + i + " par " + j + " est ");
if ((i >= 0 && j >= 0) || (i < 0 && j < 0))
{
        System.out.println("positif.");
}
else
{
        System.out.println("négatif.");
}

Accolades superflues

Lorsqu’une seule instruction d’un bloc if doit être exécutée, les accolades ne sont plus nécessaires. Il est possible par exemple de reformuler le programme précédent de la sorte :

System.out.println("Saisissez deux valeurs numériques : ");
float i = scanner.nextFloat();
float j = scanner.nextFloat();
System.out.print("Le produit de " + i + " et " + j + " est ");
if ((i >= 0 && j >= 0) || (i < 0 && j < 0))
       System.out.println("positif.");
else
       System.out.println("négatif.");

Blocs

Un bloc est un ensemble d’instructions délimité par des accolades.

Par exemple le bloc public static void main(String[] args), ou encore le bloc if.

Vous aurez remarqué qu’il est possible d’imbriquer les blocs et qu’il convient d’ajouter un niveau d’indentation supplémentaire à chaque fois qu’un nouveau bloc est ouvert.

Une des conséquences de la structure de blocs du langage Java s’observe dans l’exemple suivant :

Achtung !

int i =  4;
if (i == 4)
{
        int j = i + 1;
}
System.out.println("j = " + j + ".");

Vous aurez remarqué la variable j est déclarée à l’intérieur du bloc if, et utilisé à l’extérieur de ce bloc. Ce code ne compilera pas parce que une variable n’est utilisable qu’à l’intérieur du bloc où elle a été déclarée. La portée (ou encore la visibilité) de la variable j se limite donc à ce bloc if.

Opérateur ternaire

En plaçant l’instruction suivante à droite d’une affectation,

<variable> = (<condition>) ? <valeur1> : <valeur2> ;

on place valeur dans variable si condition est vérifié, autrevaleur sinon. Par exemple,

max = (i>j) ? i : j ;

place la plus grande des deux valeurs i et j dans max. Plus généralement on peut utiliser le si ternaire dans n’importe quel calcul, par exemple

int i = 4;
int j = 2;
int k = 7;
int l;
System.out.println((i> (l = (j>k) ? j : k)) ? i : l);

j = (j>k) ? j : k) place dans l la plus grande des valeurs j et k, donc
(i > (l = (j > k) ? j : k)) ? i : l est la plus grande des valeurs i, j et k. La plus grande de ces trois valeurs est donc affichée par cette instruction.

1.4.3 Switch

Le switch est une instruction permettant sélectionner un cas selon la valeur d’une variable. La syntaxe est la suivante :

switch(<nomvariable>)
{
  case <valeur_1> : <instructions_1> ; break ;
  case <valeur_2> : <instructions_2> ; break ;
  /* ... */
  case <valeur_n> : <instructions_n> ; break ;
  default :  <instructionspardefaut>  ; break;
}

Si nomvariable contient la valeur valeur_i, alors les instructions_i sont exécutées. Si aucune des valeurs énumérées ne correspond à celle de nomvariable, ce sont les instructionspardefaut qui sont exécutées. Les break servent à fermer chaque cas, y compris le dernier ! Si par exemple, nous voulons afficher le nom d’un mois en fonction de son numéro, on écrit :

switch(numeroMois)
{
  case 1 : System.out.print("janvier") ; break ;
  case 2 : System.out.print("fevrier") ; break ;
  case 3 : System.out.print("mars") ; break ;
  case 4 : System.out.print("avril") ; break ;
  case 5 : System.out.print("mai") ; break ;
  case 6 : System.out.print("juin") ; break ;
  case 7 : System.out.print("juillet") ; break ;
  case 8 : System.out.print("aout") ; break ;
  case 9 : System.out.print("septembre") ; break ;
  case 10 : System.out.print("octobre") ; break ;
  case 11 : System.out.print("novembre") ; break ;
  case 12 : System.out.print("decembre") ; break ;
  default : System.out.print("Je connais pas ce mois...");break;
}

1.4.4 Booléens

Une variable booléenne ne peut prendre que deux valeurs : vrai et faux.

Le type booléen en Java est boolean et une variable de ce type peut prendre soit la valeur true, soit la valeur false.

Utilisation dans des `if`

Lorsqu’une condition est évaluée, par exemple lors d’un test, cette condition prend à ce moment la valeur vrai si le test est vérifié, faux dans le cas contraire. Il est donc possible de placer une variable booléenne dans un if. Observons le test suivant :

System.out.println("Saisissez un booléen : ");
boolean b = scanner.nextBoolean();
if (b)
        System.out.println("b is true.");
else
        System.out.println("b is false.");

Si b contient la valeur true, alors le test est réussi, sinon le else est exécuté. On retiendra donc qu’il est possible de placer dans un if toute expression pouvant prendre les valeurs true ou false.

Tests et affectations

Un test peut être effectué en dehors d’un if, par exemple de la façon suivante :

boolean x = (3>2);

Un test peut être effectué en dehors d’un if, par exemple de la façon suivante : On remarque que (3>2) est une condition. Pour décider quelle valeur doit être affectée à x, cette condition est évaluée. Comme dans l’exemple ci-dessus la condition est vérifiée, alors elle prend la valeur true, et cette valeur est affectée à x.

Connecteurs logiques binaires

Les connecteurs || et && peuvent s’appliquer à des valeurs (ou variables) booléennes. Observons l’exemple suivant :

boolean x = (true && false) || (true);

Il s’agit de l’affectation à x de l’évaluation de la condition (true && false) || (true). Comme (true && false) a pour valeur false, la condition false || true est ensuite évaluée et prend la valeur true. Donc la valeur true est affectée à x.

Opérateur de négation

Parmi les connecteurs logiques se trouve !, dit opérateur de négation. La négation d’une expression est vraie si l’expression est fausse, fausse si l’expression est vraie. Par exemple,

boolean x = !(3==2);

Comme 3 == 2 est faux, alors sa négation !(3 == 2) est vraie. Donc la valeur true est affectée à x.

1.4.5 Les priorités

Complétons notre tableau des priorités en y adjoignant les connecteurs logiques et les opérateurs de comparaison :

noms	opérateurs
opérateurs unaires	`cast`, `-`, `~`, `!`, `++`, `--`
produit	`*`, `/`, `%`
somme	`+`, `-`
décalage binaire	`>>`, `<<`
comparaison	`>`, `<`, `>=`, `<=`
égalité	`==`, `!=`
ET binaire	`&`
OU Exlusif binaire	`^`
OU binaire	`\|`
connecteurs logiques	`&&`, `\|\|`
if ternaire	`()?:`
affectations	`=`, `+=`, `-=`, …