Les structures conditionnelles en Java

Les structures conditionnelles en Java

  1. Objectifs

    • Connaitre les structures conditionnelles en Java
  2. Qu’est-ce qu’une structure conditionnelle ?

    • On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non. Ces structures conditionnelles peuvent être associées à des structures qui se répètent suivant la réalisation de la condition, on appelle ces structures des structures de boucle
    • 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.
    • On appelle structure conditionnelle les instructions qui permettent de tester si une condition est vraie ou non, c’est-à- dire si la valeur de son expression vaut 0 ou 1 (le langage JAVA associe le mot-clé true à 1 et false à 0). Ces structures conditionnelles peuvent être associées à des structures qui se répètent suivant la réalisation de la condition, on appelle ces structures des structures de boucle.
    • Le langage Java fournit les structures conditionnelles suivantes :
      1. if
      2. if-else
      3. if-else if-else
      4. if imbriquée
      5. switch
  3. Notion de bloc en Java

    • Par définition, un bloc est un ensemble de commandes, d’instructions et de déclarations compris entre deux accolades.
    • Une expression suivie d’un point-virgule est appelée instruction. Par exemple i++; est une instruction.
    • Lorsque l’on veut regrouper plusieurs instructions, on peut créer ce que l’on appelle un bloc, c’est-à-dire un ensemble d’instructions (suivies respectivement par des point-virgules) et comprises entre les accolades { int i; i<10; i++ }.
    • Les instructions if, while et for peuvent par exemple être suivies d'un bloc d'instructions à exécuter...
    • Toute variable définie dans un élément for ou while est considérée comme faisant partie du bloc qui suit ce for ou ce while.
    • un bloc définit la portée d'une variable. Une variable définie à l'intérieur d'un bloc n'est pas connue à l'extérieur de ce bloc.
    • Une variable définie dans un bloc ne peut pas avoir le même nom qu'une autre variable définie dans un bloc englobant.
  4. Structure conditionnelle if en Java

    • La structure conditionnelle if permet de tester si une condition est vraie. Dans ce cas elle a la valeur booléenne true. Si c'est le cas alors le programme exécute l'instruction qui suit ou le bloc d'instructions qui suit.
    • Syntaxe
      • La condition toujours entre parenthèses

      • Une instructions
        • if ( condition ) une_seule_instruction ;
      • Plusieurs instructions
        • Une paire d'accolades est obligatoire

          if ( condition ) {
          	instruction_1 ;
          	instruction_2 ;
          }
          
  5. Structure conditionnelle if-else en Java

    • Si l'évaluation de l'expression booléenne test donne true (la valeur 'vrai'), alors l'instruction 1 est exécutée; sinon l'expression booléenne a donné false (la valeur 'faux') et l'instruction 2 est exécutée.
    • Syntaxe
      • if ( condition ) {
        	instructions à exécuter si la condition est true ;
        }else{
                instructions à exécuter si condition est false
        }
        
      • 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.
  6. Structure conditionnelle if-else if-else en Java

    • L'instruction if-else if-else vous permet de vérifier plusieurs conditions et d'exécuter différentes instructions.
    • Syntaxe
      • if ( condition1 ) {
        	        instructions à exécuter si la condition 1 est true;
                   }else if(condition2){
                         instructions à exécuter si condition 2 est true;
                         // condition 1 est false
                   }else if(condition3){
                         instructions à exécuter si condition 2 est true;
                         // condition 1, condition 2 est false
                   }......
                   }else{
                        instructions à exécuter si toutes les conditions précédentes sont false;
            }
        
    • Exemple
      • Les structures conditionnelles en Java

  7. Structure conditionnelle if imbriquée

    • Il est possible d'inclure une instruction if ... else dans le corps d'une autre instruction if ... else.
    • Exemple
      • Écrire un programme Java qui demande à l’utilisateur de saisir 3 nombres réels x, y et z et de lui afficher le maximum de ces trois nombres
      • Les structures conditionnelles en Java

  8. Structure conditionnelle switch

    • l’instruction switch permet en évaluant une valeur d’accéder directement aux instructions prévus pour cette valeur.
    • Il remplace avantageusement l’utilisation d’instructions if else imbriquées.
    • Le cas "default" ne s'exécute que lorsque aucun des cas précédents n’a été validé.
    • Syntaxe
      • switch (expression)
            case constante1 : commande1 ;
            [ break ; ] 
            [ case constante2 : commande2 ;
            [ break ; ]] 
            [ default : commande ; ]
        
      • Dans ce modèle, expression peut être n'importe quelle expression qui retourne un entier de type byte, char, short ou int (le type long n'est pas accepté), ou une valeur énumérée.
      • Les valeurs constante1 , constante2 , etc... sont des valeurs constantes. Ce peut donc être :
        • des valeurs écrites en dur dans le code, ce qui est évidemment à proscrire !
        • des valeurs constantes, donc déclarées comme étant final. Ces valeurs peuvent être importées statiquement.
        • des valeurs énumérées.
      • Les commandes sont des instructions Java classiques, rangées ou non dans un bloc, cela n'a pas d'importance (en général elles ne le sont pas).
      • L’omission d’une instruction de saut (break) permet de rentrer automatiquement dans le case suivant.
    • Fonctionnement de l'instruction switch case
      • Tout d'abord, l'expression entière spécifiée dans l'instruction switch est évaluée. Cette valeur est ensuite mise en correspondance une à une avec les valeurs constantes données dans les différents cas.
      • Si une correspondance est trouvée, alors toutes les instructions spécifiées dans ce cas sont exécutées avec tous les cas présents après ce cas, y compris l'instruction par défaut.
      • Deux cas ne peuvent pas avoir des valeurs similaires.
      • Si la casse correspondante contient une instruction break, toutes les casses présentes après celle-ci seront ignorées et le contrôle sort du commutateur.
      • Dans le cas contraire, tous les cas suivant le cas apparié seront exécutés.
  9. Application

    • Exercice01
      • Écrire un programme en langage Java qui demande à l'utilisateur d'entrer la moyenne d'un étudiant.
      • Le programme permet d'afficher la mention obtenue.
        • Moyenne en dessous de 10 : redouble
        • Moyenne entre 10 (inclus) et 12 : passable
        • Moyenne entre 12 (inclus) et 14 : Assez Bien
        • Moyenne entre 14 (inclus) et 16 : Bien
        • Moyenne supérieure à 16 : Très Bien
    • Exercice02
      • Écrire un programme qui permet de saisir un entier N et d'afficher s'il est premier ou non. Un nombre est dit premier s'il est divisible uniquement par 1 et par lui-même.
      • Lorsque le programme est compilé et exécuté, il doit produire le résultat suivant
      • Saisir un nombre - 13 13 est un nombre premier
    • Exercice03
      • Écrire un programme en java permettant d’afficher le mois en lettre selon le numéro saisi au clavier (janvier=1 , février =2 …….. décembre = 12).
      • Le mois saisi au clavier doit être entre 1 et 12
      • Les structures conditionnelles en Java