expressions2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Types caractères et chaînes de caractères\n",
    "\n",
    "En plus des nombres, on manipule souvent des informations sous forme de texte: le nom d'une personne, des messages à afficher à l'écran, etc.\n",
    "\n",
    "Pour ceci, en Java on utilisera deux autres *types*: le type ```char```, qui représente un caractère, et le type ```String```, qui représente une *chaîne de caractères*, c'est à dire une portion de texte de longueur quelconque.\n",
    "\n",
    "Pour ces deux types, on peut aussi définir des opérations.\n",
    "\n",
    "## Caractères\n",
    "\n",
    "Comme toutes les informations dans un ordinateur, les caractères sont représentés en mémoire par des codes numériques. La première table de codage est la table ASCII (\"aski\"), qui contenait 256 caractères codés sur un octet (8 bits). Ces caractères incluaient les lettres de l'alphabet latin, les chiffres, et un certain nombre de caractères spéciaux, notamment des caractères de ponctuation, des éléments graphiques utiles pour la mise en page (comme des lignes ou des coins, pour former des tableaux, encadrer ou souligner des sections de texte...), et des symboles utilisés pour la communication réseau (donc pas vraiment des caractères).\n",
    "\n",
    "Cette table de codage a été étendue à la table *Unicode*, qui donne des codes pour tous les caractères, symboles et idéogrammes des différents langages humains. Ces codes numériques dépassent évidemment la valeur 256, et doivent être codés sur plusieurs octets. Même si la table unicode est unique, il existe plusieurs façons de représenter ces codes en binaire, notamment des systèmes utilisant un nombre variable de bits (pour économiser de la mémoire lorsqu'un texte utilise presque exclusivement des caractères de la table ASCII). Un tel système d'encodage est le système \"UTF-8\". Les variations et incompatibilités entre les systèmes de codage expliquent les problèmes où un texte passé d'un système d'exploitation à un autre peut inclure des caractères bizarres...\n",
    "\n",
    "En Java, on écrit les caractères en utilisant les quotes simples. Exemples: ```'a'```, ```'5'```, ```'}'```.\n",
    "\n",
    "On peut connaître la représentation numérique d'un caractère en faisant un cast vers un type numérique:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int) 'A'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ceci signifie que le caractère A majuscule est représenté en mémoire par le code 65, ou plutôt 01000001 en binaire (sur 8 bits).\n",
    "\n",
    "On peut aussi convertir dans l'autre sens: un nombre vers le caractère correspondant:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "A"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char) 65"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Attention:** les caractères qui représentent les chiffres n'ont pas la valeur associée au chiffre écrit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(int) '3'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici, 51 (ou 0110011 en binaire) est le code ASCII du caractère ```'3'```, ce qui n'a rien à voir avec la valeur 3. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Opérations sur les ```char```\n",
    "\n",
    "Contrairement aux types numériques, il n'y a pas vraiment d'opérations très utiles à faire sur des caractères: on peut les mettre côte-à-côte pour former du texte, mais cette opération est une opération du type ```String``` (voir ci-dessous). \n",
    "\n",
    "Cependant, comme il y a une conversion directe des caractères en nombres (et vice-versa), il est parfois utile de faire des opérations numériques sur les caractères. En réalité, les caractères sont alors automatiquement convertis en nombres et l'opération se fait sur les nombres -- le résultat n'est pas automatiquement re-converti en caractère."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "131"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A' + 'B'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut ainsi utiliser des additions pour décaler les lettres dans l'alphabet, il faut utiliser un *cast* pour revenir à une représentation par un caractère:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "67"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'A' + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "C"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(char) ('A' + 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Les chaînes de caractères: le type ```String```\n",
    "Les caractères sont assez peu utilisés tels quels en Java (et en programmation en général): on manipule plutôt des chaînes de caractères, qui sont simplement des séquences de ```char```. Le type à utiliser pour une chaîne de caractères est le type ```String```. \n",
    "\n",
    "Dans la suite du cours on utilisera souvent le terme \"String\" au lieu de \"chaîne de caractère\" pour alléger le texte.\n",
    "En Java, un ```String``` est représenté par le texte entre des quotes doubles ```\"```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bonjour"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"bonjour\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Les doubles cotes sont nécessaires pour que Java ne cherche pas à interpréter le texte comme des instructions Java.\n",
    "\n",
    "\n",
    "### Opérations sur les ```String```\n",
    "La seule opération qu'on peut réaliser pour combiner deux String est la *concaténation*, qui utilise le symbole ```+```: cette opération consiste simplement à mettre les deux String bout à bout et obtenir un nouveau String:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bonjour"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"bon\" + \"jour\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La concaténation n'insère pas automatiquement des espaces, et l'espace entre le String et le symbole ```+``` ne comptent pas: si on veut séparer des mots il faut ajouter des espaces *dans* les String:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "la petite chèvre"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"la\" + \" \" + \"petite\"+ \" chèvre\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On peut insérer aussi des retours à la ligne, des tabulations, et d'autres caractères spéciaux, en utilisant des codes particuliers commençant par une barre oblique inverse ```\\```. Le retour à la ligne s'écrit ```\\n``` (pour *newline*), et la tabulation ```\\t```: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bonjour, \n",
       "petite chèvre!"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"bonjour, \\npetite chèvre!\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si l'on veut utiliser les caractères ```\"``` ou ```\\``` de manière \"littérale\" (et non pas pour terminer un String ou pour introduire un code spécial, il faut les précéder d'une barre oblique:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Je m'appelle \"Biquette\" et je suis une chèvre naine Afghane."
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Je m'appelle \\\"Biquette\\\" et je suis une chèvre naine Afghane.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Le retour à la ligne s'écrit \"\\n\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Le retour à la ligne s'écrit \\\"\\\\n\\\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 6\n",
    "\n",
    "Écrire un String (un seul) qui s'affichera comme ceci, sur plusieurs lignes et avec les double quotes:\n",
    "\n",
    "```\n",
    "A - \"alpha\"\n",
    "B - \"bravo\"\n",
    "C - \"charlie\"\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion entre nombres et chaines de caractères\n",
    "\n",
    "Comme on l'a indiqué plus haut, la valeur numérique d'un chiffre n'a absolument rien à voir avec le caractère qui représente ce chiffre: par exemple ```'3'``` est le caractère 51. De même, la séquence des caractères 51, 49 et 54, soit le String ```\"316\"``` n'a pas grand chose à voir avec les codes de ces caractères...\n",
    "\n",
    "De manière générale, les informations numériques n'ont rien à voir avec les informations \"textuelles\", et ne peuvent être combinées. Cependant, il est utile de convertir entre les deux types d'informations, pour afficher des informations numériques à l'écran (sous forme de caractères) ou pour lire au clavier une donnée numérique (faire le lien entre les caractères tapés au clavier et une valeur numérique en base 10). \n",
    "\n",
    "Java fournit des mécanismes pour passer de l'un à l'autre. La conversion de nombre vers String se fait automatiquement quand on insère un nombre dans une chaîne de caractères, et nous verrons les mécanismes inverses lorsque nous verrons les entrées et sorties.\n",
    "\n",
    "La seule opération utile qui combine un nombre et une chaîne de caractères est la concaténation, où on concatène la représentation String du nombre, avec un autre String:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Les bêtes de ce troupeau ont en moyenne 4 pattes."
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"Les bêtes de ce troupeau ont en moyenne \" + 84 / 21 + \" pattes.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici l'expression, qui inclut 3 opérateurs et 4 opérandes (2 String et 2 nombres entiers) sera exécutée une opération à la fois, en suivant l'ordre de précédence des opérateurs. \n",
    "\n",
    "Les règles de précédence sont faites comme si le ```'+'``` était une addition: une multiplication ou une division a priorité sur une concaténation, et une addition ou une soustraction ont la même priorité que la concaténation: ces opérations se font alors de gauche à droite.\n",
    "\n",
    "Ceci peut avoir des conséquences surprenantes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "J'ai 12 pommes."
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"J'ai \"+ 1 + 2 + \" pommes.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On a d'abord converti le chiffre 1 en String et concaténé ```\"J'ai \"``` avec ```1```, puis on a converti le 2 et concaténé ```J'ai 1``` avec ```2```, puis on a concaténé ```\"J'ai 12``` avec ```\" pommes.\"```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7 pommes suffisent pour cette tarte."
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 + 4 + \" pommes suffisent pour cette tarte.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cette fois on a commencé par la première opération ```+``` (à gauche), qui est une addition entre les nombres 3 et 4. On a obtenu le nombre 7, et comme la deuxième opération combine un nombre et un String, c'est une concaténation: on convertit donc 7 en String, et on effectue la concaténation.\n",
    "\n",
    "À noter qu'on peut toujours utiliser des parenthèses pour forcer un ordre particulier d'exécution."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice 7\n",
    "\n",
    "Donner le type (```int```, ```double```, ou ```String```) et la valeur des expressions suivantes. Le cas échéant, indiquer quelles expressions sont invalides (causent une erreur)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(int) 3/4 + \" pommes\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 * \"a\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3 + 3 + \"3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(double) 3 / \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"4\" + \"2\" + 3 * 4"
   ]
  }
 ],
 "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
}