Skip to content

Changes

Page history
Update Eléments de syntaxe du langage Java authored by Sebastien Jean's avatar Sebastien Jean
Hide whitespace changes
Inline Side-by-side
Eléments-de-syntaxe-du-langage-Java.md
View page @ 3598b1a2
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, ...
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
En Java, le terme **primitif** se rapporte aux types de données qui peuvent avoir une réprésentation immédiate en mémoire :
- un entier
- un réel
- un flottant (nombre réel)
- un booléen
- un caractère
Les **tableaux** ne sont pas des types primitifs, mais ne peuvent pas non plus être considérés complètement comme des types objets.
Tous les autres types sont **objets**.
> Les **tableaux** ne sont pas des types primitifs, mais ne peuvent pas non plus être considérés complètement comme des types objets. Tous les autres types sont **objets**.
Les valeurs de type primitif ont une taille indépendante de la plateforme d’exécution du code.
......@@ -25,28 +27,31 @@ Le tableau ci-dessous récapitule les types entiers, leur taille et leurs valeur
| int | 32 |-2^31 | 2^31 - 1 |
| long | 64 |-2^63 | 2^63 - 1 |
> :warning: Contrairement au langage C, tous les types entiers sont **signés** (les nombres négatifs sont codés en complément à 2).
> :warning: Contrairement au langage C, tous les types entiers sont **signés** (les nombres négatifs sont codés en [complément à 2](https://fr.wikipedia.org/wiki/Complément_à_deux)).
> :pencil: Comme en langage C, on peut exprimer un entier (par exemple 15) en décimal (`15`), en octal (`017`) ou en hexadécimal (`0x0F`).
Le tableau suivant donne les mêmes informations que le précédent pour les types flottants (codés conformément à la norme _IEEE 754_).
Le tableau suivant donne les mêmes informations que le précédent pour les types flottants (codés conformément à la norme [_IEEE 754_](https://fr.wikipedia.org/wiki/IEEE_754)).
Deux notations sont utilisables : décimale (`-3.25`) ou exponentielle (`-3.232323E-12`, le `E` peut être aussi écrit `e`).
| Type | Taille (en bits) | Chiffres significatifs | Valeur positive minimale | Valeur positive maximale |
| ------ | ------ | ------ | ------ | ------ |
| float | 32 | 7 | 1.423984E-45 | 3.402823E38|
| double | 32 | 15 | 4.94065645841246E-234 | 1.79769313486231E308 |
| double | 64 | 15 | 4.94065645841246E-234 | 1.79769313486231E308 |
:rocket: Pour en savoir plus, voir `Types implicites des expressions entières et flottantes, transtypage` dans la section `Pour aller plus loin`
## 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**.
Le type **booléen** est désigné par le mot-clé `boolean` et représente un **état logique vrai ou faux**.
Une valeur booléenne ne peut être égale qu'à une des **2 valeurs prédéfinies** : `true` et `false`.
Il existe deux constantes qui peuvent être valeurs d’une variable de type booléen : `true` et `false`.
Le type **caractère** est désigné par le mot-clé `char`. Un caractère est codé sur 16 bits, sa valeur est le **code _[Unicode](https://fr.wikipedia.org/wiki/Unicode) UTF-16_** du caractère.
Le type caractère est désigné par le mot-clé `char`. Un caractère est codé sur 16 bits, sa valeur est le code Unicode UTF-16 du caractère.
:rocket: Pour en savoir plus, voir `Unicode` dans la section `Pour aller plus loin`.
On peut désigner une valeur de type `char` :
......@@ -59,11 +64,7 @@ Il est possible d'effectuer des opérations arithmétiques sur des caractères p
Le type tableau est désigné par le **type de ses éléments suivi de `[]`**.
Par exemple, `byte[]` représente un tableau d’octets.
## Le mot-clé `void`
`void` n'a pas la même interprétation que dans le langage C. Il est utilisé uniquement en **valeur de retour de méthode** pour indiquer que la méthode ne renvoie pas de résultat.
Par exemple, `byte[]` représente un le type _tableau d’octets_.
# Déclaration de variables, affectation
......@@ -71,6 +72,8 @@ Par exemple, `byte[]` représente un tableau d’octets.
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.
> :pencil: Une instruction élémentaire (déclaration de variable, affectation, appel de méthode, ...) doit être terminée par un **point-virgule**.
Il est possible de déclarer une variable n’importe où à l’intérieur d’un **bloc d’instructions** (délimité par `{}`).
```java
......@@ -87,7 +90,7 @@ public static void main(String[] args) {
```java
public static void main(String[] args) {
int answer = 42;
int answer = 42;
}
```
......@@ -175,8 +178,6 @@ La négation logique est l’opérateur le plus prioritaire. Les priorités des
# Instructions de contrôle
> :warning: une instruction élémentaire (affectation, déclaration, appel de méthode, . . .) en Java doit être terminée par un **point-virgule**.
## _if/else_
L'instruction conditionnelle `if` / `else` est définie par :
......@@ -291,13 +292,38 @@ 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.
> : warning: Une valeur immédiate entière (résultat d'un calcul par exemple) est implicitement de type **`int`**, ce qui peut poser problème si on essaye de l’affecter à une variable de type `byte`.
# :rocket: Pour aller plus loin ...
La suite contient des compléments, non indispensables immédiatement, pour les curieux avides de détails.
## 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 **flottante** est implicitement de type **`double`**, ce qui pose problème si on essaye 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.
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]).
Pour corriger le problème, on écrira `byte aByte = (byte) 4;`.
```
## Commentaires
Les commentaires en Java ont la même syntaxe qu'en C :
- `//` pour une 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.
:warning: Une valeur immédiate flottante est implicitement de type **`double`**, ce qui peut poser problème si on essaye de l’affecter à une variable de type `float`.
## Unicode
En langage C, ce genre de problème se règle par un forçage de type (aussi appelé transtypage ou cast). Il en est de même en Java, le cast ayant la même syntaxe, consistant à faire précéder la valeur du type compatible entre parenthèses. Dans le cas du cast en float, il existe une abbréviation qui consiste à rajouter uniquement la lettre f derrière la valeur flottante (-3,2E-4f).
[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).
Commentaires.
1. 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.