Java

Les structures conditionnelles en Java

Les structures conditionnelles ont une ou plusieurs conditions à évaluer ou à tester par le programme, ainsi qu'une instruction ou des instructions à exécuter si la condition est considérée comme vraie et, éventuellement, d'autres instructions à exécuter si la condition est fausse.

Le langage de programmation Java fournit les structures conditionnelles suivantes :

  •  if
  •  if-else
  •  if imbriquée
  •  switch

Structure conditionnelle if

La syntaxe de l'instruction if est la suivante:

                                if( condition ){
                                    // corps
                                    //instructions à exécuter si la condition est true
                                }
                            

Comment fonctionne?

L'instruction if évalue la condition à l'intérieur de la parenthèse().

  • Si la condition est évaluée à true, les instructions à l'intérieur du corps de if sont exécutées.
  • Si la condition est évaluée à false, les déclarations à l'intérieur du corps de if ne sont pas exécutées.
Exemple 1 :
                                public class Test{

                                    public static void main(String args[]){
                                        a=-3;
                                        // structure conditionnelle
                                        if(a< 0){
                                            System.out.println("la valeur de a est négative ");
                                        }

                                        // fin du programme
                                        System.out.println("Good bye !");
                                    }
                                }
                            
la valeur de a est négative
Good bye !

Pour en savoir plus sur le moment où l'expression test est évaluée à true (valeur non nulle) et false (0), voir les opérateurs relationnels et logiques.

Structure conditionnelle if-else

L'instruction if peut avoir un bloc else optionnel. La syntaxe de l'instruction if..else est la suivante:

                                if( condition ){
                                    // corps
                                    //instructions à exécuter si la condition est true
                                }
                                else{
                                    //corps
                                    // instructions à exécuter si condition est false
                                }
                            

Comment fonctionne?

Si la condition est évaluée à true,

  • les instructions à l'intérieur du corps de if sont exécutées.
  • les instructions à l'intérieur du corps de else sont exclues de l'exécution.

Si la condition est évaluée à false,

  • les instructions à l'intérieur du corps de else sont exécutées.
  • les instructions à l'intérieur du corps de if sont exclues de l'exécution.
Exemple 2 :
                                public class Test{

                                    public static void main(String args[]){
                                        a=3;
                                        // structure conditionnelle
                                        if(a< 0){
                                            System.out.println("la valeur de a est négative ");
                                        }
                                        else{
                                            System.out.println("la valeur de a est positive ou nulle ");
                                        }

                                        // fin du programme
                                        System.out.println("Good bye !");
                                    }
                                }
                            
la valeur de a est positive ou nulle
Good bye !

Structure conditionnelle if-else if-else

L'instruction if ... else exécute deux codes différents selon que la condition est true ou false. Parfois, un choix doit être fait parmi plus de 2 possibilités.
if-else if-else vous permet de vérifier plusieurs conditions et d'exécuter différentes instructions.

                                if( condition1 ){
                                    // corps
                                    //instructions à exécuter si la condition 1 est true
                                }
                                else if(condition2){
                                    //corps
                                    // instructions à exécuter si condition 2 est true
                                    // condition 1 est false
                                }
                                else if(condition3){
                                    //corps
                                    // instructions à exécuter si condition 2 est true
                                    // condition 1, condition 2 est false
                                }
                                ...
                                else{
                                    //corps
                                    // instructions à exécuter si toutes les conditions est false
                                }
                            
Exemple 3 :
                                public class Test{
                                    public static void main(String args[]){
                                        a=3;
                                        // structure conditionnelle
                                        if(a < 0){
                                            System.out.println("la valeur de a est négative ");
                                        }
                                        else if( a > 0){
                                            System.out.println("la valeur de a est positive ");
                                        }
                                        else{
                                            System.out.println("la valeur de a est  nulle ");
                                        }

                                        // fin du programme
                                        System.out.println("Good bye !");
                                    }
                                }
                            
la valeur de a est positive
Good bye !

Structure conditionnelle if imbriquée

Il est possible d'inclure une instruction if ... else dans le corps d'une autre instruction if ... else.

Exemple 4 :
                                public class Test{
                                    public static void main(String args[]){
                                        a=-2;
                                        // structure conditionnelle
                                        if(a <= 0){
                                            if(a==0){
                                                System.out.println("la valeur de a est  nulle ");
                                            }
                                            else{
                                                System.out.println("la valeur de a est négative ");
                                            }
                                            
                                        }
                                        else{
                                            System.out.println("la valeur de a est positive ");
                                        }

                                        // fin du programme
                                        System.out.println("Good bye !");
                                    }
                                }
                            
la valeur de a est négative
Good bye !
Remarque ! Si le corps d'une instruction if ... else comporte une seule instruction, vous n'avez pas besoin d'utiliser des crochets {}.
Exemple 5 :
                                if(a <= 0){
                                    System.out.println("la valeur de a est négative ou nulle");
                                }
                                else{
                                    System.out.println("la valeur de a est positive ");
                                }
                            

est équivalent à

Exemple 6 :
                                if(a <= 0)
                                    System.out.println("la valeur de a est négative ou nulle");
                                else
                                    System.out.println("la valeur de a est positive ");
                            

Structure conditionnelle switch

L'instruction switch est une instruction multidirectionnelle utilisée pour gérer les décisions. Cela fonctionne presque exactement comme la déclaration if-else. La différence est que l'instruction switch génère un code plus lisible par rapport à l'instruction if-else. De plus, il s'exécute parfois plus rapidement que son homologue if-else.

Syntaxe
                                switch(expression)
                                {
                                    case val1:
                                        // instructions
                                        break; // optionnelle
                                    case val2:
                                        // instructions
                                        break; // optionnelle
                                    case val3:
                                        // instructions
                                        break; // optionnelle
                                    default:
                                        // instructions
                                }
                            

Les règles suivantes s'appliquent à une instruction switch

  • La variable utilisée dans une instruction switch ( ou expression) ne peut être que des nombres entiers, des nombres entiers convertibles (byte, short, char), des chaînes et des enums.
  • Vous pouvez avoir n'importe quel nombre de déclarations de case dans un switch. Chaque case est suivi de la valeur à comparer et de deux points.
  • La valeur d'une case doit être du même type de données que la variable( ou expression) dans le switch et il doit s'agir d'une constante ou d'un littéral.
  • Lorsque la variable est égale à un cas, les instructions qui suivent ce cas seront exécutées jusqu'à ce qu'une instruction break soit atteinte.
  • Lorsqu'une instruction break est atteinte, switch se termine et le flux de contrôle passe à la ligne suivante qui suit l'instruction switch.
  • Tous les cas ne doivent pas nécessairement contenir break. Si aucune break n'apparaît, le flux de contrôle se répercutera sur les cas suivants jusqu'à ce qu'une break soit atteinte.
  • Une instruction switch peut avoir un cas par défaut facultatif, qui doit apparaître à la fin de switch. Le cas par défaut peut être utilisé pour effectuer une tâche lorsqu'aucun des cas n'est vrai. Aucune break n'est nécessaire dans le cas par défaut.
Exemple 7

voici un programme qui à partir d’un nombre compris entre 1 et 7 affiche le jour correspondant

                                public class Test{
                                    public static void main(String args[]){
                                        int jour=3;

                                        switch(jour){
                                            case 1 : {
                                                    System.out.println("Lundi"); break;
                                                }
                                            case 2 : {
                                                    System.out.println("Mardi"); break;
                                                }
                                            case 3 : {
                                                    System.out.println("Mercredi"); break;
                                                }
                                            case 4 : {
                                                    System.out.println("Jeudi"); break;
                                                }
                                            case 5 : {
                                                    System.out.println("Vendredi"); break;
                                                }
                                            case 6 : {
                                                    System.out.println("Samedi"); break;
                                                }
                                            case 7 : {
                                                    System.out.println("dimanche"); break;
                                                }
                                            default: System.out.println("jour invalide");
                                        }
                                    }
                                }
                            

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :