Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

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 :