Next: 2. Opérations et expressions
Up: I. Java: Le langage
Previous: I. Java: Le langage
Sous-sections
1.1 Le jeu de caractères Unicode
Le langage Java est destiné à être utilisé sur Internet. Il est donc naturel
que celui se préoccupe des jeux de caractères internationaux. Le jeu
de caractères utilisé dans Java est celui connu sous le nom de
Unicode. Ce jeu de caractère est codé sur 16 bits (au lieu de 7
bits du code ASCII, et 8 bits pour Latin-1), les 256 premiers
caractères sont ceux du jeu de caractères Latin-1. Ce jeu de
caractères étendu est prévu pour coder l'ensemble de tous alphabets
internationaux (japonais, chinois, arabe,
hindi, etc.)
Pour l'heure, ne disposant pas d'éditeurs de texte permettant de
visualiser le jeu de caractère Unicode, les caractères non Latin-1
seront notés par des séquences d'échappement de la forme
\unnnn. Ces caractères peuvent être utilisés dans presque
toutes les parties d'un programme Java : commentaire, nom de
variables ou méthodes, nom de classes etc.
Tableau 1.1:
Le standard Unicode
| Début |
Fin |
Alphabet |
| 0020 |
007E |
Latin (US) |
| 00A0 |
00FF |
Latin-1 (Supplément) |
|
...
|
...
|
...
|
| 05D0 |
05EA |
Hébreu |
|
...
|
...
|
...
|
| 0B80 |
0BFF |
Tamoul |
|
...
|
...
|
...
|
| 4E00 |
9FFF |
Les idéogrammes unifiés (chinois, japonais, coréen, .) |
|
1.2 Les commentaires
Tout programme (grand ou petit, simple ou
complexe) contient (ou devrait contenir) des commentaires. Ils ont
pour but d'expliquer ce qu'est sensé faire le programme, les
conventions adoptées et tout autre information rendant le programme
lisible à soi même et surtout à autrui. Java dispose de trois types
de commentaires : les commentaires multilignes, les
commentaires lignes et les commentaires de type
documentation. On peut utiliser n'importe quel caractère Unicode
dans ces trois types de commentaires.
Les commentaires lignes débutent avec les symboles
``//'' et qui se terminent à la fin de la ligne. Ils sont
utilisés pour des commentaires courts qui tiennent sur une ligne.
// Ce programme imprime la chaîne
// de caractères " bonjour " à l'écran
...
Un commentaire multiligne
commence par les caractères ``/*'' et se terminent par
``*/''. A l'intérieur de ces délimiteurs toute suite de
caractères est valide (sauf évidemment ``*/'').
/* Ce programme imprime la chaîne
de caractères "bonjour" à l'écran
*/
1.2.3 La documentation
Enfin, un texte encadré entre ``/**'' et ``*/''
servira à produire automatiquement (avec l'outil javadoc) la
documentation sous forme HTML à l'image de la documentation
officielle de SUN. Ces commentaires servent à documenter les
classes que l'on définit. Java exige donc qu'ils figurent avant la
définition de la classe, d'un membre de la classe ou d'un
constructeur. Vous trouverez en annexe (1), des
informations plus détaillées sur javadoc.
/** Documentation de la classe .
*/
1.3 Les identificateurs
Comme dans tout langage de programmation, les
identificateurs servent à désigner des variables, des
constantes, des noms de méthodes etc. On appelle identificateur
toute suite de lettres ou chiffres commençant par une lettre ; une
lettre est un caractère alphabétique ou le caractère '_' ou le
caractère '$'. Voici des exemples d'identificateurs :
toto toto123 _toto $toto \u5678toto
Parmi tous les
identificateurs, il en existe certains qui sont réservés (voir
figure 1.2) i.e. qu'ils ont un sens prédéfini
pour le langage Java et que le programmeur ne peut utiliser
comme identificateurs.
Tableau 1.2:
Mots clés réservés
| abstract |
double |
int |
super |
| boolean |
else |
interface |
switch |
| break |
extends |
long |
synchronized |
| byte |
final |
native |
this |
| case |
finally |
new |
throw |
| catch |
float |
package |
throws |
| char |
for |
private |
transient |
| class |
goto |
protected |
try |
| const |
if |
public |
void |
| continue |
implements |
return |
volatile |
| default |
import |
short |
while |
| do |
instanceof |
static |
|
|
Outre ces mots clés, il existe trois identificateurs (qui sont des
constantes symboliques) sont également réservés : null,
true et false.
1.4 Les types de données élémentaires
Le langage Java est un
langage fortement typé ; chaque variable et chaque expression possède
un type bien défini, et ce, dès l'écriture du programme. La donnée de
ces types permet de restreindre les valeurs qu'une variable est
susceptible de contenir et de donner une signification aux opérations.
Les types de données de Java sont divisés en deux grands groupes :
les types primitifs (ou de base) et le type référence.
Les types primitifs sont constitués des types numériques (type entier
et type flottant) et du type booléen.
Le type entier se compose des
types suivants :
- byte :
- les entiers codés sur 8 bits (de -128 à 127)
- char :
- les caractères Unicode codés sur 16 bits (de
\u0000 à \uffff )
- short :
- les entiers codés sur 16 bits (de -32768 à
32767)
- int :
- les entiers codés sur 32 bits (de -2147483648 à
2147483647)
- long :
- les entiers codés sur 64 bits (de
-9223372036854775808 à 9223372036854775807)
Le type flottant se compose des types suivants :
- float :
- les nombres en virgule flottante sur 32 bits
(IEEE 754-1985)
- double :
- les nombres en virgule flottante sur 64 bits
(IEEE 754-1985)
Le type booléen (boolean) est constitué des
constantes littérales true ou false.
Le type référence se décompose en trois sous types : le type
classe, le type interface et le type
tableau.
1.5 Les constantes littérales
Nous avons présenté les divers types de données
élémentaires du langage Java sans dire comment écrire une constante
de l'un de ces types dans un programme Java. Nous allons à présent
donner la syntaxe utilisée dans le langage Java pour désigner des
constantes littérales .
1.5.1 Constantes booléennes
Les seules constantes possibles sont
les identificateurs true et false.
1.5.2 Constantes entières
Les constantes entières peuvent
s'exprimer
- En notation décimale : 123, -123, etc. Excepté
le zéro, aucune constante en notation décimale ne commence par
0.
- En notation octale avec un 0 en première position :
0123
- En notation hexadécimale avec les caractères 0x ou
0X en première position : 0x1b, 0X2c,
0X1B, 0X2C, etc.
Le type d'une constante entière est toujours de type int. Les suffixes
L et l permettent de préciser qu'une constante
entière est de type long.
1L, 0x7FFL, 0x0fffffffffffffffL, 16L, etc.
représentent des constantes entières de type long.
1.5.3 Constantes flottantes
Une constante
flottante se présente sous la forme d'une suite de chiffres
(partie entière), un point qui joue le rôle de virgule, une
suite de chiffres (partie fractionnaire), une des deux lettres
e ou E, éventuellement le signe + ou
- et suivi d'une suite de chiffres (valeur absolue de
l'exposant). La partie entière ou la partie fractionnaire peut
être omise (pas les deux) ; de même le point ou l'exposant peut être
omis (pas les deux).
Une constante flottante est supposée être de type double. Le
suffixe F ou f permet de transformer le type de la
constante en type float. Le suffixe D ou d indique
qu'elle est de type double. Le plus grand nombre flottant
(float) positif est 3.40282347e+38f. Le plus petit
nombre flottant (float) positif (non nul) est
1.40239846e-45f. Le plus grand nombre flottant
(double) positif est 1.79769313486231570e+308. Le
plus petit nombre flottant (double) positif (non nul) est
4.94065645841246544e-324.
.5e7, 5.e6, 5e6, 1e1f
Une constante double ne peut être affectée à une variable
de type float que si elle est convertie explicitement en
float.
1.5.4 Constantes de type caractères
Les constantes de type caractère sont constituées d'un caractère ou
d'une séquence d'échappement encadré par des apostrophes ("'"). Le
caractère ' se note \' et le caractère \ se
note \\. Les caractères non ISO-Latin-1 se note à l'aide
de séquences d'échappement .
'a' '%' '\\t' '\\\\' '\\'' '\\u03a9' '\\uFFFF' '\\177'
Voici une liste non exhaustive de séquences d'échappement :
Séquence
Tableau 1.3:
Séquences d'échapemment
\n |
nouvelle ligne |
\t |
tabulation horizontale |
\b |
retour d'un caractère en arrière |
\r |
retour chariot |
\f |
saut de page |
\a |
beep |
\' |
apostrophe |
\" |
guillemets |
\\ |
anti-slash |
\ddd |
en notation octale |
\udddd |
en notation unicode |
|
1.5.5 Constantes de type chaîne
Une chaîne de
caractères est une suite de caractères (éventuellement vide) entre
guillemets. Il en découle que l'on est autorisé à utiliser les
séquences d'échappement dans les chaînes. La fonction
System.out.print("Bonjour\n\tComment ca va ? "\n) ;
produit la sortie suivante :
Bonjour
Comment ca va ?
Une constante chaîne de caractère doit être écrite sur une seule
ligne. Lorsqu'il est trop long pour tenir sur une même ligne, on
découpe celle-ci en deux et on les concatène avec l'opérateur
+ qui est l'opérateur de concaténation de chaînes. Les
deux instructions suivantes sont équivalentes.
x = "abcdefghijklmnopqrstuvwxyz" + "ABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
x = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" ;
Le type null admet une constante null servant à
désigner une référence non définie.
En Java, toute variable utilisée dans un programme doit auparavant
être définie. La définition d'une variable consiste à la nommer, lui
donner un type et éventuellement lui donner une valeur initiale (on
dira initialiser). C'est cette définition qui réserve (on dira alloue)
la place mémoire nécessaire et ce en fonction du type. Une variable
n'est rien d'autre qu'un emplacement mémoire d'une taille suffisamment
grande pour contenir une valeur d'un type donné.
Initialiser une variable consiste à
remplir, avec une constante, l'emplacement réservé à cette variable.
Cette opération s'effectue avec l'opérateur =. On pourra
également (de manière optionnelle) donner un ``qualifier'' à une
variable : le mot clé final, par exemple, précise la valeur
de la variable ne sera pas modifiée dans le programme. Il existe, bien
entendu, d'autres qualifier que nous verrons plus tard.
int x = 2 ;
char c = 'c' ;
double d = 1.3 ;
final float f = 1.2f ;
Le type d'une variable est soit un type primitif soit une
référence. La valeur d'une variable sera modifiée par une
affectation. Une variable de type primitif contient toujours une
valeur de son type. Une variable de type référence contient soit
une référence null soit une référence vers un objet dont le type
est compatible avec le type de la variable.
Les déclarations de variables peuvent figurer n'importe où dans le
corps d'une méthode. Il n'est pas nécessaire de placer ces définitions de
variables au début d'une méthode, d'une classe ou d'un bloc
d'instructions.
Chaque variable possède une visibilité et une durée de vie.
On distingue 7 natures de variables :
- les variables d'instance (4)
- les variables de classe (4.2)
- les variables de type tableau (9)
- les paramètres des méthodes (4.1.2)
- les paramètres des constructeurs (4.1.4)
- les variables de type exception (8)
- les variables locales
1.6.2 Variables locales
Une variable locale est une variable qui est définie à l'intérieur
d'une méthode. Il n'est pas nécessaire que cette déclaration figure en
début de bloc. Comme en C++, les variables locales sont visibles à
partir de leur définition jusqu'à la fin du bloc le plus interne qui
contient cette définition. Leur durée de vie est limitée à au bloc qui
contient la déclaration
...
for (int i = 0 ; i != 0 ; i = i + 1) {
... // variable i visible dans tout ce bloc
}
...
1.6.3 Variables globales ?
Toute définition de variables figure forcément à l'intérieur d'une
déclaration de classe. Contrairement au langages C et C++, le concept
de variables globales n'existe pas. Il n'y a que des variables
statiques ou de classe qui sont l'équivalent (sous certaines
conditions) de nos habituelles variables globales. Toutefois, leur
visibilité dépend des qualifiers associés à la variable et à la classe
dans laquelle elle est définie. Par contre, sa durée de vie commence
au chargement de la classe qui contient sa définition et se termine à
la fin de l'exécution du programme.
public class X {
...
public static int varGlobale=100 ;
...
}
Dans ce exemple, la variable varGlobale est l'équivalent d'une
variable globale. Elle est visible de n'importe quelle partie du
programme. Ce sont les qualifiers public qui permettent d'étendre
ainsi leur visibilité. Nous verrons tout cela en détail dans les
chapitres consacrés aux classes, à l'héritage, aux interfaces et
aux packages.
Next: 2. Opérations et expressions
Up: I. Java: Le langage
Previous: I. Java: Le langage
Touraivane
1998-11-06