Eléments-de-syntaxe-du-langage-Java.md

@@ -122,7 +122,7 @@ public static void main(String[] args) {
 }
 ```
 
-> :warning: Dans l'exemple précédent, à la première ligne le tableau n'existe pas encore. Il n'existe qu'à l'appel de l'allocateur (`new`), l'affectation de la variable permet ensuite de désigner le tableau et d'accéder à ces éléments.
+> :warning: Dans l'exemple précédent, à la première ligne le tableau n'existe pas encore. Il n'existe qu'à l'appel de l'allocateur (`new`), l'affectation de la variable permet ensuite de désigner le tableau et d'accéder à ses éléments.
 
 # Opérateurs arithmétiques, relationnels et logiques
 
@@ -130,7 +130,8 @@ La suite décrit rapidement l’ensemble des opérateurs utilisables en Java, as
 
 ## Opérateurs arithmétiques et priorités
 
-On trouve en Java les mêmes opérateurs qu’en C (à l’exception de l’opérateur puissance) :
+On trouve en Java les mêmes opérateurs qu’en C (à l’exception de l’opérateur puissance) : 
+
 — l’addition, notée `+`
 — la soustraction, notée `-`
 — l’opposé, (opérateur unaire) noté `-`
@@ -168,22 +169,23 @@ Le langage Java comporte également sept opérateurs _bit-à-bit_ (dans l’ordr
 — le OU exclusif bit-à-bit, noté `ˆ`
 — le OU bit-à-bit, noté `|`
 
-Le langage Java compte trois opérateurs logiques :
+Le langage Java comporte enfin trois opérateurs logiques :
 
 — la négation logique, notée `!`
 — la conjonction (ET) logique, notée `&&` 
 — la disjonction (OU) logique, notée `||`
 
-La négation logique est l’opérateur le plus prioritaire. Les priorités des autres opérateurs sont iden- tiques et l’associativité s’effectue de gauche à droite.
+> :warning: La négation logique est l’opérateur le plus prioritaire. Les priorités des autres opérateurs sont iden- tiques et l’associativité s’effectue de gauche à droite.
 
 # Instructions de contrôle
 
 ## _if/else_
 
 L'instruction conditionnelle `if` / `else` est définie par : 
-- une condition (expression ayant une valeur booléenne), exprimée entre `()`
-- un bloc d'instructions à exécuter si la condition est vraie
-- (optionnel) un bloc d'instructions à exécuter si la condition est fausse
+
+- une **condition** (expression ayant une valeur booléenne), exprimée entre `()`
+- un **bloc d'instructions à exécuter si la condition est vraie**
+- (optionnel) **un bloc d'instructions à exécuter si la condition est fausse**
 
 Un exemple sans bloc `else` : 
 
@@ -212,6 +214,7 @@ else
 
 La construction `switch` permet d’exprimer une liste de décisions. Sa syntaxe est la suivante :
 
+```java
 switch (expression) {
   case valeur1 :
    instructions
@@ -221,6 +224,7 @@ switch (expression) {
   default :
    instructions
 }
+```
 
 Exemple :
 
@@ -236,9 +240,10 @@ switch (a) {
 }
 ```
 
-Les `case` ne sont que des étiquettes de branchement, aucun test n’y est effectué. L’expression est testée au début du `switch` et, selon sa valeur, le programme branche à l’étiquette correspondante et le flot d’instruction suit son cours. Ceci veut dire que s’il n’existe pas de rupture de flot de contrôle (comme `break` ou `return`) les instructions à l’étiquette `case` adéquate et toutes les instructions aux étiquettes suivantes seront exécutées.
+> :warning: Les `case` ne sont que des **étiquettes de branchement**, **aucun test n’y est effectué**. 
+L’expression est testée au début du `switch` et, selon sa valeur, le programme branche à l’étiquette correspondante et le flot d’instruction suit son cours. Ceci veut dire que s’il n’existe pas de rupture de flot de contrôle (comme `break` ou `return`) les instructions à l’étiquette `case` adéquate et toutes les instructions aux étiquettes suivantes seront exécutées.
 
-L’étiquette `default` permet de spécifier un comportement par défaut, lorsqu’aucune étiquette ne correspond à la valeur de l’expression.
+L’étiquette `default` permet de spécifier un **comportement par défaut**, lorsqu’aucune étiquette ne correspond à la valeur de l’expression.
 
 ## Boucle _for_
 
@@ -249,9 +254,9 @@ for (instruction1; expression; instruction2) {
   instructions
 }
 ```
-- `instruction1` est une instruction élémentaire exécutée une et une seule fois avant le premier tour de boucle. C’est en général la déclaration et l’initialisation du compteur de boucle.
-- `expression` est évaluée avant chaque tour de boucle et dénote une condition. Si cette condition n’est pas vérifiée, on ne rentre plus dans le corps de la boucle.
-- `instruction2` est une instruction élémentaire exécutée à chaque fin de tour de boucle. C’est en général l’opération d’incrémentation ou de décrémentation du compteur de boucle.
+- `instruction1` est une instruction élémentaire exécutée u**ne et une seule fois avant le premier tour de boucle**. C’est en général la déclaration et l’initialisation du compteur de boucle.
+- `expression` est **évaluée avant chaque tour de boucle et dénote une condition de poursuite**. Si cette condition n’est pas vérifiée, on ne rentre plus dans le corps de la boucle.
+- `instruction2` est une instruction élémentaire exécutée à **chaque fin de tour de boucle**. C’est en général l’opération d’incrémentation ou de décrémentation du compteur de boucle.
 
 
 Exemple :
@@ -275,22 +280,21 @@ while (expression) {
 et 
 
 ```java
-
 do {
   instructions
 }
 while (expression);
 ```
 
-La différence entre les deux boucles tient dans le fait que l’expression dénotant la condition d’arrêt est évaluée à la fin de chaque tour de boucle dans le `do while` plutôt qu’au début pour le `while` (ce qui signifie que l’instruction constituant le corps de la boucle est exécutée au moins une fois dans un `do while`).
+> :warning: La différence entre les deux boucles tient dans le fait que l’expression dénotant la condition d’arrêt est évaluée à la fin de chaque tour de boucle dans le `do while` plutôt qu’au début pour le `while` (ce qui signifie que l’instruction constituant le corps de la boucle est exécutée au moins une fois dans un `do while`).
 
 ## Instructions `break` et `continue`
 
-Ces deux instructions sont des instructions de rupture de flot de contrôle. 
+Ces deux instructions sont des instructions de **rupture de flot de contrôle**. 
 
-`continue` ne peut être utilisée que dans les itérations (c’est à dire `for` et les variantes de `while`), `break` peut être utilisée aussi dans un `switch`.
+`continue` ne peut être utilisée que dans les itérations (c’est à dire `for` et les variantes de `while`), `break` peut être utilisée également dans un `switch`.
 
-L’instruction `break` permet de sortir immédiatement d'une boucle ou d'un `case` d'un switch`, l’instruction `continue` permet quant à elle de court-circuiter le reste du corps d’une boucle pour redémarrer de suite un nouveau tour.
+L’instruction `break` permet de **sortir immédiatement** d'une boucle ou d'un `case` d'un switch`, l’instruction `continue` permet quant à elle de **court-circuiter** le reste du corps d’une boucle pour redémarrer de suite un nouveau tour.
 
 # :rocket: Pour aller plus loin ...
 
@@ -298,13 +302,13 @@ La suite contient des compléments, non indispensables immédiatement, pour les
 
 ## Types implicites des expressions entières et flottantes, transtypage
 
-Une valeur immédiate **entière** (résultat d'un calcul par exemple) est **implicitement** de type **`int`**, ce qui peut pose problème si on essaye de l’affecter à une variable de type `byte`. 
+Une valeur immédiate **entière** (résultat d'un calcul par exemple) est **implicitement** de type **`int`**, ce qui pose problème si on essaie de l’affecter à une variable de type `byte`. 
 
-Une valeur immédiate **flottante** est implicitement de type **`double`**, ce qui pose problème si on essaye de l’affecter à une variable de type `float`. 
+Une valeur immédiate **flottante** est implicitement de type **`double`**, ce qui pose problème si on essaie de l’affecter à une variable de type `float`. 
 
-En Java ces problèmes se résolvent comme en C un forçage de type (aussi appelé transtypage ou _cast_), avec la même syntaxe consistant à faire précéder la valeur du type compatible entre parenthèses. 
+En Java ces problèmes se résolvent comme en C un **forçage de type** (aussi appelé transtypage ou _cast_), avec la même syntaxe consistant à faire précéder la valeur du type compatible entre parenthèses. 
 
-L'instruction `byte aByte = 4;` est rejetée par le compilateur car `4` est de type `int` (même si 4 est une valeur valide dans l'intervalle `[-128, 127]).
+L'instruction `byte aByte = 4;` est par exemple rejetée par le compilateur car `4` est de type `int` (même si 4 est une valeur valide dans l'intervalle `[-128, 127]).
 
 Pour corriger le problème, on écrira `byte aByte = (byte) 4;`.
 ```
@@ -313,17 +317,17 @@ Pour corriger le problème, on écrira `byte aByte = (byte) 4;`.
 
 Les commentaires en Java ont la même syntaxe qu'en C :
 
-- `//` pour une commentaire de fin de ligne
-- `/* ... */` pour un commentaire multi-lignes
+- `//` pour un commentaire de **fin de ligne**
+- `/* ... */` pour un commentaire **multi-lignes**
 
 ## Le mot-clé `void`
 
-Le mot-clé `void` n'a pas la même interprétation que dans le langage C. Il est utilisé uniquement pour indiquer l'absence de valeur de retour pour une méthode.
+Le mot-clé `void` n'a pas la même interprétation que dans le langage C. Il est utilisé uniquement pour indiquer l'**absence de valeur de retour pour une méthode**.
 
 ## Unicode 
 
-[Unicode](http://www.unicode.org) est une norme qui définit un jeu de caractères universel (qui comprend tous les caractères disponibles dans toutes les langues écrites) et plusieurs types de codages de longueurs fixes (16 bits ou 32 bits par caractère, respectivement appelés UTF-16 et UTF-32) ou variables (de 8 à 24 bits par caractère, appelé UTF-8). 
+[Unicode](http://www.unicode.org) est une **norme qui définit un jeu de caractères universel** (qui comprend tous les caractères disponibles dans toutes les langues écrites) et plusieurs types de codages de longueurs fixes (16 bits ou 32 bits par caractère, respectivement appelés UTF-16 et UTF-32) ou variables (de 8 à 24 bits par caractère, appelé UTF-8). 
 
-Java est conçu de base pour manipuler les caractères et les chaînes de caractères UTF-16 (il est même possible d’utiliser des caractères Unicode dans les codes sources (mais c'est peu recommandé pour des questions de portabilité des sources).
+> Java est conçu de base pour manipuler les caractères et les chaînes de caractères UTF-16 (il est même possible d’utiliser des caractères Unicode dans les codes sources (mais c'est peu recommandé pour des questions de portabilité des sources).