IV - Le langage Java

IV - Le langage Java

Dans ce chapitre, nous allons étudier le langage Java, ou plus précisément, sa syntaxe et ses principales instructions.

En Java, il est possible de définir des commentaires sur une ou plusieurs lignes entre les caractères /* et */, ou sur une seule ligne en la précédant par //.

Exemple :

Commentaires

sur plusieurs

lignes

// Commentaire sur une seule ligne

Jusque là, Java ne fait pas preuve de beaucoup d'originalité. Cependant, nous avons parlé plus haut de l'utilitaire javadoc livré dans le JDK. Cet utilitaire permet de générer une documentation hypertexte en HTML à partir de commentaires insérés dans des fichiers sources Java.

Afin de faciliter la tache de Javadoc, Sun a défini une syntaxe particulière permettant de spécifier un certain nombre d'informations relatives à une classe ou une méthode comme sa signature (son nom, ses arguments, son type de retour et sa classe, nous en reparlerons).

Seuls les commentaires commençant par /** sont extraits par Javadoc. Entre /** et */, on peut bien sûr indiquer du texte mais également des tags HTML puisque javadoc génère un document en HTML.

Afin de pouvoir extraire sans ambiguïté les informations relatives à une fonction ou une classe, il est nécessaire de respecter la syntaxe de Javadoc à savoir, un mot clé précédé du caractère @, suivi de la valeur associée au mot clé. En voici quelques-uns :

@author texte-nom : permet de spécifier l'auteur d'une classe,

@version texte-version : pour indiquer la version,

@see nomclasse : utilisé pour faire référence (lien hypertexte) à une autre classe, ce mot clé pouvant être répété plusieurs fois,

@param nom-paramètre description : permet d'indiquer un argument d'une fonction avec un descriptif,

@return description : pour indiquer ce que retourne une fonction, etc.

Pour plus d'informations, consulter la documentation de Sun associée au JDK.

2. Types de données

Java est un langage typé, ce qui signifie qu'on doit impérativement définir le type d'une variable avant de pouvoir l'utiliser dans un programme.

Les types de base en Java sont les suivants :

entiers : il existe quatre types d'entier en Java, à savoir : byte (un octet, 8 bits), short (16 bits), int (32 bits) et long (64 bits). Il est important de noter que, contrairement à certains autres langages, la taille d'un entier est la même quelque soit la machine sur laquelle on exécute un programme, puisque c'est la JVM qui masque les spécificités du système hôte. A noter également que ces entiers sont signés.

réels : Java en définit deux, float (32 bits) et double (64 bits).

caractères : char (16 bits). Contrairement à la plupart des langages, Java code les caractères non pas en ASCII mais en UNICODE, sur 16 bits, ce qui permet de définir suffisamment de caractères pour un grand nombre de langues.

booléens : Le type boolean permet de déclarer une variable pouvant prendre deux valeur, soit true (vrai), soit false (faux).

Pour déclarer une variable, il suffit de spécifier un des types précités, suivi d'un nom de variable respectant les règles classiques des langages de programmation (lettres, chiffres et "_" autorisés, le premier caractère devant être une lettre, impossibilité d'utiliser comme nom de variable un mot clé réservé du langage).

Exemples :

int UnEntier;

char UnCaractere, UnDeuxiemeCaractere;

float UnReel;

A noter que chaque ligne d'instructions se termine par un point-virgule, comme en C.

Il convient d'apporter quelques précisons relatives à l'utilisation des variables en Java :

Toutes les variables doivent être initialisées explicitement avant leur utilisation. En effet, le compilateur n'attribue pas par défaut la valeur 0 aux variables non initialisées.

Les variables globales n'existent pas en Java. Rappelons qu'une variable globale est visible dans n'importe quel module d'un programme. On ne peut donc utiliser que des variables locales à une fonction ou à un bloc (nous en reparlerons).

Voyons maintenant ce que l'on peut faire avec ces variables.

3. Opérations sur des variables

La première opération que l'on peut appliquer à une variable déclarée en Java est de lui donner une valeur. Cette valeur peut être soit une constante, comme 23, soit le résultat d'une expression comportant des constantes et/ou d'autres variables. L'opérateur d'affectation est le =.

Exemples :

int entier = 23,

entier2 = 23 - entier; // entier2 = 0

Java reconnaît presque tous les opérateurs arithmétiques du C, comme +, -, *, /, les opérateurs d'affectation combinés comme += (a += 2 est équivalent à a = a+2), les opérateurs unaires d'incrémentation (a++ équivaut à a = a+1, de même que ++a, mais dans ce dernier cas, comme en C, la valeur renvoyée est celle de la variable a après incrémentation, alors que dans le premier cas, on obtient la valeur avant incrémentation; idem pour --), les comparaisons (>, >= etc.), les opérations logiques (||, OU logique, &&, ET logique, etc.) et les opérateurs binaires comme & (ET logique bit à bit), | (OU), >> (décalage à droite),...Il existe cependant un nouvel opérateur, qui est nouveau par rapport au C, à savoir >>>, qui fait un décalage à droite en insérant des 0 à gauche.

Etudions maintenant les instructions permettant de modifier l'ordre d'exécution d'un programme ou d'effectuer des opérations conditionnelles.

4. Structures conditionnelles et boucles

Java reprend les structures traditionnelles du C(++), à savoir les if..else, le switch...case, les boucles du type while ou do while et for (boucle indexée). Voici la syntaxe générale de ces instructions.

if (condition)

{

// instruction ou bloc exécuté si la condition est

// vraie

}

[else if (condition2)

{

// ...

}]

[else

{

// instruction ou bloc exécuté si aucune des

// conditions précédentes n'est vérifiée

}]

Remarques :

Quand une structure est optionnelle, nous l'avons mise entre crochets. C'est donc le cas du else if et du else.

Lorsque plus d'une instruction doivent être exécutées si une condition est vérifiée ou non, ces instructions doivent être mises dans un bloc entre { et }. Un tel bloc est équivalent à une instruction unique.

L'opérateur d'égalité est comme en C le == (!= pour différent de).

Une expression de condition (après le if) doit obligatoirement renvoyer une valeur de type booléen. En clair, on ne peut utiliser le résultat d'un calcul ou la valeur d'une variable.

Par exemple, si i est un entier, on peut écrire en Java comme en C :

int i=1;

if (i==1)

// faire quelque chose

Par contre, l'expression suivante est interdite en Java mais pas en C :

if (i) // vrai si i est supérieur à 1

// faire quelque chose

Cette différence est due au fait qu'il n'existe pas de type booléen en C.

Voyons la structure d'un switch :

switch (expression)

{

case valeur1 : instruction(s) ; break ;

// on exécute les instructions si

// expression = valeur1 puis on quitte (break)

case valeur2 : instruction(s) ; break ;

// on exécute les instructions si

// expression = valeur2 puis on quitte (break)

// ...

default : instruction(s);

// on exécute les instructions si aucune valeur ne

// convient

}

Le mot clé break permet de sortir d'un case. Si on ne le met pas, on continue à vérifier l'égalité de l'expression et des valeurs associées aux cases suivants. A noter qu'on ne peut utiliser cette structure conditionnelle qu'avec des entiers ou des caractères (indiqués entre apostrophes ', soit 'a' par exemple).

En ce qui concerne les boucles, voici leurs structures respectives.

while (condition)

{

// on exécute les instructions de ce bloc tant que

// la condition est vraie

}

{

// idem que ci-dessus mais les instructions de ce

// bloc sont exécutées au moins une fois, que la

// condition, en fin de boucle, soit vraie ou non

} while (condition);

for (init; expression_test; incrémentation)

{

// bloc exécuté tant que la condition est vraie

}

Dans le dernier cas, on définit trois expressions : une initialisation de la valeur de départ de l'index de la boucle (ex: i=1), une condition de test devant être vérifiée pour que l'itération suivante de la boucle soit effectuée (ex : i <= 10) et une expression d'incrémentation de la variable compteur (ex: i++).

Exemple:

for (i=1; i <= 10; i++)

// faire quelque chose

Quelques autres instructions Java permettent de modifier l'exécution d'une boucle comme continue qui interrompt l'itération courante (i.e. les instructions qui suivent le continue ne sont pas exécutées) et provoque un saut à l'itération suivante (avec vérification des conditions éventuelles), ou break, qui, comme nous l'avons vu, permet de sortir d'une boucle (i.e. les instructions qui suivent la boucle seront alors exécutées). En Java, il n'y a pas de gotos mais il est possible de spécifier un label en argument de l'instruction break afin de préciser l'endroit à partir duquel on veut poursuivre l'exécution.

Nous avons terminé de présenter le langage Java et sa syntaxe, abordons maintenant le monde de la programmation orientée objet.