La structure fondamentale du langage¶
La syntaxe du langage Java est à l’origine très inspirée du C et du C++. Ces deux langages de programmation ont également servi de base au C#. Donc si vous connaissez C, C++ ou C# vous retrouverez en Java des structures de langage qui vous sont familières.
Les instructions¶
Java est un langage de programmation impératif. Cela signifie qu’un programme Java se compose d’instructions (statements) décrivant les opérations que la machine doit exécuter. En Java une instruction est délimitée par un point-virgule.
double i = 0.0;
i = Math.sqrt(16);
Le typage¶
Un type permet d’indiquer au programme les valeurs que peuvent prendre une variable, un paramètre ou un attribut. Java est un langage fortement typé. Lorsque l’on déclare une variable un paramètre ou un attribut, il est obligatoire de préciser son type. Par exemple :
int i;
L’instruction précédente est la déclaration d’une variable i. Le type est toujours
indiqué à gauche du nom de la variable (c’est également le cas pour les paramètres
et les attributs). Dans l’exemple précédent, la variable i est déclarée comme
étant du type int
, c’est-à-dire qu’elle représente la valeur d’un nombre entier.
En déclarant le type, le programmeur restreint le type de données que peut représenter
cette variable. Ainsi, le compilateur va pouvoir signaler une erreur si jamais une
instruction dans le reste du programme tente d’affecter une valeur qui n’est pas
adéquate.
int i = 0;
i = "bonjour"; // ERREUR : on tente d'affecter une chaîne de caractères
// à une variable qui représente un nombre
On dit que le typage en Java est fort car une fois que l’on a déclaré une variable (ou un paramètre ou un attribut) avec un type, il n’est plus possible de modifier cette déclaration.
Le type est également vérifié par la machine virtuelle au moment de l’exécution du programme. Le langage Java supporte donc le typage statique (vérification réalisée au moment de la compilation) et le typage dynamique (vérification réalisée au moment de l’exécution).
Note
Depuis Java 10, il est possible d’utiliser l’identifiant var
à la place du type :
var i = 0;
Lorsque que le compilateur rencontre une instruction comme la précédente, il
détermine le type de la variable en fonction de la valeur d’initialisation (indiquée après
le signe égal). Pour l’exemple précédent, comme on affecte 0 à la variable i,
le compilateur déduit que le type de cette variable est int
(on dit qu’il
infère le type). Cette syntaxe permet d’éviter la répétition quand le type
est évident.
Comme l’inférence de type repose sur la valeur d’initialisation, var
est limité
à la déclaration de variables précisant une valeur d’initialisation.
Les blocs de code¶
Java permet de structurer le code en bloc. Un bloc est délimité par des accolades. Un bloc permet d’isoler par exemple le code conditionnel à la suite d’un if mais il est également possible de créer des blocs anonymes.
double i = 0.0;
i = Math.sqrt(16);
if (i > 1) {
i = -i;
}
{
double j = i * 2;
}
Un bloc de code n’a pas besoin de se terminer par un point-virgule. Certains outils émettent un avertissement si vous le faites.
Les commentaires¶
Un commentaire sur une ligne commence par // et continue jusqu’à la fin de la ligne :
// ceci est un commentaire
double i = 0.0; // ceci est également un commentaire
Un commentaire sur plusieurs lignes commence par /* et se termine par */ :
/* ceci est un commentaire
sur plusieurs lignes */
double i = 0.0;
Il existe un type spécial de commentaires utilisé par l’utilitaire javadoc. Ces commentaires servent à générer la documentation au format HTML de son code. Ces commentaires, appelés commentaires javadoc, commencent par /** :
/**
* Une classe d'exemple.
*
* Cette classe ne fait rien. Elle sert juste à donner un exemple de
* commentaire javadoc.
*
* @author David Gayerie
* @version 1.0
*/
public class MaClasse {
}
Le formatage du code¶
Le compilateur Java n’impose pas de formatage particulier du code. Dans la mesure où une instruction se termine par un point-virgule et que les blocs sont délimités par des accolades, il est possible de présenter du code de façon différente. Ainsi, le code suivant :
double i = 0.0;
i = Math.sqrt(16);
if (i > 1) {
i = -i;
}
est strictement identique pour le compilateur à celui-ci :
double i=0.0;i=Math.sqrt(16);if(i>1){i=-i;}
Cependant, le code source est très souvent relu par les développeurs, il faut donc en assurer la meilleure lisibilité. Les développeurs Java utilisent une convention de formatage qu’il faut respecter. Des outils comme Eclipse permettent d’ailleurs de reformater le code (sous Eclipse avec le raccourci clavier MAJ + CTRL + F). Rappelez-vous des conventions suivantes :
// On revient à la ligne après une accolade (mais pas avant)
if (i > 0) {
// ...
}
// On revient systématiquement à la ligne après un point virgule
// (sauf) dans le cas de l'instruction for
int j = 10;
for (int i = 0; i < 10; ++i) {
j = j + i;
}
// Dans un bloc de code, on utilise une tabulation ou des espaces
// pour mettre en valeur le bloc
if (i > 0) {
if (i % 2 == 0) {
// ...
} else {
// ...
}
}
// On sépare les variables des opérateurs par des espaces
i = i + 10; // plutôt que i=i+10
Les conventions de nommage¶
Chaque langage de programmation et chaque communauté de développeurs définissent des conventions sur la façon de nommer les identifiants dans un programme. Comme pour le formatage de code, cela n’a pas d’impact sur le compilateur mais permet de garantir une bonne lisibilité et donc une bonne compréhension de son code par ses pairs. Les développeurs Java sont particulièrement attachés au respect des conventions de nommage.
Type |
Convention |
Exemple |
---|---|---|
Packages |
Un nom de package s’écrit toujours en minuscule. L’utilisation d’un _ est tolérée pour représenter une séparation. |
java.utils com.company.extra_utils |
Classes et interfaces |
Le nom des classes et des interfaces ne doivent pas être des verbes. La première lettre de chaque mot doit être en majuscule (écriture dromadaire). |
MyClass SuppressionClientOperateur |
Annotations |
La première lettre de chaque mot doit être une majuscule (écriture dromadaire). Il est toléré d’écrire des sigles intégralement en majuscules. |
@InjectIn @EJB |
Méthodes |
Le nom d’une méthode est le plus souvent un verbe. La première lettre doit être en minuscule et les mots sont séparés par l’utilisation d’une majuscule (écriture dromadaire). |
run() runFast() getWidthInPixels() |
Variables |
La première lettre doit être en minuscule et les mots sont séparés par l’utilisation d’une majuscule (écriture dromadaire). Même si cela est autorisé par le compilateur, le nom d’une variable ne doit pas commencer par _ ou $. En Java, les développeurs n’ont pas pour habitude d’utiliser une convention de nom pour différencier les variables locales des paramètres ou même des attributs d’une classe. Le nom des variables doit être explicite sans utiliser d’abréviation. Pour les variables « jetables », l’utilisation d’une lettre est d’usage (par exemple i, j ou k) |
widthInPixels clientsInscrits total |
Constantes |
Le nom d’une constante s’écrit intégralement en lettres majuscules et les mots sont séparés par _. |
LARGEUR_MAX INSCRIPTIONS_PAR_ANNEE |
Les mots-clés¶
Comme pour la plupart des langages de programmation, il n’est pas possible d’utiliser comme nom dans un programme un mot-clé du langage. La liste des mots-clés en Java est :
abstract continue for new switch
assert default if package synchronized
boolean do goto private this
break double implements protected throw
byte else import public throws
case enum instanceof return transient
catch extends int short try
char final interface static void
class finally long strictfp volatile
const float native super while
_ (underscore)
Note
goto et const sont des mots-clés réservés mais qui n’ont pas de signification dans le langage Java.
Il existe également des mots réservés qui ne sont pas strictement des mots-clés du langage :
true false null