I. Introduction

À ce jour, le langage Java possède 53 mots réservés (dont 50 mots-clés) tels que class, for, long ou encore switch. Cet article les passe en revue, un par un, et vous propose des exemples d'utilisation simples. Pour s'y retrouver parmi ces 53 mots réservés, ils ont été triés par ordre alphabétique, mais aussi par catégorie.

Téléchargez le mémento ici : memento-java.pdf sur Developpez.com / memento-java.pdf sur Icauda

Téléchargez le livret ici : bientôt disponible

I-A. À propos

Cette page vous propose des descriptions de l'ensemble des mots-clés Java. Vous noterez que Batiste Wicht avait déjà écrit un article intitulé « les mots réservés du langage Java » en 2007. Vous pouvez considérer ce nouvel article non seulement comme une mise à jour mais aussi comme un complément ou une seconde explication.

En outre, cet article vous propose de télécharger et d'imprimer vous-même un mémento et un petit livret. Ce sont des documents complémentaires faciles à conserver sur un coin du bureau et à partager avec ses collègues. Si vous êtes professeur, vous verrez que les étudiants adorent qu'on leur donne ces types d'aide-mémoire (version HTML, mémento et livret).

I-B. Versions

15 mai 2013 : Création du document.

II. Le mémento et le livret

En plus de la version Web (en HTML) de ce document, que vous êtes en train de lire, nous vous proposons de télécharger un mémento et un livret dédiés aux 53 mots réservés du langage Java.

Le mémento et le livret sont offerts gratuitement. Ils se présentent sous la forme de documents PDF à imprimer sur des feuilles A4 recto-verso (sur « bords courts » et option « bord à bord »). Vous trouverez comment plier et assembler le mémento et le livret en annexe.

Un mémento est constitué d'une seule feuille à plier en trois volets. Le mémento donne des définitions rapides, sans détail, et quelques exemples simples.

Téléchargez le mémento ici : memento-java.pdf sur Developpez.com / memento-java.pdf sur Icauda

Image non disponible

Un livret est constitué de plusieurs pages à plier en deux, à assembler à l'aide d'une agrafe. Le mémento propose également des exemples.

Téléchargez le livret ici : bientôt disponible

Les mémentos et le livret sont destinés à tous ceux qui s'intéressent au langage Java et plus particulièrement aux personnes qui n'en maîtrisent pas encore toutes les subtilités comme les stagiaires, les étudiants ou tout simplement des débutants.

Le mémento et le livret vous sont offerts sous licence « Creative Commons CC BY-NC-SA 3.0 FR ». Vous êtes libre de partager (reproduire, distribuer et communiquer) ces œuvres. Ce n'est pas de la publicité. C'est un cadeau pour lequel nous ne demandons aucune contrepartie. Toutefois, si vous appréciez ces mémentos/livret, et si vous l'utilisez/distribuez, ça nous fera plaisir de le savoir.

La licence Creative Commons vous demande de respecter trois points : attribution, pas d'utilisation commerciale et pas d'œuvre dérivée. Si vous souhaitez modifier ce mémento, par exemple pour l'utiliser dans une de vos plaquettes ou pour ajouter votre logo, il vous suffit de nous contacter et nous aurons le plaisir de vous accompagner et de vous offrir (gratuitement) une version utilisable et plus pratique.

Nous sommes également à la recherche d'un partenaire qui pourrait prendre en charge l'impression professionnelle d'une v2 de ces mémentos/livret, avec éventuellement plus de pages (volets) et plus de détails.

III. Classement

III-A. Par ordre alphabétique

III-B. Par catégorie

Ce document présente 53 mots réservés que j'ai séparés arbitrairement en deux, pour des raisons pratiques. Il y a d'un côté les mots-clés permettant de définir des objets, des variables, des comportements, etc. De l'autre côté, j'ai regroupé les mots-clés permettant d'écrire des algorithmes.

Les mots-clés pour les déclarations :

Les mots-clés pour les structures de contrôle :

Les deux mémentos correspondent à ces deux catégories.

III-B-1. Ou par sous-catégorie

Ces deux listes peuvent encore être divisées pour mieux correspondre aux utilisations des mots-clés. Je vous propose donc une série de sous-catégories :

Les mots-clés pour les objets :

Les mots-clés pour les types :

Les mots-clés pour les états :

Les mots-clés pour les modificateurs :

Les mots-clés pour les boucles :

Les mots-clés pour les branchements :

Les mots-clés pour les exceptions :

III-C. Réservés mais...

Il faut noter que const et goto sont bien réservés mais ils ne sont pas utilisés.

Il faut également préciser que false, true et null sont bien des mots réservés mais ne font pas partie des mots-clés.

IV. Mots-clés

Image non disponible

Les mots-clés sont des termes réservés en Java. Ils ont une signification et ne peuvent être utilisés que dans ce sens.

Les mots-clés const et goto ont été réservés à la création du langage Java, sans doute pour imiter le langage C++, mais ne sont pas utilisés.

IV-A. Mots pour les objets

Il est possible de créer trois types d'objets en Java : Interface, Classe et Enum. Ce dernier existe depuis la version 5 du langage.

 

IV-A-1. class

Définit un objet de type classe.

class
Sélectionnez

public class Chien {

    private String nom;

    public void mange(Aliment aliment) {
        ...
    }

    ...
}

Cible : définition objet.

 

IV-A-2. Interface

Définit un objet de type interface, qui spécifie un comportement, mais pas son code.

interface
Sélectionnez

public interface Animal {

    String getNom();
    String getCri();
    int getAge()
    void mange(Aliment aliment);
    ...
}

Les méthodes et attributs d'une interface sont public

Une interface ne contient que des définitions, c'est-à-dire pas de code.

Cible : définition objet.

 

IV-A-3. implements

Indique qu'une classe implémente une(des) interface(s).

implements
Sélectionnez

public class Chien implements Animal {
    ...
}

Une classe peut implémenter plusieurs interfaces, séparées alors par des virgules :

implements
Sélectionnez

public class Chien implements Animal, Serializable, Cloneable {
    ...
}

Lorsqu'une classe implémente une interface, elle doit en implémenter toutes les méthodes, sauf si elle est marquée abstract

Cible : définition objet.

 

IV-A-4. enum

Définit un objet de type « Enumération ».

enum
Sélectionnez

public enum Sexe {
    GARCON(1),
    FILLE(2);

    private final int code;

    Sexe(final int code) {
        this.code = code;
    }

    public static Sexe valueOfByCode(final int code) {
        for(Sexe sexe : values()) {
            if(sexe.code == code) {
                return sexe;
            }
        }
        throw new IllegalArgumentException("Ce code ne correspond n'est pas valide.");
    }
}

Les enum peuvent être utilisés dans les instructions switch.

enum dans un switch
Sélectionnez

switch(sexe) {
    case GARCON:
        ...
        break;

    default:
        ...
}

Les enum sont utilisés comme des « constantes » en Java.

Depuis Java 5.

Cible : définition objet.

 

IV-A-5. extends

Indique qu'une classe ou une interface étend respectivement une autre classe ou d'autres interfaces.

extends
Sélectionnez

public class Chien extends Mammifere {
    ...

Une classe ne peut étendre qu'une seule classe. Une interface peut étendre plusieurs interfaces, séparées alors par des virgules.

extends
Sélectionnez

public interface Animal extends Serializable, Cloneable {
    ...

Quand rien n'est précisé, une classe hérite automatiquement de la classe Object.

On peut aussi s'en servir dans le cadre des génériques :

Dans un générique
Sélectionnez

List<? extends Chien> canins = ...

Cible : définition objet.

 

IV-A-6. import

Référence des classes, des packages entiers ou des méthodes pour les utiliser dans le programme sans écrire leurs noms complets.

import
Sélectionnez

import java.util.ArrayList;

public class Chien {

    public void foo() {
        ArrayList<Integer> list = ...
        ...
    }
}

On peut grosso modo dire que c'est une sorte de raccourci.

Depuis Java 5, il est également possible de faire des « import static » d'une méthode ou d'un attribut pour l'utiliser ensuite comme si elle faisait partie de la classe :

import static
Sélectionnez

import static java.util.Arrays.asList;
...
import java.util.List;

public class Chien {

    public void foo() {
        List<Integer> premiers = asList(1, 2, 3, 5, 7, 11);
    }
}

Cible : Entête fichier.

 

IV-A-7. this

Référence l'objet courant.

this
Sélectionnez

public class Chien {
    private String couleur;
    ...

    public void foo() {
        String cou = this.couleur;
        ...

Le mot clé this est souvent utilisé dans les setters pour différencier la variable de classe de la variable passée en paramètre :

this
Sélectionnez

public class Chien {
    private String couleur;
    ...

    public void setCouleur(String couleur) {
        this.couleur = couleur;
    }

}

Le mot clé this est souvent utilisé de manière inutile, pour bien insister…

this
Sélectionnez


public class Loup {
    public String getCri() {
        return "hurle";
    }
}

public class Chien extends Loup {

    public String getCri() {
        return "aboie";
    }

    public void foo() {
        String criLoup = this.getCri(); // "aboie"
        String criChien = getCri(); // "aboie" : ici "this" est sous-entendu.
    }
}

On peut aussi appeler la méthode « this(...) », qui fait référence au constructeur de l'objet, à partir d'un autre constructeur. Si on appelle « this(...) », ça doit être la première instruction du constructeur :

this(...)
Sélectionnez

public class Chien extends Loup {

    public Chien() {
        ...
    }

    public Chien(int age) {
        this();
        this.age = age;
    }

    public Chien(int age, String nom) {
        this(age);
        this.nom = nom;
    }
}

En fait, si aucune instruction « super(...) » spécifique n'est utilisée, un appel au « super() » vide est implicitement fait.

Il est également possible d'utiliser « this » pour accéder à l'instance englobante dans les classes anonymes :

this dans une classe anonyme
Sélectionnez

public class MaClasse() {

     public void process() {
       new Thread(new Runnable() { // classe anonyme
          public void run() {
              MaClasse.this.foo(); // this fait reference a MaClasse et non a la classe anonyme
          }
       }).start();
    }
 
    public void foo() {
       // ...
    }
}
}

Cible : Corps du programme.

 

IV-A-8. super

Référence la classe mère de l'objet courant.

super
Sélectionnez


public class Loup {
    public String getCri() {
        return "hurle";
    }
}

public class Chien extends Loup {

    public String getCri() {
        return "aboie";
    }

    public void foo() {
        String criLoup = super.getCri(); // "hurle"
        String criChien = getCri(); // "aboie"
    }
}

Quand aucun héritage n'est précisé, la classe étend Object. C'est donc alors à Object que super fait référence.

On peut aussi appeler la méthode « super(...) », qui fait référence au constructeur de l'objet parent, à partir d'un autre constructeur. Si on appelle « super(...) », ça doit être la première instruction du constructeur :

super(...)
Sélectionnez


public class Loup {

    public Loup() {
        ...
    }

    public Loup(int age) {
        ...
    }
}

public class Chien extends Loup {

    public Chien() {
        super();
    }

    public Chien(int age) {
        super(age);
    }
}

En fait, si aucune instruction « super(...) » spécifique n'est utilisée, un appel au "super()" vide est implicitement fait.

Cible : Corps du programme.

 

IV-A-9. package

Indique le package auquel appartient l'objet.

package
Sélectionnez

package com.societe.animal

public class Chien {
    ...

Le nom complet de l'objet est composé de son nom de package accolé à son nom propre. Dans l'exemple ce sera donc « com.societe.animal.Chien ».

Il est d'usage que les noms de package soient en minuscule.

L'instruction package doit être la première instruction d'un fichier source.

Cible : Entête fichier.

 

IV-A-10. abstract

Indique qu'une classe ou une méthode est abstraite, c'est-à-dire sans implémentation.

Une classe abstraite ne peut pas être instanciée. Elle définit des méthodes (pas forcément abstraites) qui sont héritées par les classes filles.

Les méthodes abstraites sont déclarées sans corps (comme dans une interface). Elles doivent être surchargées (avec un corps) dans les classes filles non abstraites.

Une classe possédant au moins une méthode abstraite doit être déclarée abstraite également.

On se sert généralement d'une classe abstraite pour définir un comportement par défaut, qu'il faudra éventuellement finir dans les classes filles.

Exemple :

abstract
Sélectionnez

public abstract class AbstractAnimal implements Animal {

    public abstract int getNombreJambe();
    public abstract int getNombreBras();

    public int getNombreMembre() {
        return getNombreJambe() + getNombreBras();
    }

    ...
}

public class Chien extends AbstractAnimal {

    @Override
    public int getNombreJambe() {
        return 4;
    }

    @Override
    public int getNombreBras() {
        return 0;
    }
}

public class Singe extends AbstractAnimal {

    @Override
    public int getNombreJambe() {
        return 2;
    }

    @Override
    public int getNombreBras() {
        return 2;
    }
}

Cible : Définition d'une classe ou d'une méthode.

 

IV-A-11. native

Indique qu'une méthode est écrite de manière native, dans un autre langage que Java et dans un autre fichier.

native
Sélectionnez

public class Chien {

    public native void doTruc();
    ...

    public void foo() {
        Chien chien = ...

        chien.doSomething();
    }

}

La méthode native étant écrite dans un autre fichier, il est donc logique que sa déclaration Java soit vide.

Pour compléter le code, il suffit de charger le fichier cible :

native
Sélectionnez

public class Chien {

    public native void doTruc();
    ...

    static {
        System.loadLibrary("utility");
    }

}

Ce mot clé est assez rarement utilisé.

Cible : Définition d'une méthode.

IV-B. Mots pour les types

Java définit huit « types primitifs », qui ne sont pas des objets, et qui correspondent à des booléens, des caractères, des entiers et des nombres décimaux. Chaque type est codé sur un nombre de bits qui lui est propre et qui définit son intervalle de valeurs :

Type Correspondance Taille (bits) Intervalle de valeurs
boolean Booléen 1 true / false
char Caractère Unicode 16 non signés 0 à 65536
byte Entier 8 signés -128 à 127
short Entier 16 signés -32768 à 32767
int Entier 32 signés -2147483648 à 2147483647
long Entier 64 signés -9223372036854775808 à 9223372036854775807
float Décimal 32 signés -1.40239846E-45 à 3.40282347E38
double Décimal 64 signés 4.9406564584124654E-324 à 1.797693134862316E308

Même sur 64 bits, la précision des décimaux et leur représentation binaire font que tous les nombres ne peuvent pas être exactement décrits : cf. article « Double-precision floating-point format ».

Chacun des types primitifs est associé à un objet enveloppe immuable, qui a justement la particularité d'être un objet :

Type Enveloppe
boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

Le type void, qui n'est pas un primitif, possède également un objet enveloppe nommé Void.

Depuis Java 5, on peut utiliser l'autoboxing qui permet de travailler de façon quasi transparente avec les types primitifs ou leurs enveloppes :

autoboxing
Sélectionnez

// Avant Java 5
int number = 0;
Integer number = new Integer(0);

// Depuis Java 5
int number = 0;
Integer number = 0;

Il convient de prendre garde aux égalités mathématiques. Ainsi, 1/3 n'est pas égal à 0,3333 quelle que soit la quantité de « 3 » qu'on accole à la fin. Avec un double, il suffit d'utiliser le bon nombre de digits. Au passage, il faut aussi faire attention au type du résultat :

double
Sélectionnez

double tierCalculed = 1/3; // 0
double tierCalculed = (double) 1/3; // 0.3333333333333333

boolean egaux = tierCalculed == 0.33333; // false
boolean egaux = tierCalculed == 0.3333333333333333; // true

Pour comparer des décimaux, je vous conseille plutôt d'utiliser un delta :

delta
Sélectionnez

public static boolean areAlmostEqual(final double a, final double b) {
    final double delta = 0.0001;
    return ((a - delta) <= b) && (b <= (a + delta)) ;
}

areAlmostEqual(0.3333, (double) 1/3); // true 
 

IV-B-1. boolean

Type primitif pouvant prendre les valeurs true (vrai) et false (faux).

boolean
Sélectionnez

public class Chien {
    private boolean garcon = false;

    public boolean isGarcon() {
        return garcon;
    }
}

Un boolean peut recevoir le résultat d'une opération booléenne :

boolean
Sélectionnez

String[] tab = ...

boolean vide = tab == null || tab.lenght == 0;

Cible : variable ou retour de méthode.

 

IV-B-2. char

Type primitif représentant un caractère Unicode sur 16 bits.

Un char est spécifié à l'aide de l'apostrophe, et non des guillemets :

char
Sélectionnez

char lettre = 'a';

Les caractères non présents sur le clavier peuvent être saisis à l'aide de sa valeur hexadécimale en Unicode.

char en Unicode
Sélectionnez

char lettreUnicode = '\u039A'; // Le "\u" indique de l'Unicode

Un point difficile à comprendre quand on débute, c'est qu'un char peut recevoir une valeur entière, qui sera convertie :

Pi
Sélectionnez

char pi = 1055; // 1055 est le signe PI.

Il faut bien faire la différence entre un char et un String. Ce dernier peut être vu comme un tableau de char.

Cible : variable ou retour de méthode.

 

IV-B-3. byte

Type primitif représentant des entiers signés sur 8 bits, c'est-à-dire entre -128 et 127.

La plus petite valeur d'un entier signé sur huit bits est -2^7, soit -128. La plus grande valeur est 2^7-1, soit 127.

byte
Sélectionnez

public class Chien {
    private byte age = 4;
}

Cible : variable ou retour de méthode.

 

IV-B-4. short

Type primitif représentant des entiers signés sur 16 bits, c'est-à-dire entre -32 768 et 32 767.

La plus petite valeur d'un entier signé sur huit bits est -2^15, soit -32 768. La plus grande valeur est 2^15-1, soit 32 767.

byte
Sélectionnez

public class Chien {
    private short age = 4;
}

Cible : variable ou retour de méthode.

 

IV-B-5. int

Type primitif représentant des entiers signés sur 32 bits, c'est-à-dire entre -2 147 483 648 et 2 147 483 647.

La plus petite valeur d'un entier signé sur huit bits est -2^31, soit -2 147 483 648. La plus grande valeur est 2^31-1, soit 2 147 483 647.

int
Sélectionnez

public class Chien {
    private int age = 4;
}

Depuis Java 7, on peut utiliser le signe underscore sur les types int et long, dans le but de faciliter la lecture des valeurs :

 
Sélectionnez

// Avant Java 7
int nombreEtoile = 123456789;

// Depuis Java 7
int nombreEtoile = 123_456_789;

Cible : variable ou retour de méthode.

 

IV-B-6. long

Type primitif représentant des entiers signés sur 64 bits, c'est-à-dire entre -9 223 372 036 854 775 808 et 9 223 372 036 854 775 807.

La plus petite valeur d'un entier signé sur huit bits est -2^63, soit -9 223 372 036 854 775 808. La plus grande valeur est 2^63-1, soit 9 223 372 036 854 775 807.

long
Sélectionnez

public class Chien {
    private long age = 4;
}

Cible : variable ou retour de méthode.

 

IV-B-7. float

Type primitif représentant des décimaux signés sur 32 bits.

float
Sélectionnez

public class Chien {
    private float poids = 34.5f; // le "f" indique un float
}

Cible : variable ou retour de méthode.

 

IV-B-8. double

Type primitif représentant des décimaux signés sur 64 bits.

double
Sélectionnez

public class Chien {
    private double poids = 34.5d; // le "d" indique un double
}

Cible : variable ou retour de méthode.

 

IV-B-9. void

Type indiquant qu'une méthode ne renvoie pas de valeur.

La méthode « main() » et les « setters » sont des exemples classiques de méthodes renvoyant un void, c'est-à-dire rien :

void
Sélectionnez

public class Chien {
    private float poids = 34.5d;

    public void setPoids() {
        this.poids = poids;
    }
}

Cible : retour de méthode.

IV-C. Mots pour les états

 

IV-C-1. const

Mot réservé, mais pas utilisé.

 

IV-C-2. false

Représente une valeur booléenne négative.

false
Sélectionnez

boolean ok = false;
boolean egal = (1 == 2); // false

La valeur false est l'opposée de true.

Cible : retour de méthode.

 

IV-C-3. true

Représente une valeur booléenne positive.

true
Sélectionnez

boolean ok = true;
boolean egal = (1 == 1); // true

La valeur true est l'opposée de false.

Cible : retour de méthode.

 

IV-C-4. new

Opérateur permettant d'instancier un objet.

new
Sélectionnez

Chien chien = new Chien();

Animal chien = new Chien(); // Avec Chien qui implémente Animal.

Il est également possible d'instancier une classe anonyme, à l'aide d'une interface par exemple, sous réserve d'implémenter toutes les méthodes définies :

new
Sélectionnez

Animal dragon = new Animal() {
    @Override
    public int getNombreBras() {
        return 2;
    }

    ...
};

Cible : Corps du programme.

 

IV-C-5. null

Valeur spéciale indiquant qu'un objet ne référence rien.

null
Sélectionnez

Chien chien = null;

La valeur par défaut d'un Objet est null.

On ne peut réaliser aucune opération sur un objet null, faute de quoi ça lèvera une exception :

NullPointerException
Sélectionnez

Chien chien = null;
chien.foo(); // NullPointerException : NPE

Cible : variable ou retour de méthode.

 

IV-C-6. static

Indique qu'une variable, une méthode ou un bloc n'appartient pas à une instance particulière d'une classe.

static
Sélectionnez

public class Chien {

    private static ChienUtility util = new ChienUtility(); 
}

Une utilisation classique du mot clé static est le Design Pattern Singleton :

Singleton
Sélectionnez

public class MonService {

    private static MonService instance;

    // Constructeur private
    private MonService() {
    }

    public static MonService getInstance() {
        if(instance == null) {
            instance = new MonService();
        }
        return instance;
    }
}

Puisqu'une méthode marquée static n'est liée à aucune instance, elle ne peut en toute logique accéder qu'à des variables ou méthodes elles-mêmes static.

Le mot clé static peut également être associé à un bloc de code. Dans ce cas, le bloc sera exécuté à l'initialisation de la classe :

Bloc static
Sélectionnez

public class Chien {

    private static List<String> couleurs = new ArrayList<String>();
    static {
        couleurs.add("rouge");
        couleurs.add("jaune");
        couleurs.add("bleu");
    }
}

Cible : variable ou méthode.

 

IV-C-7. strictfp

Garantit la précision et les arrondis des calculs flottants pour assurer la portabilité, conformément à la spécification IEEE 754.

strictfp
Sélectionnez

public strictfp class FPDemo {
    public static void main(String[] args) {
        double d = 8e+307;

        /** affiche 4 * d /2 donc 2 * d */
        System.out.println(4 * d / 2);

        /** affiche 2 * d */
        System.out.println(2 * d);
    } 
} 

Ces deux expressions sont mathématiquement identiques, mais la JVM les interprète différemment. Java impose un parenthésage : (4*d)/2, et dans ce cas (4*d) produit un dépassement de capacité, donc un résultat infini. En revanche, la deuxième expression produit bien un résultat correct. Le mot-clé strictfp garantit les mêmes calculs sur toutes les machines virtuelles.

"strictfp" est une abréviation pour "Strict floating point".

Depuis Java 1.2.

Cible : déclaration de classe, interface ou méthode.

 

IV-C-8. transient

Indique qu'une variable ne doit pas être sérialisée.

transient
Sélectionnez

public class Chien implements Serializable {

    // Ne sera pas serialise
    private transient int uid;

    // Sera serialise
    private String nom;

}

Cible : déclaration de variable.

 

IV-C-9. final

Indique qu'un élément ne peut n'être ni modifié ni étendu.

final sur une classe
Sélectionnez

public final class Labrador {
    ...
}

public class MaClasse extends Labrador { // Ne compile pas.
    ...
final sur une méthode
Sélectionnez

public class Chien {

    public final void foo() {
        ...
    }
}

public class MaClasse extends Chien {

    public void foo() { // Ne compile pas.
        ...

Lorsqu'on applique le mot clé final à une classe, cela signifie donc que la classe ne peut pas avoir de fille par héritage. Appliqué à une méthode, il indique que les classes filles ne peuvent pas surcharger la méthode. Appliqué à une variable, il indique que la variable est une constante.

Appliqué à une variable de type primitif ou à un objet immutable, cela crée une constante. Appliqué à un objet, cela crée une référence constante : on ne peut pas réaffecter la référence, mais on peut modifier les champs de l'objet.

final
Sélectionnez

public void foo() {
    final Chien milou = new Chien("Milou");

    milou = new Chien("Lassie"); // Ne compile pas

    milou.setName("Lassie"); // Autorise
}

Le mot clé final permet également d'accéder à une variable depuis une classe anonyme :

final
Sélectionnez

public void method(final int nb) {
    new Thread() {
        public void run() {
            System.out.prinlnt(nb);
        }
    }.start();
}

Une variable marquée final ne peut être instanciée qu'une seule fois, y compris en null, sachant qu'elle n'est pas obligée d'être instanciée dès la déclaration :

final
Sélectionnez

public void method(final int nb) {
    final Chien milou;
    ...

    milou = new Chien(...);
}

Cible : déclaration de classe, méthode ou variable.

 

IV-C-10. volatile

Garantit la synchronisation d'une variable dans un contexte multithread.

 
Sélectionnez

public class Chien {

    public volatile double poids;
}

Il est possible que plusieurs threads essaient de lire/écrire une variable en même temps. En indiquant qu'une variable est « volatile », ça oblige la JVM à rafraîchir son contenu à chaque fois qu'elle est utilisée. On est ainsi certain que la valeur de la variable n'est pas une valeur mise en cache, mais bel et bien sa valeur exacte. Ainsi chaque thread a accès à la valeur la plus récente de la variable.

Le mot clé volatile est relativement peu utilisé.

Cible : déclaration de variable.

IV-D. Mots pour les modificateurs

Les mots-clés public, protected et private sont très importants dans Java, en tant que langage objet, car ils déterminent la visibilité de tous les éléments.

On peut les classer par ordre de restrictivité ainsi : public, protected, « vide » et private.

 

IV-D-1. private

Indique qu'un élément n'est accessible que dans la classe où il est défini.

private
Sélectionnez

public class Chien {
    private int age;
	...	

Les attributs d'une classe sont souvent marqués private. Pour y accéder, on ajoute des getters/setters marqués public à la classe.

Cible : déclaration de variable, méthode ou classe.

 

IV-D-2. protected

Indique qu'un élément n'est accessible que dans la classe où il est défini, ou dans les classes filles, ou encore dans les classes du même package.

protected
Sélectionnez

public class Chien {

    protected void doSomething() {
        ...
    }

En général, quand on utilise protected, c'est surtout pour que les éléments soient visibles depuis les classes filles. On n'utilise qu'assez rarement la visibilité depuis les autres classes du package.

Cible : déclaration de variable, méthode ou classe.

 

IV-D-3. public

Indique qu'un élément est accessible depuis partout.

public
Sélectionnez

public class Chien {
    private int age;

    public int getAge() {
        return age;
    }

Cible : déclaration de variable, méthode ou classe.

IV-D-4. Modificateur vide

Lorsqu'on n'indique aucune visibilité spécifique, c'est la visibilité par défaut qui est employée. On parle de visibilité de niveau package, qui est à mi-chemin de public et protected.

IV-E. Mots pour les boucles

De manière générale, les boucles permettent d'itérer sur les éléments d'une liste ou selon un compteur.

 

IV-E-1. for

Crée une boucle en spécifiant une initialisation de variable, une condition d'arrêt et une règle d'incrémentation.

for
Sélectionnez

for(int i = 0; i < 10; i++) {
    System.out.println(i);
}

La boucle précédente se contente de compter de 0 à 9.

La condition d'arrêt est évaluée avant chaque itération.

Les variables créées dans la boucle, y compris à l'initialisation (variable i ci-dessus), n'existent pas en dehors de la boucle. Elles existent en revanche dans les éventuelles boucles/structures imbriquées.

Les trois parties (initialisation, condition d'arrêt et incrémentation) de la boucle peuvent être vides :

for
Sélectionnez

Chien chien = ...
for( ; chien != null; ) {
    ...
}

Depuis Java 5, il est possible de boucler sur les éléments itérables (qui implémentent Iterable) comme les listes à l'aide d'une boucle for appelée communément « for-each » :

for each
Sélectionnez

List<Chien> chiens = ...

for(Chien chien : chiens) {
    System.out.println(chien);
}

Cible : Corps de méthode.

 

IV-E-2. while

Crée une boucle en spécifiant une condition d'arrêt.

while
Sélectionnez

int i = 0;
...

while (i < 10) {
    ...
}

On pourrait parler de « condition de continuité » à la place de « condition d'arrêt » puisque la boucle s'exécute tant que la condition est vérifiée.

La condition d'arrêt est évaluée avant chaque itération.

Cible : Corps de méthode.

 

IV-E-3. do

Crée une boucle dont la condition d'arrêt est évaluée, en association avec un while, après l'itération.

do while
Sélectionnez

int i = 0;

do {
    ...
} while(i < 10);

Contrairement aux boucles for et while, la condition d'arrêt est évaluée après les itérations.

Les boucles do sont rarement utilisées.

Cible : Corps de méthode.

 

IV-E-4. continue

Stoppe l'exécution d'une boucle et reprend à l'itération suivante (ou au niveau d'un label).

continue
Sélectionnez

for(int i = 0, i < 10, i++) {
    if(i == 5) {
        continue;
    }
    System.out.println(i)
}

L'exemple ci-dessus compte de 0 à 9 en sautant 5.

On peut aussi préciser un label cible, comme avec le mot clé break. Dans ce cas, ça poursuit au niveau du label et non à l'itération suivante. Toutefois cette option est rarement utilisée.

Cible : Corps d'une boucle.

 

IV-E-5. goto

Mot réservé, mais pas utilisé.

IV-F. Mots pour les branchements

 

IV-F-1. if

Exécute un bloc si une condition booléenne est satisfaite.

if
Sélectionnez

if(5 < 6) 
    foo();

Le mot clé if permet donc de faire un test. On entre dans le bloc si la condition est remplie.

Lorsque le bloc contient plusieurs instructions, il faut utiliser les accolades.

if
Sélectionnez

if(5 < 6) {
    foo();
    truc();
}

Il est conseillé de toujours utiliser des accolades, même lorsqu'il n'y a qu'une seule instruction, pour des raisons de lisibilité.

Cible : corps du programme.

 

IV-F-2. else

Exécute un bloc lorsque la condition d'un if n'est pas remplie.

else
Sélectionnez

if(5 < 6) {
    foo();
    truc();
} else {
    doSomething();
}

Il est possible de tester plusieurs conditions en enchaînant des if avec des else :

else
Sélectionnez

int x = ...;
if(x < 3) {
    ...
} else if(x < 5) {
    ...
} else if(x < 7) {
    ...
} else {
    ...
}

Cible : corps du programme en complément d'un if.

 

IV-F-3. switch

Exécute un bloc de code, désigné par un label case, en fonction d'une valeur.

switch
Sélectionnez

int x = ...

switch(x) {
    case 1:
        ...
        break;

    case 2:
        ...
        break;

    ...

    default :
        ...
        break;
}

L'exécution des blocs commence à partir du case correspondant. Les case suivants sont aussi exécutés, dans l'ordre d'apparition, sauf si une instruction break fait sortir du switch.

switch
Sélectionnez

int x = 2;
switch(x) {
    case 1 :
        ...
        break;

    case 2:
        foo(); // sera exécute
        truc(); // sera exécute

    case 3:
    case 4:
        toto(); // sera exécute
        break; 

    case 5:
        ...

    default:
        ...
}

Ce mot clé évite d'utilise une structure constituée de multiple "if" et "else" imbriqués.

Les switch n'acceptent que des valeurs convertibles en int, comme un char, ce qui est perturbant pour les débutants. Depuis Java 5, il est possible d'utiliser un enum. Et depuis Java 7, il est aussi possible d'utiliser un String, même si cela est déconseillé.

switch en Java 7
Sélectionnez

String s = ...
switch(s) {
    case "bonjour" :
        ...
        break;

    case "bonsoir":
        ...
        break;

    default:
        ...
}

Cible : corps du programme en complément de case et default.

 

IV-F-4. case

Définit un label cible dans un bloc switch.

default
Sélectionnez

int x = ...

switch(x) {
    case 1:
        ...
        break;

    case 2:
        ...
        break;

    ...

    default :
        ...
        break;
}

La valeur du case doit bien entendu être une constante.

Cible : bloc switch

 

IV-F-5. default

Définit un label par défaut quand aucun label d'un bloc switch ne correspond.

Cible : bloc switch

 

IV-F-6. break

Saute hors d'une boucle, hors d'une instruction (switch) ou vers un label.

Il est utilisé pour sortir facilement d'une boucle et éviter de nombreux tests imbriqués.

break
Sélectionnez

for(int i = 0; i < 10; i++) {
    System.out.println("i:" + i);

    if(5 < i) {
        break; // Fait sortir de la boucle for
    }
}

Dans l'exemple précédent, l'exécution de la boucle se termine dès que la variable i devient supérieure à 5. Le programme reprend alors son cours.

L'instruction break ne fait sortir que d'un seul niveau de boucle, si plusieurs boucles sont imbriquées.

break
Sélectionnez

// Boucle #1
for(int i = 0; i < 10; i++) {
    System.out.println("i:" + i);

    // Boucle #2
    for(int j = i; j < 10; j++) {
        System.out.println("j:" + j);

        if(i < 5) {
            break; // Fait sortir de la boucle #2
        }
    }
}

L'instruction break peut être utilisée en combinaison avec un label.

break
Sélectionnez

aaa: for(int i = 0; i < 10; i++) {
    System.out.println("i:" + i);

    bbb: while() {
        ...

        if(condition) {
            break aaa; // Reprend au niveau du label aaa
        }
    }
}

L'utilisation de l'instruction break conjointement à un label est assez rare.

Ce mot-clé sert également pour structurer un switch :

break
Sélectionnez

int number = ...

switch(number) {
    case 0 :
    case 1 :
        ...
        break;

    case 2 :
        ...
        break;

    default :
        ...
        break;
}

Cible : boucle ou switch.

 

IV-F-7. assert

Vérifie qu'une condition est remplie, sinon lève une erreur avec le message spécifié.

assert
Sélectionnez

public void setPoids(final int poids) {
    assert 0 < poids : "Un poids ne peut pas être négatif ou nul";

    this.poids = poids;
}

La condition assert est surtout utilisée pour faire du débogage. Elle peut être désactivée, pour des raisons de performances par exemple, cf. la documentation sur l'activation.

L'erreur qui est lancée est une AssertionError. Elle reprend le message d'erreur spécifié. Ce dernier est toutefois optionnel.

Cible : Corps d'une méthode.

Depuis : Java 1.4.

 

IV-F-8. instanceof

Teste si une variable est une instance d'un objet spécifique.

instanceof
Sélectionnez


Chien milou = new Chien(...);
if(milou instanceof Chien) { // oui
    ...

Le mot clé instanceof prend en compte la hiérarchie d'objet :

instanceof
Sélectionnez


Chien milou = new Chien(...);
if(milou instanceof Animal) { // oui
    ...

if(milou instanceof Singe) { // non
    ...

Cible : Corps d'une méthode, généralement dans une instruction if

 

IV-F-9. return

Stoppe l'exécution d'une méthode et renvoie la valeur facultative spécifiée.

return
Sélectionnez

public int additionne(int a, int b) {
    int somme = a + b;
    return somme;
}

L'instruction return peut être utilisée plusieurs fois dans une méthode, pour simplifier l'algorithme par exemple :

return
Sélectionnez

public int factoriel(int n) {

    if(n == 0) {
        return 1;
    }

    return n * factoriel(n - 1);
}

Lorsque le type de retour d'une méthode est void, l'instruction return ne peut pas spécifier de valeur.

Cible : Corps d'une méthode.

 

IV-F-10. synchronized

Indique qu'un seul thread à la fois peut accéder à une méthode ou à un bloc.

synchronized sur une méthode
Sélectionnez

public synchronized void update() {
    ...
}

Un cas classique d'utilisation est le design pattern Singleton, dans lequel on voudrait par exemple ouvrir une ressource.

synchronized avec un lock sur this
Sélectionnez

public void update() {
    synchronized(this) {
        ...
    }
    ...
}
synchronized sur une variable
Sélectionnez

Chien milou = new Chien("Milou");
...

    synchronized (milou) {
        ...
    }

Cible : déclaration de méthode ou corps d'une méthode.

IV-G. Mots pour les exceptions

 

IV-G-1. throw

Lève une exception.

throw
Sélectionnez

public void foo() {
    ...

    if(chien == null) {
        throw new NullPointerException("Le chien doit exister");
    }

    ...
}

Lorsqu'une exception est levée, l'exécution de la méthode est arrêtée.

Cible : Corps d'une méthode.

 

IV-G-2. throws

Indique qu'une méthode peut lever une exception.

throws
Sélectionnez

public void foo() throws MonException {

    if(...) {
        throw new MonException("...");
    }

}

Une méthode peut lever plusieurs exceptions distinctes, dont les noms sont séparés par des virgules :

throws
Sélectionnez

public void foo() throws MonException, FooException, TrucException {

    if(...) {
        throw new MonException("...");
    }

}

Les exceptions de type « runtime » n'ont pas besoin d'être indiquées dans la définition de la méthode.

Cible : Déclaration d'une méthode.

 

IV-G-3. try

Ouvre un bloc pour intercepter d'éventuelles exceptions.

try
Sélectionnez

try {
    String s = null;
    int taille = s.size(); // Leve une NullPointerException ici.

} catch(Exception e) {
    ...
}

Depuis Java 7, on peut indiquer à un try qu'il doit gérer la fermeture des ressources, comme un statement vers la base de données par exemple. On dit « try-with-resource ». La ressource doit alors implémenter AutoCloseable.

try avec ressource
Sélectionnez

public Chien[] chercheChiensEnBase(final Connection con) {
    try {
        String sql = "select * from t_chien";

        try (Statement stmt = con.createStatement()) {
            ResultSet rs = stmt.executeQuery(sql);

            Chien[] chiens = ...
            while (rs.next()) {
                ...
            }

            return chiens;

    } catch(Exception e) {
        ...
    }
}

le mot clé try doit toujours être associé avec catch et/ou finally : au moins l'un des deux.

Cible : Corps d'une méthode.

 

IV-G-4. catch

Ouvre un bloc permettant de gérer une exception survenue dans un try.

catch
Sélectionnez

try {
    String s = null;
    int taille = s.size(); // Leve une NullPointerException ici.

} catch(NullPointerException e) {
    e.printStackTrace(); // Log l'exception et ses détails dans la console.
}

Il peut y avoir plusieurs catch d'affilés, mais un seul (le premier qui correspond) sera exécuté.

catch
Sélectionnez

try {
    ...

} catch(NullPointerException e) {
    e.printStackTrace(); // Log l'exception et ses détails dans la console.
} catch(IOException e) {
    e.printStackTrace(); 
} catch(TrucException e) {
    e.printStackTrace(); 
} catch(Exception e) {
    ...
}

Depuis Java 7, il est possible de spécifier plusieurs types d'exception dans un catch. En effet, la plupart du temps, on fait des copiés-collés d'un catch à l'autre.

catch
Sélectionnez

try {
    ...

} catch(NullPointerException | IOException | TrucException e) {
    e.printStackTrace(); // Log l'exception et ses détails dans la console.

} catch(Exception e) {
    ...
}

Cible : Corps d'une méthode, en complément d'un try.

 

IV-G-5. finally

Ouvre un bloc qui sera toujours exécuté après un try.

finally
Sélectionnez

FileOutputStream fos = null;

try {
    File f = ...
    fos = new FileOutputStream(f);
    ...

} finally {
    fos.close();
}

Le finally sert généralement à fermer les éventuelles ressources ouvertes dans le try.

S'il y a aussi un catch, il sera exécuté avant le finally :

try catch finally
Sélectionnez

try {
    ...
} catch(MonException e) {
    ...
} catch(FooException e) {
    ...
} finally {
    ...
}

Il est important de noter que le bloc finally est exécuté même lorsqu'il y a un return dans le try. L'instruction return est réalisée dès que l'exécution du finally est terminée :

try return finally
Sélectionnez

try {
    ...
    return "foo";
} catch(Exceptio, e) {
    ...
} finally {
    ...
}

Cible : Corps d'une méthode, en complément d'un try.

V. Conclusion

53 mots réservés, dont 50 mots-clés, même si deux ne servent à rien, ça fait beaucoup de choses à connaître et à comprendre, surtout en ce qui concerne leurs interactions. J'espère que cet article vous aidera à y voir plus clair. Jetez simplement un œil au mémento et au livret quand vous aurez un trou de mémoire.

VI. Remerciements

Je tiens à remercier, en tant qu'auteur de cet article, toutes les personnes qui m'ont aidé et soutenu. Je pense tout d'abord à mes collègues qui subissent mes questions au quotidien, mais aussi à mes contacts et amis du Web, dans le domaine de l'informatique ou non, qui m'ont fait part de leurs remarques et critiques. Bien entendu, je n'oublie pas l'équipe de Developpez.com qui m'a guidé dans la rédaction de cet article et m'a aidé à le corriger et le faire évoluer, principalement sur le forum.

Plus particulièrement j'adresse mes remerciements à Mickael Baron, mlny84, Yann Caron (CyaNnOrangehead), Nicolas (Robin56), Logan (Nemek), Claude Leloup et Fabien.

VII. Annexes

VII-A. Liens

Article « Les mots réservés du langage Java », par Batiste Wicht :
http://baptiste-wicht.developpez.com/tutoriels/java/mots-reserves/

Article « List of Java keywords », sur Wikipedia :
http://en.wikipedia.org/wiki/List_of_Java_keywords

Article « Les types primitifs et les classes enveloppes », par Anis Frikha :
http://anisfrikha.developpez.com/tutoriel/java/types-primitifs/

Article « Développons en Java », par Jean-Michel Doudoux :
http://jmdoudoux.developpez.com/cours/developpons/java/

VII-B. Liens personnels

Mon site Web : http://www.icauda.com

Retrouvez ma page et mes autres articles sur developpez.com à l'adresse
http://thierry-leriche-dessirier.developpez.com/#page_articlesTutoriels

Image non disponible
QR Code vers mes articles

Ajoutez-moi à vos contacts à l'aide du QR Code suivant :

Image non disponible
QR Code contenant ma vCard

Suivez-moi sur Twitter : @thierryleriche@thierryleriche

[ALT-PASTOUCHE]@thierryleriche
@thierryleriche

VII-C. Pliage des versions PDF imprimées

Le mémento et le livret doivent être imprimés recto-verso sur bords courts sur des feuilles au format A4, avec l'option bord à bord.

Le mémento doit être plié en trois, pour former trois volets. Il y a un petit guide (trait en pointillés) au verso. Il suffit de replier le volet de garde (avec le titre « Java, les mots-clés du langage ») sur ce guide. Pour finir, il faut replier le dernier volet en s'appuyant sur le premier pli.

Image non disponible
Recto du mémento
Image non disponible
Verso du mémento

Les feuilles du livret doivent être pliées en deux parties égales. Les feuilles sont conçues pour s'imbriquer les unes dans les autres. Si vous possédez une agrafeuse à grand débattement, vous pouvez l'utiliser pour solidariser les pages. Je vous conseille de mettre les pointes des agrafes vers le centre du livret pour que ce soit plus esthétique lorsque le livret est fermé.