|
|
|
Le but de ce document est de présenter les éléments de syntaxe du langage Java : les types primitifs, les opérateurs arithmétiques et logiques, les structures de contrôle.
|
|
|
|
|
|
|
|
- [Variables de types primitifs ou tableaux](#variables-de-types-primitifs-ou-tableaux)
|
|
|
|
* [Types _entier_ et _flottant_](#types--entier--et--flottant-)
|
|
|
|
* [Les types _booléen_ et _caractère_](#les-types--bool-en--et--caract-re-)
|
|
|
|
* [Le type _tableau_](#le-type--tableau-)
|
|
|
|
- [Déclaration de variables, affectation](#d-claration-de-variables--affectation)
|
|
|
|
* [Variables de type primitif](#variables-de-type-primitif)
|
|
|
|
* [Variables de type tableau](#variables-de-type-tableau)
|
|
|
|
- [Opérateurs arithmétiques, relationnels et logiques](#op-rateurs-arithm-tiques--relationnels-et-logiques)
|
|
|
|
* [Opérateurs arithmétiques et priorités](#op-rateurs-arithm-tiques-et-priorit-s)
|
|
|
|
* [Opérateurs relationnels et logiques et priorités](#op-rateurs-relationnels-et-logiques-et-priorit-s)
|
|
|
|
- [Instructions de contrôle](#instructions-de-contr-le)
|
|
|
|
* [_if/else_](#-if-else-)
|
|
|
|
* [_switch_](#-switch-)
|
|
|
|
* [Boucle _for_](#boucle--for-)
|
|
|
|
* [Boucle `while` et `do while` :](#boucle--while--et--do-while---)
|
|
|
|
* [Instructions `break` et `continue`](#instructions--break--et--continue-)
|
|
|
|
- [:rocket: Pour aller plus loin ...](#-rocket--pour-aller-plus-loin-)
|
|
|
|
* [Types implicites des expressions entières et flottantes, transtypage](#types-implicites-des-expressions-enti-res-et-flottantes--transtypage)
|
|
|
|
* [Commentaires](#commentaires)
|
|
|
|
* [Le mot-clé `void`](#le-mot-cl---void-)
|
|
|
|
* [Unicode](#unicode)
|
|
|
|
|
|
|
|
<small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>
|
|
|
|
# Table des matières
|
|
|
|
|
|
|
|
<!-- TOC start (generated with https://github.com/derlin/bitdowntoc) -->
|
|
|
|
|
|
|
|
- [Variables de types primitifs ou tableaux](#variables-de-types-primitifs-ou-tableaux)
|
|
|
|
* [Types _entier_ et _flottant_](#types-entier-et-flottant)
|
|
|
|
* [Les types _booléen_ et _caractère_](#les-types-booléen-et-caractère)
|
|
|
|
* [Le type _tableau_](#le-type-tableau)
|
|
|
|
- [Déclaration de variables, affectation](#déclaration-de-variables-affectation)
|
|
|
|
* [Variables de type primitif](#variables-de-type-primitif)
|
|
|
|
* [Variables de type tableau](#variables-de-type-tableau)
|
|
|
|
- [Opérateurs arithmétiques, relationnels et logiques](#opérateurs-arithmétiques-relationnels-et-logiques)
|
|
|
|
* [Opérateurs arithmétiques et priorités](#opérateurs-arithmétiques-et-priorités)
|
|
|
|
* [Opérateurs relationnels et logiques et priorités](#opérateurs-relationnels-et-logiques-et-priorités)
|
|
|
|
- [Instructions de contrôle](#instructions-de-contrôle)
|
|
|
|
* [_if/else_](#ifelse)
|
|
|
|
* [_switch_](#switch)
|
|
|
|
* [Boucle _for_](#boucle-for)
|
|
|
|
* [Boucle `while` et `do while` :](#boucle-while-et-do-while-)
|
|
|
|
* [Instructions `break` et `continue`](#instructions-break-et-continue)
|
|
|
|
- [:rocket: Pour aller plus loin ...](#rocket-pour-aller-plus-loin-)
|
|
|
|
* [Types implicites des expressions entières et flottantes, transtypage](#types-implicites-des-expressions-entières-et-flottantes-transtypage)
|
|
|
|
* [Commentaires](#commentaires)
|
|
|
|
* [Le mot-clé `void`](#le-mot-clé-void)
|
|
|
|
* [Unicode ](#unicode)
|
|
|
|
|
|
|
|
<!-- TOC end -->
|
|
|
|
|
|
|
|
|
|
|
|
<!-- TOC --><a name="variables-de-types-primitifs-ou-tableaux"></a>
|
|
|
|
# Variables de types primitifs ou tableaux
|
|
|
|
|
|
|
|
En Java, le terme **primitif** se rapporte aux types de données qui peuvent avoir une réprésentation immédiate en mémoire :
|
| ... | ... | @@ -36,6 +42,7 @@ En Java, le terme **primitif** se rapporte aux types de données qui peuvent avo |
|
|
|
|
|
|
|
Les valeurs de type primitif ont une taille indépendante de la plateforme d’exécution du code.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="types-entier-et-flottant"></a>
|
|
|
|
## Types _entier_ et _flottant_
|
|
|
|
|
|
|
|
Le tableau ci-dessous récapitule les types entiers, leur taille et leurs valeurs extrêmes.
|
| ... | ... | @@ -63,6 +70,7 @@ Deux notations sont utilisables : décimale (`-3.25`) ou exponentielle (`-3.2323 |
|
|
|
|
|
|
|
:rocket: Pour en savoir plus, voir `Types implicites des expressions entières et flottantes, transtypage` dans la section `Pour aller plus loin`
|
|
|
|
|
|
|
|
<!-- TOC --><a name="les-types-booléen-et-caractère"></a>
|
|
|
|
## Les types _booléen_ et _caractère_
|
|
|
|
|
|
|
|
Le type **booléen** est désigné par le mot-clé `boolean` et représente un **état logique vrai ou faux**.
|
| ... | ... | @@ -80,14 +88,17 @@ On peut désigner une valeur de type `char` : |
|
|
|
|
|
|
|
Il est possible d'effectuer des opérations arithmétiques sur des caractères pour passer d'un caractère à un autre ou pour changer la casse. Par exemple , `'a'+1` représente le caractère `'b'`.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="le-type-tableau"></a>
|
|
|
|
## Le type _tableau_
|
|
|
|
|
|
|
|
Le type tableau est désigné par le **type de ses éléments suivi de `[]`**.
|
|
|
|
|
|
|
|
Par exemple, `byte[]` représente un le type _tableau d’octets_.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="déclaration-de-variables-affectation"></a>
|
|
|
|
# Déclaration de variables, affectation
|
|
|
|
|
|
|
|
<!-- TOC --><a name="variables-de-type-primitif"></a>
|
|
|
|
## Variables de type primitif
|
|
|
|
|
|
|
|
La déclaration d’un entier, d’un flottant, d’un booléen ou d’un caractère s’effectue de la même manière qu’en C.
|
| ... | ... | @@ -114,6 +125,7 @@ public static void main(String[] args) { |
|
|
|
}
|
|
|
|
```
|
|
|
|
|
|
|
|
<!-- TOC --><a name="variables-de-type-tableau"></a>
|
|
|
|
## Variables de type tableau
|
|
|
|
|
|
|
|
Les tableaux Java ressemblent aux tableaux de C :
|
| ... | ... | @@ -144,10 +156,12 @@ 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 à ses éléments.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="opérateurs-arithmétiques-relationnels-et-logiques"></a>
|
|
|
|
# Opérateurs arithmétiques, relationnels et logiques
|
|
|
|
|
|
|
|
La suite décrit rapidement l’ensemble des opérateurs utilisables en Java, assez similaires à ceux utilisés en C.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="opérateurs-arithmétiques-et-priorités"></a>
|
|
|
|
## 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) :
|
| ... | ... | @@ -168,6 +182,7 @@ Les priorités sont les suivantes : |
|
|
|
|
|
|
|
> :warning: L’associativité s’effectue de gauche à droite pour des opérateurs de même priorité.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="opérateurs-relationnels-et-logiques-et-priorités"></a>
|
|
|
|
## Opérateurs relationnels et logiques et priorités
|
|
|
|
|
|
|
|
Les opérateurs relationnels sont au nombre de six :
|
| ... | ... | @@ -197,8 +212,10 @@ Le langage Java comporte enfin trois opérateurs logiques : |
|
|
|
|
|
|
|
> :warning: La négation logique est l’opérateur le plus prioritaire. Les priorités des autres opérateurs sont identiques et l’associativité s’effectue de gauche à droite.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="instructions-de-contrôle"></a>
|
|
|
|
# Instructions de contrôle
|
|
|
|
|
|
|
|
<!-- TOC --><a name="ifelse"></a>
|
|
|
|
## _if/else_
|
|
|
|
|
|
|
|
L'instruction conditionnelle `if` / `else` est définie par :
|
| ... | ... | @@ -230,6 +247,7 @@ else |
|
|
|
|
|
|
|
> :pencil: s'il n'y a qu'une seule instruction dans le bloc `if` ou dans le bloc `else`, l'utilisation des accolades n'est pas obligatoire.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="switch"></a>
|
|
|
|
## _switch_
|
|
|
|
|
|
|
|
La construction `switch` permet d’exprimer une liste de décisions. Sa syntaxe est la suivante :
|
| ... | ... | @@ -281,6 +299,7 @@ L’étiquette `default` permet de spécifier un **comportement par défaut**, l |
|
|
|
```
|
|
|
|
3
|
|
|
|
```
|
|
|
|
<!-- TOC --><a name="boucle-for"></a>
|
|
|
|
## Boucle _for_
|
|
|
|
|
|
|
|
La syntaxe de la boucle `for` est identique à celle de C :
|
| ... | ... | @@ -303,6 +322,7 @@ for(int answer=0;i<=42;index++) { |
|
|
|
}
|
|
|
|
```
|
|
|
|
|
|
|
|
<!-- TOC --><a name="boucle-while-et-do-while-"></a>
|
|
|
|
## Boucle `while` et `do while` :
|
|
|
|
|
|
|
|
La syntaxe des boucles `while` est identique à celle de C :
|
| ... | ... | @@ -324,6 +344,7 @@ while (expression); |
|
|
|
|
|
|
|
> :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`).
|
|
|
|
|
|
|
|
<!-- TOC --><a name="instructions-break-et-continue"></a>
|
|
|
|
## Instructions `break` et `continue`
|
|
|
|
|
|
|
|
Ces deux instructions sont des instructions de **rupture de flot de contrôle**.
|
| ... | ... | @@ -332,10 +353,12 @@ Ces deux instructions sont des instructions de **rupture de flot de contrôle**. |
|
|
|
|
|
|
|
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.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="rocket-pour-aller-plus-loin-"></a>
|
|
|
|
# :rocket: Pour aller plus loin ...
|
|
|
|
|
|
|
|
La suite contient des compléments, non indispensables immédiatement, pour les curieux avides de détails.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="types-implicites-des-expressions-entières-et-flottantes-transtypage"></a>
|
|
|
|
## 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 pose problème si on essaie de l’affecter à une variable de type `byte`.
|
| ... | ... | @@ -348,6 +371,7 @@ L'instruction `byte aByte = 4;` est par exemple rejetée par le compilateur car |
|
|
|
|
|
|
|
Pour corriger le problème, on écrira `byte aByte = (byte) 4;`.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="commentaires"></a>
|
|
|
|
## Commentaires
|
|
|
|
|
|
|
|
Les commentaires en Java ont la même syntaxe qu'en C :
|
| ... | ... | @@ -355,10 +379,12 @@ Les commentaires en Java ont la même syntaxe qu'en C : |
|
|
|
- `//` pour un commentaire de **fin de ligne**
|
|
|
|
- `/*` ... `*/` pour un commentaire **multi-lignes**
|
|
|
|
|
|
|
|
<!-- TOC --><a name="le-mot-clé-void"></a>
|
|
|
|
## 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**.
|
|
|
|
|
|
|
|
<!-- TOC --><a name="unicode"></a>
|
|
|
|
## 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).
|
| ... | ... | |
