FAQ Langage JavaConsultez toutes les FAQ

Un mot-clé est tout simplement un mot qui a été réservé dans la grammaire du langage pour une utilisation spéciale par ce langage ; vous ne pouvez donc pas employer des mots-clés comme noms de variable, noms de classe ou tous autres éléments qui peuvent être déclarés.

Pour avoir une liste de tous les mots-clés du langage Java et de leurs significations, vous pouvez lire cet article ou la référence sur le site d'Oracle.

Ces trois mots-clés du langage Java (public, private, protected) définissent la portée d'une variable, d'une méthode ou d'une classe.

Il existe en fait quatre modificateurs d'accessibilité ; le quatrième est le modificateur dit par package-private. Pour ce dernier modificateur, on n'écrit rien : il n'y a pas de modificateur devant le nom de la variable, de la méthode ou de la classe. Attention, il ne faut pas confondre ce dernier modificateur avec le modificateur public.

Voici les caractéristiques de ces modificateurs, du plus permissif au plus restrictif :

• tous les membres (attributs et méthodes) d'une interface ou d'une annotation sont obligatoirement public ;
• tous les constructeurs d'une Enum sont obligatoirement private.
  

Le mot-clé void (avec un petit v) signifie littéralement « rien » ou « néant ». Ce mot-clé indique qu'une méthode ne retourne aucune valeur et sert donc à distinguer les méthodes qui ne retournent pas de valeur (appelées « procédures » dans d'autres langages de programmation) de celles qui en retournent une (appelées « fonctions » dans d'autres langages).

Par exemple :

1
2
3
4
5
6
7
8
public void maMethode1() { 
    [...] 
} 
  
public int maMethode2() { 
    [...] 
    return 0; 
}

1
2
int valeur1 = maMethode1(); // Impossible, ne compile pas. 
int valeur2 = maMethode2(); // Compile

Les conditions de type if-then-else se traduisent en Java de cette manière :

1
2
3
if (condition) { 
    // Code exécuté si condition respectée. 
}

1
2
3
4
5
if (condition) { 
    // Code exécuté si condition respectée. 
} else { 
    // Code exécuté si condition non respectée. 
}

1
2
3
4
5
6
7
8
9
if (condition1) { 
    // Code exécuté si condition respectée. 
} else if (condition2) { 
    // Code exécuté si condition2 est respectée. 
} else if (condition3) { 
    // Code exécuté si condtion3 est respectée. 
} else { 
    // Code exécuté si condition3 non respectée. 
}

Le mot-clé return permet de terminer une méthode et de la quitter. Lorsqu'une méthode ne retourne pas de valeur (déclarée void), le mot-clé return doit être utilisé tel quel sans spécifier de valeur. Lorsque cette méthode retourne une valeur, ce mot-clé doit être suivi d'une valeur de retour ; cela permet de faire remonter ce résultat dans la méthode appelante. Combiné avec des tests, le mot-clé return peut être utilisé pour sortir prématurément d'une méthode.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void maMethode1() { 
    [...] 
    if (test) { 
        return; // Cet appel court-circuite le reste de la méthode. 
    } 
    [...] 
    // Ici le return est implicite, il n'est pas besoin de le spécifier. 
} 
  
public int maMethode1() { 
    [...] 
    if (test) { 
        return 1; // Cet appel court-circuite le reste de la méthode. 
    } 
    [...] 
    return 0; // Ici, il faut quand même retourner une valeur. 
}

1
2
3
System.out.println("Toto"); 
return; // Ne compile pas. 
System.out.println("Tutu");

Il existe deux manières de créer des boucles for en Java.

For classique
Le for classique est la manière traditionnelle d'utiliser ce genre de boucle. La syntaxe à utiliser est la suivante :

1
2
3
for (initialisation ; condition ; mise à jour) { 
    // Code à exécuter dans la boucle. 
}

• L'initialisation permet de configurer une ou plusieurs variables qui serviront en général d'indices lors de la boucle. L'initialisation est utilisée uniquement lors du démarrage de la boucle.
• La condition consiste en un ou plusieurs tests qui permettent de stopper la boucle. Ces conditions sont vérifiées au démarrage de la boucle et au début de chaque interaction. Les conditions peuvent porter sur des variables qui ne sont pas décrites dans l'initialisation.
• La mise à jour permet de changer la valeur (incrémentation, décrémentation, etc.) d'une ou plusieurs variables à la fin d'une itération. Les mises à jour peuvent porter sur des variables qui ne sont pas décrites dans l'initialisation ou testées par les conditions.
  

1
2
3
for (int index = 0 ; index < 3 ; index++) { 
     System.out.println(index); 
}

1
2
3
0 
1 
2

1
2
3
for (int index = 2 ; index >= 0 ; index--) { 
    System.out.println(index); 
}

1
2
3
2 
1 
0

1
2
3
for (;;) { 
    // Code à exécuter dans la boucle. 
}

1
2
3
for (int variableA = 0, variableB = 5 ; condition ; mise à jour) { 
    // Code à exécuter dans la boucle. 
}

1
2
3
for (initialisation ; condition ; variableA ++, variableB -= 7) { 
    // Code à exécuter dans la boucle. 
}

1
2
3
for (valeur : conteneur) { 
    // Code à exécuter dans la boucle. 
}

1
2
3
4
final int[] valeurs = { 1, 2, 3 }; 
for (final int valeur : valeurs) { 
    System.out.println(valeur); 
}

1
2
3
4
final List<Integer>valeurs = Arrays.asList(1, 2, 3); 
for (final int valeur : valeurs) { 
    System.out.println(valeur); 
}

1
2
3
1 
2 
3

L'instruction while exécute un bloc d'instructions tant que la condition est respectée.

1
2
3
while (expression) { 
    // Code à exécuter dans la boucle.  
}

1
2
3
do { 
     // Code à exécuter dans la boucle.  
} while (expression);

1
2
3
while (true) { 
   // Code à exécuter dans la boucle.  
}

1
2
3
4
5
6
7
8
9
10
11
final int fin = 0; 
int i = 0; 
while (i < fin) { 
    System.out.println("i " + i); 
    i++; 
} 
int j = 0; 
do { 
    System.out.println("j " + j); 
    j++; 
} while (j < fin);

L'instruction switch permet de faire un saut dans le code en fonction d'une valeur constante qui est définie par une instruction case (qui fonctionne un peu comme un label). Le label default permet de définir un cas de figure par défaut.

Literal
L'instruction switch accepte presque tous les types de base : byte, char, short, int, long, float, double. Le type boolean n'est pas supporté.

Par exemple :

1
2
3
4
5
6
7
8
9
10
11
int myVar = [...] 
switch (maVar) { 
    case 1: 
        [...] // Instructions 1. 
    case 2: 
        [...] // Instructions 2. 
        break; 
    case 3: 
    default: 
        [...] // Instructions 3. 
 }

• 1 - les blocs d'instructions « Instructions 1 » et « Instructions 2 » sont exécutés séquentiellement. L'instruction break permet de quitter le bloc switch sans exécuter le bloc « Instructions 3 ».
• 2 - le bloc d'instructions « Instructions 2 » est exécuté. L'instruction break permet de quitter le bloc switch sans exécuter le bloc « Instructions 3 ».
• 3 ou une autre valeur - le bloc d'instructions « Instructions 3 » est exécuté.
  

1
2
3
4
5
int a = 1; 
switch (maVar) { 
    case a:  // Interdit. 
        [...] 
}

1
2
3
4
final int a = 1; 
switch (maVar) { 
    case a: // Fonctionne. 
}

1
2
3
4
5
6
7
8
9
10
11
String maString = [...] 
switch (maString) { 
    case "A": 
        [...] 
    break; 
    case "B": 
        [...] 
    break; 
    default: 
        [...] 
}

1
2
3
4
5
6
7
if ("A".equals(maString)) { 
    [...] 
} else if ("B".equals(maString)) { 
    [...] 
} else { 
    [...] 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public enum Priority { 
    ALWAYS, SOMETIMES, NEVER; 
} 
  
Priority maPriorite = [...] 
switch (maPriorite) { 
    case ALWAYS: // Et non pas Priority.ALWAYS 
        [...] 
    break; 
    case SOMETIMES: // Et non pas Priority.SOMETIMES 
        [...] 
    break; 
    case NEVER: // Et non pas Priority.NEVER 
        [...] 
    break; 
}

Le mot-clé static est utilisable pour des variables, méthodes, classes internes ou blocs de code.

Devant une variable ou méthode :

Le mot-clé static devant une variable (ou méthode) indique que celle-ci n'appartient pas à une instance particulière de la classe. Les variables ou méthodes statiques appartiennent à la classe elle-même. On peut ainsi les utiliser sans avoir une instance créée. De nombreuses classes ont des membres ou méthodes statiques. Par exemple la classe java.lang.Math :

1
2
3
4
System.out.println(Math.PI); 
// Affiche la valeur de PI. 
System.out.println(Math.abs(-1)); 
// Affiche la valeur absolue de -1.

• on peut aussi manipuler une variable ou méthode statique à partir d'une instance de la classe ;
• pour rendre des variables statiques comme des constantes, il faut combiner le mot-clé static avec le mot-clé final ;
• les méthodes statiques, étant indépendantes de toute instance, n'ont pas accès aux variables ou méthodes non statiques.
  

1
2
3
4
5
6
7
8
9
public class MaClasse { 
   public static Map<String, String> uneVariableStatique = new HashMap<String, String>(); 
   static{ 
      // Initialisation du contenu de uneVariableStatique lors du chargement de la classe. 
      uneVariableStatique.put("une clef","une valeur"); 
      uneVariableStatique.put("une autre clef","une autre valeur"); 
      // Etc . 
   } 
}

Depuis le JDK8, les méthodes statiques sont autorisées dans les interfaces. Dans les versions antérieures, seule la définition de variables statiques était autorisée.

Dans l'exemple ci-dessous, une interface Person déclare une méthode statique sayHello().

1
2
3
4
5
interface Person { 
    static void sayHello() { 
        System.out.println("Hello there!"); 
    } 
}

Le mot-clé final est utilisable pour des variables, méthodes, classes, classes internes ou des classes internes statiques.

Devant une méthode :
On indique que cette méthode ne pourra plus être redéfinie dans une classe fille. Ce qui entraine une certaine optimisation dans les appels à cette méthode.

1
2
3
4
// Aucune classe fille ne peut redéfinir cette méthode. 
public final void doClick() {  
  [...] 
}

1
2
3
4
// Il est impossible d’étendre cette classe. 
public final class String { 
  [...] 
}

• Par une déclaration en ligne :
  

  Code java :

  Sélectionner tout

  private final int i = 5;

• Par un bloc d'initialisation :
  

  Code java :

  Sélectionner tout

  1
  2
  3
  4
  private final int i; 
  { 
      i = 5; 
  }

• Par un constructeur :
  

  Code java :

  Sélectionner tout

  1
  2
  3
  4
  5
  private final int i; 
    
  public Exemple() { 
      i = 5; 
  }

  Si la classe possède plusieurs constructeurs, la variable doit être correctement initialisée, quel que soit le constructeur utilisé (sinon le compilateur provoquera une erreur).
  

• Par une déclaration en ligne :
  

  Code java :

  Sélectionner tout

  private static final int X = 5;

• Par un bloc d'initialisation statique :
  

  Code java :

  Sélectionner tout

  1
  2
  3
  4
  private static final int X; 
  static { 
      X = 5; 
  }

1
2
3
4
public void methode() { 
  final float flottant = 0.2f; 
  flottant = 0.5f  // Interdit. 
}

1
2
3
4
5
6
public void methode(final List<Object> liste, final int entier) { 
  entrier = 0; // Interdit. 
  liste = new ArrayList<Object>(); // Interdit. 
  final float flottant = 0.2f; 
  flottant = 0.5f  // Interdit. 
}

Les mots-clés this et super désignent respectivement des références sur l'instance courante et sur la classe mère. Voici un exemple qui devrait mettre en valeur cette définition plutôt succincte :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public MaClasse extends ClasseMere { 
   private String attribut; 
  
   // On peut accéder aux constructeurs de la super-classe. 
   public MaClasse(String uneValeur){ 
      super(uneValeur); 
      // On appelle ici le constructeur de la classe mère qui prend en paramètre une String. 
      // Cet appel, s'il a lieu d’être, est toujours sur la première ligne du constructeur. 
   } 
  
   // On peut aussi accéder aux constructeurs de la classe elle-même. 
   public MaClasse(){ 
      this("une valeur par défaut"); 
      // On appelle ici le constructeur défini un peu plus haut. 
      // Cet appel, s'il a lieu d’être, est toujours sur la première ligne du constructeur. 
   } 
  
   // En général l'appel à this est superflu lors d'appels à une méthode. 
   public void uneMethode() {} 
  
   public void doubleAppel(){ 
      // Les deux lignes suivantes sont équivalentes. 
      this.uneMethode(); 
      uneMethode(); 
   } 
  
   // L'appel à this peut être utile pour bien différencier les variables de classe des paramètres ou variables de méthodes. 
   public void uneMethode(String attribut){ 
      this.attribut = attribut; 
      // Ici, la variable de classe prend la valeur de la variable passée en paramètre de la méthode. 
   } 
  
   // On peut aussi faire appel aux méthodes de la super-classe. 
   public void uneAutreMethode(){ 
      // On peut faire quelque chose en plus avant. 
      super.uneAutreMethode(); 
      // Mais aussi après. 
   } 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Englobante { 
    private Object attribut; 
  
    public final class Interne { 
        private Object attribut; 
  
        private Interne() { 
            Englobante.this.attribut = this.attribut; 
            // Le premier this fait référence à la classe englobante. 
            // Le second this fait référence à la classe interne. 
        } 
    } 
}

Le mot-clé strictfp, qui est une abréviation de Strict floating point, s'applique en tant que modificateur d'accès. Ou plus simplement, on l'utilise de la même manière que les mots-clés public ou synchronized. Avec quelques restrictions : strictfp s'applique en tant que modificateur de classes, d'interfaces ou de méthodes d'une classe et en aucun cas au constructeur ou aux méthodes d'une interface. L'entité affectée est alors dite « FP-strict ».

Effet
Comme son nom l'indique, strictfp agit sur les opérations en virgule flottante. C'est-à-dire sur les types primitifs double et float.

Java effectue les calculs en garantissant une priorité de la gauche vers la droite.

1
2
3
4
5
6
7
8
9
10
/** classe FP-strict */ 
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); 
    }  
}

Le mot-clé transient (éphémère ou transitoire) est lié à la sérialisation des classes Java. Il permet d'interdire la sérialisation de certaines variables d'une classe.

1
2
3
4
5
6
7
8
// La classe que nous allons sérialiser. 
class Writeable implements java.io.Serializable { 
    // Entier transient. 
    public transient int var1 = 4; 
  
    // Entier normal. 
    public int var2 = 19; 
}

Le mot-clé volatile est utilisé sur les variables qui peuvent être modifiées de manière asynchrone. C'est-à-dire que plusieurs threads peuvent y accéder simultanément. Ces accès peuvent être pour la lecture et/ou la modification du contenu.

En indiquant que la variable est volatile, on 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.

Remarque : ce mot-clé est relativement peu utilisé.

Bien que goto soit un mot réservé de Java, on ne le trouve pas dans le langage ; Java n'a pas de goto. Le mot-clé goto est aussi ancien que les langages de programmation. En effet, goto a été le premier moyen de contrôle des programmes dans les langages d'assemblage : « si la condition A est satisfaite, alors sauter ici, sinon sauter là ». Lorsqu'on lit le code assembleur finalement généré par n'importe quel compilateur, on voit qu'il comporte beaucoup de sauts.

Break et continue
Cependant, il existe quelque chose qui ressemble à un saut, lié aux mots-clés break et continue. Ce n'est pas vraiment un saut, mais plutôt une manière de sortir d'une instruction d'itération.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
while(true) { 
    // Instructions. 
    [...] 
  
    if (condition1) { 
        // Quitte la boucle. 
        break; 
    }  
    if (condition2) { 
        // Retourne au début de la boucle. 
        continue;  
    }  
  
    // Instructions. 
    [...] 
}

Comme nous l'avons vu, il n'y a pas de goto en Java, mais il est possible d'associer un label à une instruction de boucle. Ce label, utilisé en conjonction avec l'instruction break, permet de savoir à quel niveau le break sera effectif.

Un label est un identifiant suivi de : (deux-points) et qui se place devant l'instruction de la boucle.

Voici un exemple :

1
2
3
4
5
6
7
8
9
10
11
Boucle1: while(true) {  
    System.out.println("Boucle 1");   
    Boucle2: for(int ind=0; ind < 10; ind++) {  
        System.out.println("Boucle 2");  
        Boucle3: while(true){  
            System.out.println("Boucle 3");  
            break Boucle2;  
        }  
    }  
    break;  
}

Les varargs, ou ellipse, sont un concept qui permet de créer des méthodes (ou des constructeurs) avec un nombre d'arguments variable. On utilise pour cela trois points (...) après le type des arguments, par exemple la méthode suivante accepte un nombre quelconque de String :

1
2
3
public void method (String... args) { 
   //  
}

1
2
3
4
5
6
7
8
// Avec 1 paramètre : 
method ("param1"); 
  
// Avec plusieurs paramètres : 
method ("param1", "param2", "param3"); 
  
// Sans paramètre : 
method ();

1
2
3
4
5
6
7
8
// Avec 1 paramètre : 
method (new String[]{"param1"}); 
  
// Avec plusieurs paramètres : 
method (new String[]{"param1", "param2", "param3"}); 
  
// Sans paramètres : 
method (new String[]{});

Le mot-clé import permet l'utilisation du nom court d'une classe au lieu de son nom long. Ainsi, pour les utilisateurs de C++, il est a rapprocher d'un using namespace plutôt que d'un #include.

Par exemple, il est tout à fait possible d’écrire :

1
2
3
4
5
6
7
8
9
10
11
mon.paquet.a.moi.MaClasse toto = new mon.paquet.a.moi.MaClasse(); 
  
[...] 
  
public void maMethode1(mon.paquet.a.moi.MaClasse parametre1) { 
    [...] 
} 
  
public mon.paquet.a.moi.MaClasse maMethode2() { 
    [...] 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import mon.paquet.a.moi.MaClasse; 
  
[...] 
  
MaClasse toto = new MaClasse(); 
  
[...] 
  
public void maMethode1(MaClasse parametre1) { 
    [...] 
} 
  
public MaClasse maMethode2() { 
    [...] 
}

import mon.paquet.a.moi.*;

L'importation statique permet d'importer les éléments statiques d'une classe afin d'alléger l'écriture du code. Cela permet en effet de ne pas préfixer les éléments statiques par le nom de la classe. Par exemple, les deux codes suivants sont identiques, mis à part que le second utilise une importation statique pour accéder aux méthodes de la classe java.lang.Math :

1
2
3
4
5
public Class Test { 
    public void calcul (int i) { 
        Math.round(Math.cos(i*(Math.PI/6)-Math.PI/2)*Math.E); 
    } 
}

1
2
3
4
5
6
7
import static java.lang.Math.*; 
  
public Class Test { 
    public void calcul (int i) { 
        round(cos(i*(PI/6)-PI/2)*E); 
    } 
}

1
2
3
4
5
6
7
8
import static java.lang.System.out; 
  
public Class Test { 
    public void print () { 
        out.println("Message d'information"); 
        System.err.println("Message d'erreur"); 
    } 
}

Les mots-clés import et le import static n'ont pas la même fonction.

Le mot-clé import opère sur une classe (ou un ensemble de classes via la notation *) et permet d'éviter de spécifier le package de la classe à chaque fois qu'on l'utilise (en partant du principe que l'on se trouve dans un paquetage différent de celui contenant la classe actuelle).

Le mot-clé import static a un fonctionnement similaire, mais pour les méthodes et les attributs statiques d'une classe ou d'une interface et les membres d'une enum. En effet, il permet d'éviter de spécifier la classe de la méthode ou de l'attribut statique à chaque fois qu'on l'utilise (en partant du principe que l'on se trouve dans une classe différente de celle contenant la méthode ou l'attribut).

Illustration
Soit les classes package_a.ClasseA et package_b.ClasseB.

Pour « utiliser » la classe ClasseA dans la classe ClasseB, il faut normalement spécifier le package comme suit :

1
2
3
4
5
6
7
8
9
package package_b; 
  
public class ClasseB { 
    private package_a.ClasseA a; 
  
    public CLasseB() { 
        a = new package_a.ClasseA(); 
    } 
}

1
2
3
4
5
6
7
8
9
10
11
package package_b; 
  
import package_a.ClasseA; 
  
public class ClasseB { 
    private ClasseA a; 
  
    public CLasseB() { 
        a = new ClasseA(); 
    } 
}

1
2
3
public static void staticMethod() { 
    [...] 
}

ClasseA.staticMethod();

1
2
3
4
5
import static package_a.ClasseA.staticMethod; 
  
[...] 
  
staticMethod();

ClasseA

ClasseA.staticMethod();

package_a.ClasseA

staticMethod();

• le mot-clé import ne permet la simplification d'écriture que pour les classes ;
• le mot-clé import static ne permet la simplification d'écriture que pour les méthodes et les attributs statiques d'une classe ou interface et les membres d'une enum ;
• les mots-clés import et import static sont indépendants l'un de l'autre.
  

On considère souvent l'opérateur ternaire "?" comme une syntaxe réduite de l'instruction if traditionnelle. Mais c'est avant tout un opérateur au sens où il produit une valeur.

(condition) ? résultat_1 : résultat_2

String chaine = (nouvelleChaine != null) ? nouvelleChaine : "";

1
2
3
4
String chaine = ""; 
if (nouvelleChaine != null) { 
    chaine = nouvelleChaine; 
}

Lorsqu'un membre, une méthode ou une classe sont qualifiés de deprecated, cela signifie que ce membre, cette méthode ou cette classe sont dépréciés ou encore obsolètes. Ce membre, cette méthode ou cette classe existent toujours pour des soucis de compatibilité ascendante, mais ils ne sont plus supportés et peut-être amenés à disparaître à l'avenir.

Pourquoi ?
Il existe plusieurs raisons pour qu'un membre, une méthode ou une classe soient marqués deprecated :

• le plus généralement il s'agit d'un renommage de l’entité. Certaines méthodes sont héritées des toutes premières versions de Java, les conventions de nommage n'étant pas toujours respectées à l’époque, certaines méthodes ont été renommées par la suite... (les exemples sont très fréquents dans Swing) ;
• quelques méthodes sont devenues obsolètes suite à une évolution de l'architecture de l'API (la gestion des dates par exemple) ;
• enfin, certaines méthodes se sont révélées dangereuses et ne doivent plus être utilisées. Les méthodes de la classe java.lang.Thread peuvent conduire à un état incohérent des objets ou un arrêt de l'application.
  

1
2
3
4
5
6
7
8
9
public class MaClass { 
    /**  
     * Une méthode dépréciée  
     * @deprecated 
     */ 
    public void maMethodeDepreciee() { 
        [...] 
    }  
}

1
2
3
4
5
6
public class MaClass { 
    @Deprecated 
    public void maMethodeDepreciee() { 
        [...] 
    }  
}

L’opérateur de comparaison instanceof (littéralement « instance de ») permet de tester si une variable appartient à un type donné ou pas. Cet opérateur accepte uniquement en opérande de gauche une variable à tester de type référence de tableau ou d'objet ou à la valeur null. L’opérande de droite doit être un nom de classe, un type de tableau ou objet valide sur lequel tester la variable. Cette expression retourne un boolean indiquant si le test a réussi ou échoué.

Par exemple :

1
2
3
4
5
6
7
8
int[] t = { 1, 2, 3, 4}; 
boolean tEstUnTableauDEntier = t instanceof int[]; // tEstUnTableauDEntier contient la valeur true. 
boolean tEstUnObjet = t instanceof Object; // tEstUnObjet contient la valeur true. 
boolean tEstUnTableauDObject = t instanceof Object[]; // Compilation impossible. 
boolean tEstUneChaine = t instanceof String; // Compilation impossible. 
Object o = p; 
boolean oEstUnTableauDObject = o instanceof Object[]; // oEstUnTableauDObject contient la valeur false. 
boolean oEstUneChaine = o instanceof String; // oEstUneChaine contient la valeur false.

1
2
3
4
5
6
7
8
Point p = new Point(); 
boolean pEstUnPoint = p instanceof Point; // pEstUnPoint contient la valeur true. 
boolean pEstUnObjet = p instanceof Object; // pEstUnObjet contient la valeur true. 
boolean pEstUnTableauDObject = p instanceof Object[]; // Compilation impossible. 
boolean pEstUneChaine = p instanceof String; // Compilation impossible. 
Object o = p; 
boolean oEstUnTableauDObject = o instanceof Object[]; // oEstUnTableauDObject contient la valeur false. 
boolean oEstUneChaine = o instanceof String; // oEstUneChaine contient la valeur false.

1
2
3
4
Object o = new Point(); 
if (o instanceof Point) { 
    Point p = (Point)b; // Ce cast ne lève jamais de ClassCastException. 
}

1
2
3
4
5
6
int[] t = null; 
boolean tEstUnPoint = t instanceof Point; // tEstUnPoint contient la valeur false. 
boolean tEstUnObjet = t instanceof Object; // tEstUnObjet contient la valeur false. 
Point p = null; 
boolean pEstUnPoint = p instanceof Point; // pEstUnPoint contient la valeur false. 
boolean pEstUnObjet = p instanceof Object; // pEstUnObjet contient la valeur false.

Le mot-clé throw (« jette » à l’impératif) est une instruction qui permet de lancer une exception.

Par exemple :

1
2
IOException ex = new IOException("Erreur de lecture sur le fichier !"); 
throw ex;

Le mot-clé throws (« jette » à la troisième personne du présent) est placé en fin de déclaration de méthode pour indiquer que cette dernière peut lever une ou plusieurs exceptions en cas d’exécution anormale.

Par exemple :

1
2
3
public void MaMethode() throws IndexOutOfBoundsException, IOException, NullPointerException { 
    [...] 
}

Le mot-clé try (« essaie ») permet d'ouvrir un bloc contenant des instructions pouvant générer une ou plusieurs exceptions lorsque des erreurs surviennent. Généralement (mais pas toujours), un bloc try est suivi par un ou plusieurs blocs catch et parfois par un bloc finally.

Par exemple :

1
2
3
try { 
    [...] // Opération pouvant générer une exception. 
}

Le mot-clé catch (« attrape ») permet d'ouvrir un bloc contenant des instructions servant à traiter une ou plusieurs exceptions. Ces blocs ne peuvent être positionnés qu’après un bloc try.

Par exemple :

1
2
3
4
5
try { 
    [...] // Opération pouvant générer une exception. 
} catch (MonException ex) { 
    [...] // Traitement de l'erreur. 
}

Le mot-clé finally (« enfin », « finalement ») permet d'ouvrir un bloc d'instructions qui sera tout le temps exécuté qu'il y ait une levée d'erreurs ou pas dans le bloc try ou les blocs catch qui le précèdent. Ce bloc ne peut être positionnés après un bloc try sans bloc catch ou après le dernier bloc catch qui suit un bloc try.

Par exemple :

1
2
3
4
5
try { 
    [...] // Opération pouvant générer une exception. 
} finally { 
    [...] // Bloc d'instructions tout le temps exécuté qu'il y ait des erreurs ou pas dans le try. 
}

1
2
3
4
5
6
7
try { 
    [...] // Opération pouvant lever une exception. 
} catch (MonException ex) { 
    [...] // Traitement de l'erreur. 
} finally { 
    [...] // Bloc d'instructions tout le temps exécuté qu'il y ait des erreurs ou pas dans le try ou le catch. 
}