Un mémento des mots-clés du langage Java

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 :

Définit un objet de type classe.

public class Chien {

    private String nom;

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

    ...
}

Cible : définition objet.

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

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.

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

public class Chien implements Animal {
    ...
}

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

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.

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

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.

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

    default:
        ...
}

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

Depuis Java 5.

Cible : définition objet.

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

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.

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 :

List<? extends Chien> canins = ...

Cible : définition objet.

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

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 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.

Référence l'objet courant.

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 :

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…

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 :

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 :

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.

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

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 :

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.

Indique le package auquel appartient l'objet.

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.

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 :

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.

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

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 :

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.

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

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 :

String[] tab = ...

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

Cible : variable ou retour de méthode.

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 lettre = 'a';

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

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 :

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.

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.

public class Chien {
    private byte age = 4;
}

Cible : variable ou retour de méthode.

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.

public class Chien {
    private short age = 4;
}

Cible : variable ou retour de méthode.

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.

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 :

// Avant Java 7
int nombreEtoile = 123456789;

// Depuis Java 7
int nombreEtoile = 123_456_789;

Cible : variable ou retour de méthode.

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.

public class Chien {
    private long age = 4;
}

Cible : variable ou retour de méthode.

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

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

Cible : variable ou retour de méthode.

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

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

Cible : variable ou retour de méthode.

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 :

public class Chien {
    private float poids = 34.5d;

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

Cible : retour de méthode.

Mot réservé, mais pas utilisé.

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

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

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

Cible : retour de méthode.

Représente une valeur booléenne positive.

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

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

Cible : retour de méthode.

Opérateur permettant d'instancier un objet.

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 :

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

    ...
};

Cible : Corps du programme.

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

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 :

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

Cible : variable ou retour de méthode.

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

public class Chien {

    private static ChienUtility util = new ChienUtility(); 
}

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

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 :

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.

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

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.

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

public class Chien implements Serializable {

    // Ne sera pas serialise
    private transient int uid;

    // Sera serialise
    private String nom;

}

Cible : déclaration de variable.

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

public final class Labrador {
    ...
}

public class MaClasse extends Labrador { // Ne compile pas.
    ...

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.

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 :

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 :

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

    milou = new Chien(...);
}

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

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

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.

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

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.

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.

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.

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

public class Chien {
    private int age;

    public int getAge() {
        return age;
    }

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

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.

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

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 :

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 » :

List<Chien> chiens = ...

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

Cible : Corps de méthode.

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

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.

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

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.

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

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.

Mot réservé, mais pas utilisé.

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

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(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.

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

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

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

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

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

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

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.

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é.

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

    case "bonsoir":
        ...
        break;

    default:
        ...
}

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

Définit un label cible dans un bloc switch.

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

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

Cible : bloc switch

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.

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.

// 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.

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 :

int number = ...

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

    case 2 :
        ...
        break;

    default :
        ...
        break;
}

Cible : boucle ou switch.

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

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.

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

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

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

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

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

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 :

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.

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

public synchronized void update() {
    ...
}

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

public void update() {
    synchronized(this) {
        ...
    }
    ...
}

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

    synchronized (milou) {
        ...
    }

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

Lève une exception.

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.

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

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 :

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.

Ouvre un bloc pour intercepter d'éventuelles exceptions.

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.

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.

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

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é.

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.

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.

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

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(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 "foo";
} catch(Exceptio, e) {
    ...
} finally {
    ...
}

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