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