Java >> Tutoriel Java >  >> Tag >> switch

Instruction de commutation en Java expliquée avec des exemples

À l'aide d'exemples, vous apprendrez à utiliser l'instruction switch en Java pour réguler le flux d'exécution de votre programme. L'instruction switch nous permet de choisir plusieurs manières différentes d'exécuter un bloc de code. L'instruction switch en Java a la syntaxe suivante :

Instruction de commutation en Java

switch (expression) {

  case one:
    // code
    break;
  
  case two:
    // code
    break;
  
  ...
  ...
  
  default:
    // run default statements here
  }

Quel est le but de l'instruction switch-case ?

L'expression est évaluée une fois et les valeurs de chaque cas sont comparées. Si l'expression correspond à un, le code de cas un est déclenché. De même, si l'expression correspond à deux, le code du cas deux est lancé. Si aucune correspondance n'est trouvée, le code du cas par défaut est exécuté.

L'instruction switch-case fonctionne de la même manière que Java if…else…if. La syntaxe de l'instruction switch, en revanche, est beaucoup plus propre et plus facile à lire et à écrire.

Exemple :instruction switch de Java

// Program for checking  the length  using the switch...case statement

class CodeMain {
  public static void main(String[] args) {

    int numVar = 50;
    String scoreVar;

    // switch statement for checking the size
    switch (numVar) {

      case 80:
        scoreVar = "Excellent";
        break;

      case 70:
        scoreVar = "Good";
        break;

      // match the value of week
      case 60:
        scoreVar = "Above Average";
        break;

      case 50:
        scoreVar = "Average";
        break;
      
      default:
        scoreVar = "Indefinite";
        break;

    }
    System.out.println("Your score is: " + scoreVar);
  }
}

Pour trouver le scoreVar, nous avons utilisé l'instruction switch dans l'exemple précédent. Nous avons un nombre variable ici. La valeur de chaque instruction case est comparée à la variable. Le code du cas 50 est exécuté puisque la valeur correspond à 50.

Instruction break dans le cas switch… de Java

Vous remarquerez que nous avons utilisé une pause dans chaque bloc de cas. Par exemple,

case 50:
  scoreVar = "Average";
  break;

L'instruction switch-case se termine par l'instruction break. Si aucune pause n'est donnée, tous les cas après le cas correspondant sont également exécutés. Par exemple,

class CodeMain {

  public static void main(String[] args) {

    int expValue = 3;

    // switch statement for checking the weight
    switch (expValue) {
      case 1:
        System.out.println("1st Case ");

        // matching case
      case 2:
        System.out.println("2nd Case ");

      case 3:
        System.out.println("3rd Case");
	
     case 4:
        System.out.println("4th Case");

      default:
        System.out.println("Default case");
    }
  }
}

Dans l'exemple précédent, expValue correspond à la situation 3. De plus, après chaque instance, nous n'avons pas utilisé l'instruction break. Par conséquent, tous les cas après le cas 3 sont également exécutés. C'est pourquoi, suivant la casse correspondante, l'instruction switch-case doit se terminer par une instruction break.

Cas par défaut de Java switch-case

Un cas par défaut est également inclus dans l'instruction switch en tant qu'option. Il est exécuté lorsque l'expression ne correspond à aucun des cas. Par exemple,

class CodeMain {

  public static void main(String[] args) {
  
    int expVal = 10;
    
    switch(expVal) {
        
      case 1:
        System.out.println("Excellent");
        break;

      case 2:
        System.out.println("Good");
        break;
	
      case 3:
        System.out.println("Average");
        break;
            
      // default case
      default:
        System.out.println("out of scope");
    }
  }
}

Une instruction switch-case est produite dans l'exemple précédent. La valeur de l'expression, dans ce cas, ne correspond à aucun des cas. En conséquence, le code du cas par défaut est exécuté.

default:
        System.out.println("out of scope");

Exemple :un boîtier de commutation simple

public class CodeSwitchCase{

   public static void main(String args[]){
     int numVar=10;

     switch(numVar+5)
     {
        case 1:
	  System.out.println("1st Case: Value is: "+numVar);
	case 2:
	  System.out.println("2nd Case: Value is: "+numVar);
	case 3:
	  System.out.println("3rd Case: Value is: "+numVar);
        default:
	  System.out.println("The Default: Value is: "+numVar);
      }
   }
}

Nous avons utilisé une expression dans le commutateur, mais vous pouvez également utiliser une variable. De plus, nous avons donné l'équation numVar+5, où numVar est 10, et le résultat après addition est 15. Comme aucun cas avec la valeur 15 n'a été défini, le cas par défaut est utilisé. C'est pourquoi, dans le scénario de basculement, nous devons utiliser la valeur par défaut afin que si aucun catch ne remplisse la condition, le bloc par défaut est exécuté.

Exemple :Switch-Case sans interruption

public class CodeSwitchCase {

   public static void main(String args[]){
      int numVar=5;
      switch(numVar)
      {
	 case 1:
	   System.out.println("1st Case ");
	 case 2:
	   System.out.println("2nd Case ");
	 case 3:
	   System.out.println("3rd Case ");
	 case 4:
           System.out.println("4th Case ");
	case 5:
           System.out.println("5th Case ");
          case 6:
           System.out.println("6th Case ");
          case 7:
           System.out.println("7th Case ");
	 default:
	   System.out.println("No such definition in our cases ");
      }
   }
}

Bien que l'instruction break ne soit pas requise dans les cas de commutation, vous l'utiliserez toujours. L'exemple ci-dessus est un scénario dans lequel nous n'utilisons pas l'instruction break.

Nous avons donné la valeur entière 5 au commutateur dans le programme ci-dessus, ce qui a entraîné le passage du contrôle au cas 5, mais nous n'avions pas d'instruction break après le cas 5, ce qui a entraîné le transfert du flux vers les cas suivants jusqu'à la fin. L'instruction break est la solution à cette situation.

Vous utilisez des instructions break lorsque vous souhaitez que votre flux de programme quitte le corps du commutateur. Le flux d'exécution est contourné lorsqu'une instruction break est découverte dans le corps du commutateur. Par la suite, les autres instances sont ignorées.

Exemple :Switch-Case avec pause

Utilisons le même exemple mais avec une instruction break cette fois.

public class CodeSwitchCaseWithBreak {

   public static void main(String args[]){
      int numVar=5;
      switch(i)
      {
	  case 1:
	   System.out.println("1st Case ");
	break;
	 case 2:
	   System.out.println("2nd Case ");
	break;
	 case 3:
	   System.out.println("3rd Case ");
	break;
	 case 4:
           System.out.println("4th Case ");
	break;
	case 5:
           System.out.println("5th Case ");
	break;
          case 6:
           System.out.println("6th Case ");
	break;
          case 7:
           System.out.println("7th Case ");
	break;
	 default:
	   System.out.println("No such definition in our cases ");
      }
   }
}

Comme vous pouvez le voir, seul le cas 5 a été exécuté, tandis que les autres cas ont été ignorés. Après défaut, pourquoi n'avons-nous pas utilisé l'instruction break ? Après défaut, le contrôle sortait du commutateur, nous ne l'avons donc pas utilisé; cependant, si vous souhaitez toujours utiliser la pause après le défaut, continuez ; il n'y a aucun dommage.

Exemple :Utilisation de caractères en cas de changement

public class CodeSwitchCase {

   public static void main(String args[]){
      char charVar='z';
      switch(charVar)
      {
	 case 'a':
	   System.out.println("1st Case ");
	   break;
	 case 'b':
	   System.out.println("2nd Case ");
	   break;
	 case 'c':
	   System.out.println("3rd Case ");
	   break;
	 case 'd':
           System.out.println("4th Case ");
           break;
	 default:
	   System.out.println("Default ");
      }
   }
}

Exemple :Changer la casse des variables de mois

//Program for demonstrating the Switch statement by printing the month's name for the given number  

public class CodeSwitchMonth {    

  public static void main(String[] args) {    

    //indicate the current month's number  
    int monthVar=5;  

    String resultVar="";  

    //Switch statement  
    switch(monthVar){    

        //case statements within the switch block  

      case 1: resultVar="1 - January";  
        break;    
      case 2: resultVar="2 - February";  
        break;    
      case 3: resultVar="3 - March";  
        break;    
      case 4: resultVar="4 - April";  
        break;    
      case 5: resultVar="5 - May";  
        break;    
      case 6: resultVar="6 - June";  
        break;    
      case 7: resultVar="7 - July";  
        break;    
      case 8: resultVar="8 - August";  
        break;    
      case 9: resultVar="9 - September";  
        break;    
      case 10: resultVar="10 - October";  
        break;    
      case 11: resultVar="11 - November";  
        break;    
      case 12: resultVar="12 - December";  
        break;    
      default:System.out.println("This is not a valid Month!");    
    }    
    //Printing  the given numbers' month
    System.out.println(resultVar);  
  }    
}   

Conclusion

Nous utilisons l'instruction switch case lorsque nous avons plusieurs possibilités (ou choix), et nous pouvons avoir besoin de mener une action différente pour chaque choix. De plus, même si elle est facultative, l'instruction Switch Case est fréquemment utilisée avec l'instruction break. Ainsi, globalement, il est possible d'avoir un switch case sans break et un switch case avec break, comme nous l'avons vu dans les exemples.

Les ordres 1, 2, 3, etc. ne sont pas nécessairement requis dans un cas. Après le mot-clé case, il peut avoir n'importe quelle valeur entière. De plus, le cas ne doit pas toujours être spécifié dans l'ordre croissant, selon l'exigence, et vous pouvez les fournir dans n'importe quel ordre. De plus, si l'expression donnée à l'intérieur du commutateur n'aboutit pas à une valeur constante, elle n'est pas valide. Les instructions switch peuvent être imbriquées, ce qui signifie que vous pouvez placer une instruction switch dans une autre. D'autre part, les instructions switch imbriquées sont évitées car elles rendent le programme plus complexe et difficile à lire.


Balise Java