Précédent Remonter Suivant

Annexe H  Conventions d'écriture des programmes Java

Ce chapitre rassemble quelques règles usuelles de présentation de programmes en Java. Il est fortement inspiré du document Sun qu'on peut par exemple trouver au centre de référence Java1.

Il est important de noter que ces règles sont bien des conventions et ne font pas partie de la syntaxe de Java. Vous pouvez parfaitement écrire des programmes Java corrects mais illisibles ou très confus. Mais si une syntaxe correcte est nécessaire pour que la machine vous comprenne, une écriture claire et cohérente est nécessaire pour que d'autres humains vous comprennent !

H.1  Fichiers

Les noms de fichiers de source Java ont le suffixe .java. Les noms de fichiers compilés (bytecode) ont le suffixe .class.

Chaque fichier source Java contient une seule classe ou interface publique. Le nom du fichier (sans le suffixe .java) est obligatoirement le nom de cette classe ou interface publique. Si on y met des classes ou interfaces privées, la classe ou interface publique doit être la première à être définie dans le fichier.

On organisera le contenu de chaque fichier dans l'ordre suivant :

H.2  Indentation

Utiliser de préférence 4 espaces comme unité d'indentation. Règle de base : le niveau d'indentation correspond au degré d'imbrication.

Soyez cohérent dans vos alignements d'accolades ouvrantes et fermantes (utilisez partout la même convention). Le document SUN recommande de mettre l'accolade ouvrante à la fin de la ligne où commence le bloc concerné, et l'accolade fermante sur une ligne à part, indentée au niveau de l'instruction qui a entraîné l'ouverture du bloc, sauf pour les méthodes à corps vide, pour lesquelles l'accolade fermante suit immédiatement l'accolade ouvrante. Exemples :
class Test extends Object {
    int var1;
    int var2;

    Test(int i, int j) {
        var1 = i;
        var2 = j;
    }

    int methodeVide() {}

    void calculs() {
        ...
        if (var1 > 0) {
            var2--;
            ...
        }
        ...
        while (var1 != var2) {
            ...
        }
    }
    ...
}
Éviter les lignes trop longues (plus de 80 caractères), et souvenez-vous que vous pouvez toujours écrire une expression très longue sur plusieurs lignes. Dans ce cas, on cherchera à les couper aux endroits qui laissent la plus grande lisibilité : Quelques exemples :
fonc(expressionTresLongue1, expressionTresLongue2, expressionTresLongue3,
     expressionTresLongue4, expressionTresLongue5);

var = fonc1(expressionTresLongue1,
            fonc2(expressionTresLongue2,
                  expressionTresLongue3));

impotAPayer = ageDuCapitaine * (longueur + largeur - hauteur)
              + 4 * tailleChemise;
Pour les instructions if, s'il faut présenter la condition sur plusieurs lignes, indenter de 8 espaces au lieu de 4 pour que l'instruction qui suit reste lisible :
if ((condition1 && condition2)
        || (condition3 && condition4)
        || (condition5 && condition6)) {
    faireQuelqueChose()   // reste lisible
    ...
}

H.3  Commentaires

H.3.1  Commentaires de programmation

On les utilise soit pour "masquer" une partie du code, en cours de développement, soit pour expliquer certains détails de mise en oeuvre. Ils peuvent être mis sous la forme de l'un des styles suivants :
  1. Blocs de commentaires : servent à expliciter des fichiers, des méthodes, des structures de données et des algorithmes. Les précéder d'une ligne blanche, et les présenter comme suit :
    /*
     * Ceci est un bloc de commentaire.
     * Il peut comporter plusieurs lignes, chacune commençant par une
     * étoile entourée de deux espaces, pour la lisibilité de l'ensemble
     */
    


  2. Une ligne de commentaire : si votre commentaire ne tient pas sur une ligne, ne faites pas suivre deux lignes de commentaires ; utilisez de préférence un bloc de commentaires. Exemple de ligne de commentaire :
    if (condition) {
        /* Traiter le cas où tout va bien */
        ....
    }
    


  3. Commentaires de fin de ligne : ils peuvent prendre les deux formes /* ... */ ou // ..., la deuxième servant en outre à "masquer" une partie du code en cours de développement ou de déboguage. Exemples :
    if (a == 2) {
        return TRUE;      /* Cas particulier */
    }
    else if (toto > 1) {
        // Permuter les deux valeurs
        ...
    }
    else
        return FALSE;     // Explications
    
    // if (tata > 1) {
    //
    //    // Trois valeurs à permuter
    //    ...
    //}
    //else
    //    return FALSE;
    

H.3.2  Commentaires de documentation

Ces commentaires sont traités comme les autres par le compilateur, mais sont interprétés par l'outil javadoc, qui permet de créer des pages WWW de documentation de vos programmes. Pour une introduction à javadoc, voir son site de référence2, où vous trouverez aussi un manuel avec des exemples pour Windows. Un commentaire de documentation commence par /** et se termine par */. Exemples de commentaires de documentation :

H.4  Déclarations et instructions

Il est recommandé de ne mettre qu'une déclaration par ligne, et de regrouper les déclarations en début de bloc. Essayez d'initialiser les variables locales dès leur déclaration (il y a bien sûr des cas où cela est difficile ou impossible, comme quand l'initalisation dépend d'un calcul préalable).

Par souci de clarté, évitez de masquer des variables à un certain niveau par des variables de même nom à un niveau d'imbrication inférieur, comme dans :
int total;
...
fonction() {
    if (condition) {
        int total;       // à éviter !!
        ...
    }
    ...
}
Mettez une seule instruction par ligne ; évitez par exemple :
compte++; valeur -= compte;    // à éviter !!
N'utilisez des parenthèses avec l'instruction return que lorsqu'elles clarifient la lecture du code.

H.5  Noms

Choisissez toujours des noms significatifs et non ambigus quant au concept qu'ils désignent. Tenez-vous en à une des deux grandes règles de composition : majuscules à chaque nouveau mot de la composition (ageDuCapitaine) ou soulignés (age_du_capitaine). Dans le tableau suivant, nous choisissons la première.
Type Règles de nommage Exemples
Classes La première lettre doit être une majuscule. Éviter les acronymes, choisir des noms simples et descriptifs. class Image;
class ClientPrivilégié;
Interfaces Mêmes règles que pour les classes interface ImageAccesDirect;
interface Stockage;
Méthodes Les noms de méthodes (fonctions) doivent refléter une action. Choisir de préférence des verbes. Première lettre en minuscules. afficher();
getValue();
setValue();
Variables Première lettre en minuscules. Noms relativement courts mais descriptifs (mnémoniques). Éviter les noms à une lettre, sauf pour compteurs internes et variables temporaires. int i;
float largeur;
String nomDuCapitaine;
Constantes En majuscules. Le séparateur devient donc forcément un souligné. final static int VAL_MAX = 999;


1
href="http://java.sun.com/docs/codeconv/html/CodeConventionsTOC.doc.html" SIZE=5>target="_blank">http://java.sun.com/docs/codeconv/html/CodeConventionsTOC.doc.html
2
http://java.sun.com/j2se/javadoc/

Précédent Remonter Suivant