Editions ENI Livres | Vidéos | e-Formations
Éléments syntaxiques
Objectifs du chapitre
L’objectif de ce chapitre est de présenter les principaux éléments syntaxiques du langage, en insistant sur les caractéristiques particulières du langage Java par rapport au langage C.
Ce chapitre utilise des notions qui ne seront expliquées que dans les chapitres suivants. Ainsi, la méthode main() de la classe PremiereClasse comporte quelques mots-clés (public, static, throws) impossibles à expliquer correctement à ce niveau de l’exposé. Il est toutefois possible d’en admettre la syntaxe en attendant une explication complète.
Premier programme
1. Programme
// ==========================================================================
// PremiereClasse : elements syntaxiques
// ==========================================================================
import java.io.IOException;
import utilitairesMG.divers.Clavier;
public class PremiereClasse
{
public static void main(String argv[]) throws IOException
{
int i;
double x;
System.out.print("Saisir une valeur numerique : ");
x = Clavier.readDouble();
i = (int)x;
i++;
System.out.println("i : " + i);
}
}
Voici le résultat de l’exécution de ce programme :
Les sections suivantes expliquent ce programme.
2. La classe
Une classe est définie grâce au mot-clé class et contient le code compris dans le bloc (instructions entre { et }) suivant la déclaration : Public class PremiereClasse
Le code d’une classe publique NomClasse doit toujours se trouver dans le fichier NomClasse.java. Le code de la classe PremiereClasse est dans le fichier PremiereClasse.java....
Les commentaires
Java accepte deux formes de commentaires :
-
Le commentaire de ligne, signalé par les caractères //. Tous les caractères qui suivent // et qui sont sur la même ligne sont du commentaire.
-
Le commentaire qui débute par /* et se termine par */.
Exemple
// ==========================================================================
// PremiereClasse : elements syntaxiques
// ==========================================================================
. . .
javadoc.exe est un outil du JDK qui permet de générer la documentation d’une classe au format HTML. Il se base sur des commentaires particuliers insérés dans le code source de la classe. Ces commentaires commencent par /** et se terminent par */. Nous avons fait le choix de ne pas les utiliser dans cet ouvrage, car ils peuvent alourdir la lecture du code.
Les noms des identificateurs
Bien qu’elles ne soient pas imposées par le langage, certaines règles sont utilisées dans le choix des identificateurs d’un programme Java.
1. Variables, propriétés, méthodes
Les noms des variables, des propriétés, des méthodes sont écrits en minuscules, sauf s’ils sont formés de la juxtaposition de plusieurs mots, auquel cas chaque mot sauf le premier commence par une majuscule.
Exemples
x
readDouble()
nombreValeurs
nombreReponsesExactes
println(String s) Les noms de méthodes sont toujours suivis de parenthèses, même si la méthode n’a pas de paramètre. Exemples : afficheXY(), racineCarre(double valeurParametre).
Les noms des constantes (propriété avec l’attribut final) sont écrits entièrement en majuscule.
Exemple
Math.PI : PI est une constante de la classe Math (reconnaissable au M majuscule).
2. Classes
Les noms des classes suivent la même règle, mais leur première lettre est écrite en majuscule.
Exemples
PremiereClasse
System
Clavier
IOException Ces règles de nommage sont extrêmement pratiques pour faciliter la lecture du code.
Exemple : System.out.println(x);
System est une classe, out est une propriété, println est une méthode.
Les types de base
1. Entiers
Le type char est un entier de deux octets (au lieu de un octet en langage C). Il s’agit d’y stocker, non plus un code ASCII, mais le code d’un caractère UNICODE (codé en UTF-16).
Le type byte est un entier d’un octet.
2. Booléens
Une variable de type boolean ne peut prendre que deux valeurs : true (vrai) ou false (faux).
3. Flottants
Contrairement au langage C, les tailles des types de base ne dépendent pas de l’environnement d’exécution.
Quelques opérateurs
1. Opérateurs arithmétiques
+ - * / ( ) % Exemple
L’expression (a + b) % c additionne les variables a et b, puis calcule le reste de la division (modulo) de ce total par c.
2. Opérateurs de comparaison
> < <= >= == != Exemple
if (a == b)
{
Instructions;
}
Les instructions sont exécutées si a et b contiennent la même valeur. Attention au double signe "égal" !
3. Opérateurs d’affectation
= += -= Exemples
a = b; Recopie le contenu de b dans a.
a += b; Ajoute le contenu de b à celui de a.
4. Opérateurs logiques
&& ! || & | ˆ Exemple
if ((a == b) && (b != c))
{
Instructions;
}
Les instructions sont exécutées si a et b contiennent la même valeur ET si b et c contiennent des valeurs différentes.
5. Opérateurs ++ et --
L’opérateur ++ incrémente (augmente de 1) la valeur d’un entier. L’opérateur - la décrémente.
L’utilisation de ces opérateurs présente un danger : leur priorité change suivant que l’opérateur...
Structures logiques du langage Java
Les structures logiques de Java sont les mêmes que celles du langage C (cf. chapitre Initiation - Structures logiques).
En voici la liste :
if
if(expression)
{
instructions 1
}
else
{
instructions 2
}
switch
switch (expression)
{
case constante 1 : instructions 1
case constante 2 : instructions 2
. . . .
case constante n : instructions n
default : instructions
}
while
while(expression)
{
instructions
}
for
for (expression 1; expression 2; expression 3)
{
instructions
}
do while
do
{
instructions
}
while(expression);
break
L’exemple est le switch du langage C.
