conditions2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Instructions Conditionnelles: suite\n",
    "## Blocs d'instructions\n",
    "\n",
    "À l'occasion de l'utilisation d'instructions ```if``` nous avons écrit nos premiers *blocs d'instructions*, c'est à dire des sections de code délimitées par des accolades ```{``` et ```}```.\n",
    "\n",
    "#### Exemple\n",
    "On reprend l'exemple du calcul de la valeur absolue d'un nombre:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrer un nombre:\n",
      "-45.8\n",
      "La valeur absolue du nombre est: 45.8\n"
     ]
    }
   ],
   "source": [
    "import java.util.Scanner;\n",
    "Scanner clavier=new Scanner(System.in);\n",
    "\n",
    "System.out.println(\"Entrer un nombre:\");\n",
    "double nombre = clavier.nextDouble();\n",
    "\n",
    "double absolue = nombre;\n",
    "\n",
    "if (nombre <0){\n",
    "    absolue = - absolue;\n",
    "}\n",
    "\n",
    "System.out.println(\"La valeur absolue du nombre est: \" + absolue);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, si la condition du ```if``` est vraie (si nombre est strictement négatif), on exécute l'instruction ```absolue= - absolue;```, qui est placée dans un bloc, comme on fait habituellement après un ```if```.\n",
    "\n",
    "En fait, ici les accolades sont optionnelles, puisqu'on a une seule instruction. Si on devait exécuter deux instructions (ou plus) à la suite du ```if``` ou du ```else``` il serait nécessaire de mettre des accolades.\n",
    "\n",
    "#### Exemple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Changement de signe !\n",
      "La valeur absolue du nombre est: 45.8\n"
     ]
    }
   ],
   "source": [
    "double absolue = nombre;\n",
    "\n",
    "if (nombre <0){\n",
    "    absolue = - absolue;\n",
    "    System.out.println(\"Changement de signe !\");\n",
    "}\n",
    "\n",
    "System.out.println(\"La valeur absolue du nombre est: \" + absolue);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans ce code les accolades sont indispensables. Dans un programme Java, on aura souvent un grand nombre de blocs de code, qui peuvent être imbriqués les uns dans les autres (voir ci-dessous)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Portée d'une variable\n",
    "\n",
    "Avant de développer l'usage des blocs d'instructions et notamment leur imbrication, il faut aborder une notion fondamentale en programmation: la *portée* d'une variable.\n",
    "\n",
    "On a déjà vu que pour pouvoir utiliser une variable en Java, il faut la *déclarer*, sinon on a une erreur de compilation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mmavariable\u001b[0m\u001b[1m\u001b[30m = 35;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable mavariable\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "mavariable = 35;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "L'erreur ```cannot find symbol``` signifie que le nom (symbole) surligné est inconnu, tout simplement parce qu'il n'a pas été déclaré.\n",
    "\n",
    "On peut remarquer que même si une variable est déclarée dans un programme, le nom n'est \"valide\" qu'à partir de la déclaration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30m\u001b[0m\u001b[1m\u001b[30m\u001b[41mmavariable\u001b[0m\u001b[1m\u001b[30m = 35;\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable mavariable\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "mavariable = 35;\n",
    "int mavariable;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On voit donc que les noms de variables ne sont valides que dans une partie d'un programme: la partie d'un programme où un nom de variable est valide est appelé la *portée* de la variable.\n",
    "\n",
    "On a donc une première règle: un nom de variable (de variable *locale*, comme toutes celles qu'on a utilisées jusqu'à maintenant) est valide **à partir de sa déclaration**. \n",
    "\n",
    "La question suivante est maintenant: *jusqu'où* un nom de variable est-il valide? \n",
    "\n",
    "En Java, la réponse est la suivante: une variable est valide **jusqu'à la fin du bloc d'instructions où elle a été déclarée**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Somme de x et y: 7 \n"
     ]
    },
    {
     "ename": "CompilationException",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1m\u001b[30m|   \u001b[1m\u001b[30mSystem.out.printf(\"Différence de x et y: %d %n\", x - \u001b[0m\u001b[1m\u001b[30m\u001b[41my\u001b[0m\u001b[1m\u001b[30m);\u001b[0m",
      "\u001b[1m\u001b[31mcannot find symbol\u001b[0m",
      "\u001b[1m\u001b[31m  symbol:   variable y\u001b[0m",
      ""
     ]
    }
   ],
   "source": [
    "int x = 2;\n",
    "if(x==2){\n",
    "    int y = 5;\n",
    "    System.out.printf(\"Somme de x et y: %d %n\", x + y);\n",
    "}\n",
    "\n",
    "System.out.printf(\"Différence de x et y: %d %n\", x - y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On observe ici que la variable ```y``` a bien été utilisée lignes 3 et 4, mais qu'elle n'est plus reconnue ligne 7. Ceci s'explique par le fait que ```y``` a été déclarée à l'intérieur du bloc suivant le if, qui commence par l'accolade ouvrante ligne 2 et se termine par l'accolade fermante ligne 5.\n",
    "\n",
    "En revanche, le ```x``` qui a été déclaré *avant* le bloc, ne pose pas problème ligne 7: le bloc dans lequel il a été déclaré (ses accolades ne sont pas visibles mais il est conceptuellement \"extérieur\" au ```if```) ne s'est pas terminé.\n",
    "\n",
    "Sans surprise, si on sort la déclaration de ```y``` du bloc, le nom continuera à être valide:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Somme de x et y: 7 \n",
      "Différence de x et y: -3 \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "java.io.PrintStream@75252b4f"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int x = 2;\n",
    "int y = 5;\n",
    "if(x==2){\n",
    "    System.out.printf(\"Somme de x et y: %d %n\", x + y);\n",
    "}\n",
    "\n",
    "System.out.printf(\"Différence de x et y: %d %n\", x - y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 3\n",
    "\n",
    "Une situation classique où on doit tenir compte de la portée d'une variable est quand on doit fixer la valeur d'une variable dans un ```if-else```. Par exemple, le programme de la valeur absolue peut s'écrire:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "System.out.println(\"Entrer un nombre:\");\n",
    "double nombre = clavier.nextDouble();\n",
    "\n",
    "if (nombre >=0){\n",
    "    absolue = nombre;\n",
    "} else {\n",
    "    absolue = - nombre;\n",
    "}\n",
    "\n",
    "System.out.println(\"La valeur absolue du nombre est: \" + absolue);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici le code est incomplet: la variable ```absolue``` n'a pas été déclarée. La question est: où la déclarer pour que le programme fonctionne correctement?\n",
    "\n",
    "Réponses possibles:  \n",
    "(a) ligne 3  \n",
    "(b) ligne 5  \n",
    "(c) ligne 5 et ligne 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## If imbriqués\n",
    "Comme on l'a mentionné plus tôt, on peut imbriquer des blocs de code les uns dans les autres afin de créer des algorithmes plus complexes.\n",
    "\n",
    "\n",
    "#### Exemple\n",
    "On peut par exemple placer un ```if``` à l'intérieur du bloc créé par un premier ```if```: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrez votre note sur 100 au cours:\n",
      "84\n",
      "Vous avez brillamment réussi ce cours!"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrez votre note sur 100 au cours:\");\n",
    "int note = clavier.nextInt();\n",
    "if (note>=52){\n",
    "    System.out.print(\"Vous avez \"); \n",
    "    if(note >=80){\n",
    "        System.out.print(\"brillamment réussi\"); \n",
    "    } else {\n",
    "        System.out.print(\"passé\"); \n",
    "    }\n",
    "    System.out.print(\" ce cours!\");\n",
    "} else {\n",
    "    System.out.print(\"C'est malheureusement un échec.\"); \n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dans cet exemple, l'utilisateur est invité à entrer une note sur 100 pour un cours.\n",
    "On a ensuite des instructions conditionnelles qui dépendent de la note. Un premier ```if``` évalue si la note est supérieure à 52, et selon le cas, l'un des blocs ```if``` ou ```else``` est exécuté. \n",
    "\n",
    "Dans l'exécution montrée ci-dessus, où l'utilisateur entre la valeur ```84``` pour la variable ```note```, l'ordre d'exécution des lignes est le suivant:\n",
    "* lignes 1, 2\n",
    "* évaluation de la condition ligne 3: pour la condition est vraie (84 >= 52); l'accolade ouvrante ```{``` marque le début d'un premier bloc d'instructions\n",
    "* on entre donc dans le bloc suivant immédiatement le ```if```, ligne 4\n",
    "* ligne 5, on continue dans le même bloc d'instructions, évaluation de la condition: à nouveau la condition est vraie;\n",
    "* on entre donc dans le bloc imbriqué, ligne 6\n",
    "* on arrive à une accolade fermante ```}``` et on quitte donc le bloc imbriqué: on saute à la ligne 10\n",
    "* après la ligne 10 on arrive ligne 11 et on trouve à nouveau une accolade fermante ```}```. On quitte donc le premier bloc, on saute ligne 13, l'exécution est terminée\n",
    "\n",
    "De la même façon, on peut intégrer de nouvelles instructions conditionnelles à l'intérieur du bloc ```else```, ou aller à une plus grande profondeur d'imbrication. En composant ainsi le code, on peut gérer différentes combinaisons de conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 4\n",
    "\n",
    "On souhaite diagnostiquer le risque lié à l'obésité selon le sexe et le tour de taille d'un patient.\n",
    "On a deux variables: ```sexe```: 'M' ou 'F' et ```tourDeTaille```: le tour de taille en cm.\n",
    "\n",
    "Le diagnostic est le suivant: pour un homme, on déclare la personne à risque si son tour de taille dépasse 102cm, et pour une femme, la limite est de 88cm.\n",
    "\n",
    "**Modifier** le programme suivant pour afficher l'un des deux messages \"Le patient est à risque\" ou \"Le patient n'est pas à risque\" selon son sexe et son tour de taille. Tel qu'il est, il diagnostique tous les hommes comme étant à risque.\n",
    "\n",
    "**Indication:** utiliser des ```if``` imbriqués: un ```if-else``` portant sur le sexe, et à l'intérieur de chaque bloc un nouveau ```if``` portant sur le tour de taille."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrez le sexe (M ou F) du patient suivi de son tour de taille en cm:\n",
      "M 84\n",
      "Le patient est à risque\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrez le sexe (M ou F) du patient suivi de son tour de taille en cm:\");\n",
    "char sexe = clavier.next().charAt(0); //cet appel de fonction renvoie le premier caractère du String lu au clavier\n",
    "int tourDeTaille = clavier.nextInt();\n",
    "\n",
    "if (sexe=='M'){\n",
    "    System.out.println(\"Le patient est à risque\");\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ```if``` - ```else if``` - ```else```\n",
    "\n",
    "Une utilisation classique de ```if``` imbriqués est pour des instructions conditionnelles pour laquelle il y a plus de deux conditions, et ces conditions peuvent être décrites en énumérant les valeurs possibles d'une variable, souvent sous forme d'intervalles. Par exemple, si l'on voulait convertir une note numérique sur 100 en lettre (A, B, C, D, ou E), on pourrait évaluer toutes les possibilités dans l'ordre décroissant de notes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrez votre note sur 100 au cours:\n",
      "68\n",
      "Votre note en lettre est: C\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrez votre note sur 100 au cours:\");\n",
    "int note = clavier.nextInt();\n",
    "char lettre;\n",
    "if (note < 50){\n",
    "    lettre = 'E';\n",
    "} else if (note < 60){\n",
    "    lettre = 'D';\n",
    "} else if (note < 70){\n",
    "    lettre = 'C';\n",
    "} else if (note < 80){\n",
    "    lettre = 'B';\n",
    "} else {\n",
    "    lettre = 'A';\n",
    "}\n",
    "\n",
    "System.out.println(\"Votre note en lettre est: \" + lettre); "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cettre structure -- une séquence de  ```if``` - ```else if``` - ```else``` qui énumère toutes les possibilités, est très classique. Examinons de plus près comment elle marche.\n",
    "\n",
    "D'abord, on peut remarquer qu'il s'agit en fait de ```if-else``` imbriqués: plus précisément, on commence par un ```if```, puis dans la clause ```else``` on imbrique un nouveau ```if-else```, et dans ce ```else``` on place à nouveau un ```if - else```, etc.\n",
    "\n",
    "L'écriture ci-dessus est lisible et la plus usitée, mais en utilisant une indentation classique et des accolades autour de chaque bloc on peut mieux bien voir que cette séquence est une imbrication de ```if-else``` ordinaires: on peut visualiser la structure de chaque ```if``` et du ```else``` correspondant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "if (note < 50){\n",
    "    lettre = 'E';\n",
    "} else { \n",
    "    if (note < 60){\n",
    "        lettre = 'D';\n",
    "    } else {\n",
    "        if (note < 70){\n",
    "            lettre = 'C';\n",
    "        } else {\n",
    "            if (note < 80){\n",
    "                lettre = 'B';\n",
    "            } else {\n",
    "                lettre = 'A';\n",
    "            } // fin du bloc lignes 12-14\n",
    "        } // fin du bloc lignes 9-15 \n",
    "    } // fin du bloc lignes 6-16\n",
    "} // fin du bloc lignes 3-17"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remarquer la correspondance des accolades (indiquée par les commentaires).\n",
    "\n",
    "Ceci montre bien que l'on considère les intervalles de notes les uns après les autres. Supposons par exemple que la note entrée est 67. La première condition est fausse (la note est supérieure ou égale à 50), alors on entre dans le bloc ```else``` (lignes 3 à 17). On est entré dans un bloc, on est maintenant à une \"profondeur d'imbrication\" de 1. \n",
    "\n",
    "Là on rencontre une condition qui évalue si la note est inférieure à 60 (ligne 4). Comme c'est encore faux, on entre dans le bloc ```else``` des lignes 6 à 16 (profondeur 2). On rencontre une condition qui évalue si la note est inférieure à 70 (ligne 7), et là c'est vrai: on entre donc dans le bloc suivant le ```if``` (ligne 8, profondeur 3). À la fin de ce bloc (accolade ```}``` en début de ligne 9), on revient à la profondeur 2, et on saute le bloc ```else``` des lignes 9-15, et on arrive ligne 16 , où le bloc else de la ligne 6 se termine (on revient à la profondeur 1), puis ligne 17, où se termine celui de la ligne 3. On est donc rsorti de tous les blocs imbriquées et on est revenu à la profondeur initiale.\n",
    "\n",
    "Recommendation: on utilise une telle structure ```if``` - ```else if``` - ```else``` dans une situation où il existe plusieurs possibilitées mutuellement exclusive, typiquement une variable peut se trouver dans différents intervalles (elle ne peut pas être dans plusieurs intervalles en même temps).\n",
    "\n",
    "#### Exercice 5\n",
    "\n",
    "Dans le programme suivant, l'utilisateur entre la température d'une eau de baignade, en degrés Celcius. Si cette température est inférieure à 0, le programme affiche un message \"l'eau est gelée!\". \n",
    "\n",
    "**Compléter le programme** pour afficher des messages différents selon la température. Si la température est entre 0 et 12, afficher un message \"l'eau est trop froide\", si elle est entre 12 et 20, afficher \"prenez votre combinaison pour vous baigner\", et enfin si la température est au-dessus de 20, afficher \"tous à l'eau!\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entrez la température de l'eau:\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "System.out.println(\"Entrez la température de l'eau:\");\n",
    "int temperature = clavier.nextInt();\n",
    "\n",
    "if (temperature < 0){\n",
    "    System.out.println(\"L'eau est gelée\");\n",
    "}"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Java",
   "language": "java",
   "name": "java"
  },
  "language_info": {
   "codemirror_mode": "java",
   "file_extension": ".jshell",
   "mimetype": "text/x-java-source",
   "name": "Java",
   "pygments_lexer": "java",
   "version": "14.0.1+7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}