next up previous contents index
Next: 2. Opérations et expressions Up: I. Java: Le langage Previous: I. Java: Le langage

Sous-sections


1. Eléments de base

 

     
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

1.2.1 Les commentaires multilignes

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.

1.2.2 Les commentaires lignes

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 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" ;

1.5.6 La constante null

      Le type null admet une constante null servant à désigner une référence non définie.

1.6 Les variables

  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.

1.6.1 Nature des variables

On distingue 7 natures de variables :

   
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 up previous contents index
Next: 2. Opérations et expressions Up: I. Java: Le langage Previous: I. Java: Le langage
Touraivane
1998-11-06