Il existe deux types d'instructions de contrôle en Java. Elles sont:

• If
• Switch

If

Une instruction if consiste en une expression booléenne suivie d'une ou plusieurs instructions.

Syntaxe:

La syntaxe d’une instruction if est:

if(Boolean_expression)
{
   // Les instructions s'exécutent si l'expression booléenne est vraie
}

Si l'expression booléenne est évaluée comme étant vraie, le bloc de code à l’intérieur de l’instruction if sera exécuté. Sinon, le premier ensemble de code après la fin de l’instruction if (après l'accolade fermée) sera exécuté.

Exemple:

public class Test {
   public static void main(String args[]){
      int x = 10;
      if( x < 20 ){
         System.out.print("This is if statement");
      }
   }
}

Cela produirait le résultat suivant:

This is if statement

If ... else

Une instruction if peut être suivie d'une instruction optionnelle, qui s'exécute lorsque l'expression booléenne est fausse.

Syntaxe:

La syntaxe d’un if ... else est:

if(Boolean_expression){
   // Exécute lorsque l'expression booléenne est vraie
}else{
   // Exécute lorsque l'expression booléenne est fausse
}

Exemple:

public class Test {
   public static void main(String args[]){
      int x = 30;
      if( x < 20 ){
         System.out.print("This is if statement");
      }else{
         System.out.print("This is else statement");
      }
   }
}

 Cela produirait le résultat suivant:

This is else statement

If...else if...else

Une instruction if peut être suivie d'une instruction facultative if ...else, ce qui est très utile pour tester diverses conditions à l'aide de l'instruction if…else if…else.

Lorsque vous utilisez if, else if, else, il y a peu de points à garder à l'esprit.

• Un if peut avoir zéro ou un else et il doit venir après else if.
• Un if peut avoir zéro et else if et ils doivent venir avant else.
• Une fois que else réussis, aucun des else if ou if else sera testé.

Syntaxe:

La syntaxe d’un if ... else est:

if(Boolean_expression 1){
   // Exécute lorsque l'expression booléenne 1 est vraie
}else if(Boolean_expression 2){
   // Exécute lorsque l'expression booléenne 2 est vraie
}else if(Boolean_expression 3){
   // Exécute lorsque l'expression booléenne 3 est vraie
}else {
   // Exécute lorsque la condition de la condition ci-dessus est vraie.
}

Exemple:

public class Test {
   public static void main(String args[]){
      int x = 30;
      if( x == 10 ){
         System.out.print("Value of X is 10");
      }else if( x == 20 ){
         System.out.print("Value of X is 20");
      }else if( x == 30 ){
         System.out.print("Value of X is 30");
      }else{
         System.out.print("This is else statement");
      }
   }
}

Cela produirait le résultat suivant:

Value of X is 30

If…else imbriqué

Il est toujours légal d’imbriqué les déclarations if…else, ce qui signifie que vous pouvez utiliser une instruction if ou else if dans une autre instruction if ou else if.

Syntaxe:

La syntaxe pour un If…else imbriqué est la suivante:

if(Boolean_expression 1){
   // Exécute lorsque l'expression booléenne 1 est vraie
   if(Boolean_expression 2){
      //Exécute lorsque l'expression booléenne 2 est vraie
   }
}

Vous pouvez d’imbriquer else if…else de la même manière que l'énonciation if.

Exemple:

public class Test {
   public static void main(String args[]){
      int x = 30;
      int y = 10;
      if( x == 30 ){
         if( y == 10 ){
             System.out.print("X = 30 and Y = 10");
          }
       }
    }
}

Cela produirait le résultat suivant:

X = 30 and Y = 10

Switch

Une instruction de commutation permet à une variable d'être testée pour l'égalité avec une liste de valeurs. Chaque valeur est appelée cas, et la variable activée est vérifiée pour chaque cas.

Syntaxe:

La syntaxe pour l’insctruction switch est la suivante :

switch(expression){
    case value :
       // Déclarations
       break; // optionnel
    case value :
       // Déclarations
       break; // optionnel
    // Vous pouvez avoir un certain nombre d'énoncés de cas.
    default : // optionnel
       // Déclarations
}

Les règles suivantes s'appliquent à une déclaration switch:

• La variable utilisée dans une instruction de commutation ne peut être qu'un byte, un short, un int ou un char.
• Vous pouvez avoir un certain nombre de cas dans un switch. Chaque cas est suivi de la valeur à comparer et de deux points.
• La valeur d'un cas doit être du même type de données que la variable de contrôle dans le switch et doit être une constante ou un littéral.
• Lorsque la variable de  contrôle  est égale à un cas, les instructions suivent à ce cas seront exécutées jusqu'à ce qu'une déclaration break soit atteinte.
• Lorsqu'une déclaration break est atteinte, l’instruction switch se termine et le flux de contrôle passe à la ligne suivante après l'instruction switch.
• Tous les cas ne doivent pas contenir de break. Si aucune break ne s'affiche, le flux de contrôle tombera dans les cas subséquents jusqu'à ce qu'un break soit atteinte.
• Une instruction switch peut avoir un cas optionnel par défaut, qui doit apparaître à la fin du switch. Le cas par défaut peut être utilisé pour effectuer une tâche lorsqu’aucun des cas n'est vrai. Aucun break n'est nécessaire dans le cas par défaut.

Exemple:

public class Test {
   public static void main(String args[]){
      //char grade = args[0].charAt(0);
      char grade = 'C';
      switch(grade)
      {
         case 'A' :
            System.out.println("Excellent!");
            break;
         case 'B' :
         case 'C' :
            System.out.println("Well done");
            break;
         case 'D' :
            System.out.println("You passed");
         case 'F' :
            System.out.println("Better try again");
            break;
         default :
            System.out.println("Invalid grade");
      }
      System.out.println("Your grade is " + grade);
   }
}

Compilez et exécutez le programme ci-dessus en utilisant différents arguments de ligne de commande. Cela produirait le résultat suivant:

java Test

Well done

Your grade is a C

• ← Les boucles
• Sommaire du cours
• Classe des nombres →