IdentifiantMot de passe
Loading...
Mot de passe oubli� ?Je m'inscris ! (gratuit)
logo

FAQ Langage JavaConsultez toutes les FAQ

Nombre d'auteurs : 42, nombre de questions : 297, derni�re mise � jour : 19 septembre 2017  Ajouter une question

 

Cette FAQ a �t� r�alis�e � partir des questions fr�quemment pos�es sur le forum Java de http://java.developpez.com ainsi que l'exp�rience personnelle des auteurs.

Nous tenons � souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne pr�tend pas non plus �tre compl�te. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant r�dacteur, lisez ceci.

Sur ce, nous vous souhaitons une bonne lecture.

SommaireBases du langageMots-cl�s (29)
pr�c�dent sommaire suivant
 

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.

Mis � jour le 2 juin 2015 bentechno

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

Mot-cl� Port�e Remarques
public Les variables, m�thodes ou classes publiques sont accessibles par tout objet. Il ne peut y avoir qu'une seule classe publique par .java et celle-ci doit obligatoirement porter le nom du fichier .java
Les variables, m�thodes ou classes d�finies sans modificateur sont accessibles par toute classe appartenant au m�me package. Attention�: les variables sans modificateur ne sont pas accessibles aux classes filles d�finies dans un autre package.
protected Les variables, m�thodes ou classes d�finies comme prot�g�es ne sont accessibles que par les classes filles et classes du m�me package.
private Les variables, m�thodes ou classes d�finies comme priv�es ne sont accessibles que par la classe dans laquelle elles sont d�finies. Il est fortement conseill� de d�clarer comme priv�s tous les attributs d'une classe, et de cr�er des m�thodes de type getter et setter pour y acc�der.

Naturellement, toute m�thode, variable ou classe est accessible dans la classe ou elle est d�finie.

Remarque�: il y a deux cas particuliers o� l�absence de mot-cl� de visibilit� ne correspond pas � une visibilit� package-private�:

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

Mis � jour le 7 mai 2015 bouye Ioan

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

Code Java : S�lectionner tout
1
2
3
4
5
6
7
8
public void maMethode1() { 
    [...] 
} 
  
public int maMethode2() { 
    [...] 
    return 0; 
}

Ici, maMethode1() ne retourne pas de valeur, tandis que ma maMethode2() retourne un entier qu'il est possible d'affecter dans une variable.

Code Java : S�lectionner tout
1
2
int valeur1 = maMethode1(); // Impossible, ne compile pas. 
int valeur2 = maMethode2(); // Compile

Attention�: ne pas confondre le mot-cl� void et la classe java.lang.Void (avec un grand V) qui permet de retourner la valeur null et rien d'autre.

Mis � jour le 10 juillet 2015 bouye

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

Code Java : S�lectionner tout
1
2
3
if (condition) { 
    // Code ex�cut� si condition respect�e. 
}

Ou encore, dans le cas o� on effectue une action lorsque la condition n'est pas respect�e�:

Code Java : S�lectionner tout
1
2
3
4
5
if (condition) { 
    // Code ex�cut� si condition respect�e. 
} else { 
    // Code ex�cut� si condition non respect�e. 
}

Vous noterez qu'il n'y a pas de mot-cl� then dans la syntaxe.

Il est possible d'empiler diff�rentes conditions de cette mani�re

Code Java : S�lectionner tout
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. 
}

Mis � jour le 7 mai 2015 bouye Mickael Baron

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.

Code Java : S�lectionner tout
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. 
}

Attention�: lorsqu'une m�thode est d�clar�e comme retournant une valeur, contrairement � d'autres langages, il n'y a pas de valeur de retour implicite. En Java, vous devez explicitement d�clarer toutes les valeurs de retour.

Le mot-cl� return doit toujours �tre la derni�re instruction d'un bloc. Si le mot-cl� return est plac� ailleurs dans le bloc, votre code ne compilera pas et vous obtiendrez une erreur indiquant que votre code n'est pas atteignable (unreachable statement).

Code Java : S�lectionner tout
1
2
3
System.out.println("Toto"); 
return; // Ne compile pas. 
System.out.println("Tutu");

Mis � jour le 10 juillet 2015 bouye

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

Code Java : S�lectionner tout
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.

Chacune des parties est s�par�e de la suivante par un point-virgule ��;��. Il est important de bien v�rifier ce que vous �crivez dans chacune de ces trois parties sous peine d'avoir des boucles qui ne d�marrent jamais, dont les mises � jour ne se passent pas comme pr�vu ou m�me qui it�rent de mani�re infinie (boucle infinie ou infinite loop).

Prenons un exemple de boucle simple�:

Code Java : S�lectionner tout
1
2
3
for (int index = 0; index < 3; index++) { 
     System.out.println(index); 
}

Ici, ce bout de code permet de faire varier la variable index de la valeur 0 � la valeur 3. La boucle se terminera lorsque la valeur 3 sera atteinte. La sortie de ce bout de code est�:

Code Console : S�lectionner tout
1
2
3
0 
1 
2

Prenons un autre exemple�:

Code Java : S�lectionner tout
1
2
3
for (int index = 2; index >= 0; index--) { 
    System.out.println(index); 
}

Ici, ce bout de code permet de faire varier la variable index de la valeur 2 � la valeur -1. La boucle se terminera lorsque la valeur -1 sera atteinte. La sortie de ce bout de code est�:

Code Console : S�lectionner tout
1
2
3
2 
1 
0

Chaque partie de la d�claration est optionnelle et peut �tre omise�: il suffit de la laisser vide, mais ce sera � vos propres risques. Ainsi, il est tout � fait possible d��crire�:

Code Java : S�lectionner tout
1
2
3
for (;;) { 
    // Code � ex�cuter dans la boucle. 
}

Ce qui provoquera une boucle infinie.

Il est possible de d�clarer plusieurs variables dans l'initialisation, en les s�parant par des virgules ��,��. Ces variables sont forcements toutes du m�me type que la premi�re variable d�clar�e. Par exemple�:

Code Java : S�lectionner tout
1
2
3
for (int variableA = 0, variableB = 5; condition�; mise � jour) { 
    // Code � ex�cuter dans la boucle. 
}

Il est de m�me possible de faire une mise � jour qui porte sur plusieurs variables, en les s�parant par des virgules ��,��.

Code Java : S�lectionner tout
1
2
3
for (initialisation�; condition�; variableA ++, variableB -= 7) { 
    // Code � ex�cuter dans la boucle. 
}

Il n'est pas possible de sp�cifier plusieurs conditions en les s�parant par des virgules. Il suffit d��crire plusieurs conditions et de les composer avec des op�rateurs bool�ens tels que && (ET) ou || (OU).

Attention�: trop abuser de cette syntaxe tend � rendre la lecture de la bouche difficile et il est alors plus facile de commettre des erreurs.

For-each
Depuis Java 1.5, il est possible d'utiliser le mot-cl� for dans une boucle nomm�e enhanced for loop (boucle for am�lior�e) �galement appel�e for-each dans d'autres langages. Ce type de boucle effectue une it�ration automatique sur un ensemble de valeurs�; il n'est donc pas besoin de manipuler un indice manuellement comme dans le for classique. Si un conteneur de donn�es est un tableau ou h�rite de l'interface java.lang.Iterable<T>, il est possible de faire une boucle for-each en utilisant la syntaxe suivante�:

Code Java : S�lectionner tout
1
2
3
for (valeur�: conteneur) { 
    // Code � ex�cuter dans la boucle. 
}

Par exemple�:

Code Java : S�lectionner tout
1
2
3
4
final int[] valeurs = { 1, 2, 3 }; 
for (final int valeur�: valeurs) { 
    System.out.println(valeur); 
}

Ou encore�:

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

Ces deux bouts de code auront comme sortie�:

Code Console : S�lectionner tout
1
2
3
1 
2 
3

Ici, dans le premier code valeurs est un tableau d'entiers tandis que dans le second bout de code c'est un objet de type List<Integer> qui �tend donc l'interface Iterable<Integer>. Il est donc possible d'utiliser la syntaxe for-each dans les deux cas.

Mis � jour le 2 juin 2015 bouye

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

Code Java : S�lectionner tout
1
2
3
while (expression) { 
    // Code � ex�cuter dans la boucle.  
}

L'instruction do-while est identique � la pr�c�dente sauf qu'au moins un bloc d'instructions est ex�cut� m�me si la condition n'est pas respect�e.

Code java : S�lectionner tout
1
2
3
do { 
     // Code � ex�cuter dans la boucle.  
} while (expression);

Attention�: dans une boucle while ou do-while, vous devez vous-m�me g�rer les conditions qui permettent de quitter la boucle. Le code suivant par exemple provoquera une boucle infinie (infinite loop)�:

Code Java : S�lectionner tout
1
2
3
while (true) { 
   // Code � ex�cuter dans la boucle.  
}

La diff�rence entre while et do-while tient dans le fait que do-while �value la condition � la fin. Ainsi, dans avec do-while le bloc d'instruction est au moins ex�cut� une fois.

Par exemple�:

Code Java : S�lectionner tout
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);

Ici seule la seconde boucle affichera une sortie puisque son instruction est ex�cut�e au moins une fois.

Mis � jour le 21 mars 2015 bouye ClaudeLELOUP Mickael Baron

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

Code Java : S�lectionner tout
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. 
 }

Ici, si maVar vaut�:
  • 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�.


L'instruction case n'accepte que des constantes�; ainsi le compilateur reportera l'erreur case expressions must be constant expressions si jamais vous essayez de faire�:

Code Java : S�lectionner tout
1
2
3
4
5
int a = 1; 
switch (maVar) { 
    case a:  // Interdit. 
        [...] 
}

Cependant, il est possible d�clarer la variable a avec le mot-cl� final pour la d�clarer en tant que constante�:

Code Java : S�lectionner tout
1
2
3
4
final int a = 1; 
switch (maVar) { 
    case a: // Fonctionne. 
}

Chaine de caract�res
L'instruction switch supporte les String depuis le JDK7. Par exemple�:

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

Pour des versions de Java ant�rieures au JDK7, il n'est pas possible de faire un switch sur un String. Il faudra passer par une s�quence de constructions if-then-else-if�:
Code java : S�lectionner tout
1
2
3
4
5
6
7
if ("A".equals(maString)) { 
    [...] 
} else if ("B".equals(maString)) { 
    [...] 
} else { 
    [...] 
}

Attention�: le switch sur des instances de String s�accommode mal de la valeur null.

Enum
Il est possible d'utiliser des enums dans un switch. Dans ce cas pr�cis, les valeurs des labels doivent reprendre texto les valeurs d�finies dans l'enum sans les pr�fixer par le nom de leur classe�:

Code Java : S�lectionner tout
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; 
}

Attention�: le switch sur des enums s�accommode mal de la valeur null.

Mis � jour le 12 octobre 2006 bouye bulbo

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

Code Java : S�lectionner tout
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.
Voici quelques remarques�:

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

Devant un bloc de code�:

Le mot-cl� static devant un bloc de code indique que celui-ci ne sera ex�cut� qu'une fois. L'ex�cution se fait lors du chargement de la classe par le ClassLoader. On peut utiliser ces blocs, par exemple, pour initialiser des variables statiques complexes.

Code Java : S�lectionner tout
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 . 
   } 
}

Devant une classe interne�:

Pour plus d'informations sur ce cas, reportez-vous � la QR Quels sont les diff�rents types de classes internes (nested classes)�? .

Mis � jour le 7 mai 2015 bouye Ioan

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

Code Java : S�lectionner tout
1
2
3
4
5
interface Person { 
    static void sayHello() { 
        System.out.println("Hello there!"); 
    } 
}

Mis � jour le 21 mars 2015 Mickael Baron

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.

Code Java : S�lectionner tout
1
2
3
4
// Aucune classe fille ne peut red�finir cette m�thode. 
public final void doClick() {  
  [...] 
}

Devant une classe�:
On ne peut pas cr�er de classe d�riv�e de celle-ci. Par exemple, il est impossible de d�river une classe � partir de la classe String de la biblioth�que de base, car elle est d�crite d'une mani�re similaire �:

Code Java : S�lectionner tout
1
2
3
4
// Il est impossible d��tendre cette classe. 
public final class String { 
  [...] 
}

Cela peut aussi bien s'appliquer aux classes normales, qu'aux classes internes ou internes statiques�:

Devant une variable membre ou une variable locale�:
La variable ne peut plus �tre modifi�e apr�s son initialisation, et doit obligatoirement �tre initialis�e une fois (et une seule fois).

Pour une variable membre, elle peut �tre initialis�e de plusieurs mani�res.

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


Pour une variable membre statique, elle peut �tre initialis�e�:

  • 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; 
    }


Pour une variable locale�:

Code java : S�lectionner tout
1
2
3
4
public void methode() { 
  final float flottant = 0.2f; 
  flottant = 0.5f  // Interdit. 
}

Devant un param�tre d'une m�thode�: emp�che l'attribution d'une nouvelle valeur au param�tre.
Par exemple�:

Code java : S�lectionner tout
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. 
}

Pour une variable locale ou pour un param�tre de m�thode, cela permet �galement de r�f�rencer cette variable dans une classe anonyme ou encore une expression lambda qui serait d�finie dans la m�thode.

Mis � jour le 7 mai 2015 bouye Clement Cunin

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

Code java : S�lectionner tout
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. 
   } 
}

� noter que, dans le cas d'une classe interne (non statique), le mot-cl� this permet �galement de r�cup�rer l'instance de la classe englobante�:

Code java : S�lectionner tout
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. 
        } 
    } 
}
Ici, Englobante.this fait donc r�f�rence � l'instance de la classe englobante et this fait r�f�rence � la classe interne.

Ces deux mots-cl�s sont tr�s li�s au concept d'h�ritage.

Mis � jour le 7 mai 2015 bouye Mickael Baron tchize_

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.

Code Java : S�lectionner tout
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); 
    }  
}
Math�matiquement ces deux expressions sont identiques, mais interpr�t�es dans un langage, il en va autrement. Java impose un parenth�sage�: (4*d)/2, et dans notre 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.

Notons que le mot-cl� oblige l'impl�mentation de la JVM � �valuer l'expression tel que pr�vu dans la sp�cification du langage. Ne pas faire usage de ce mot-cl� ne garantit pas que la JVM r�alisera ce calcul de la sorte. Une JVM peut en effet avoir le droit, si la m�thode n'est pas FP-strict, d'utiliser des types interm�diaires diff�rents pour �viter de provoquer un d�passement de capacit� ou pour s'adapter � l'architecture de la machine. Dans ce cas les deux expressions pourraient, en fonction de la JVM, produire des r�sultats diff�rents.

Conclusion�: le mot-cl� strictfp permet de garantir le m�me calcul quelle que soit la machine virtuelle sur laquelle l'op�ration est effectu�e.

Mis � jour le 27 janvier 2003 Clement Cunin

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.

Code Java : S�lectionner tout
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; 
}
Si nous s�rialisons une instance de cette classe, la variable var1 ne sera pas sauvegard�e et lors de la d�s�rialisation, elle prendra la valeur 0, malgr� la pr�sence de la valeur par d�faut 4. L'attribution d'une valeur par d�faut se fait lors de l'instanciation de l'objet�! Or, la m�thode consistant � lire un objet depuis un fichier ne cr�e pas cette instance explicitement. Donc var1 n'est jamais initialis�e avec sa valeur par d�faut. De plus, comme cet attribut est transient, il n'est pas �crit dans le fichier. Cela implique que var1 ne re�oit aucune valeur et contient donc 0.

Ce mot-cl� trouve des applications d�s lors qu'une donn�e sensible ne doit en aucun cas apparaitre dans un fichier. Un mot de passe par exemple. Mais ce mot-cl� peut �galement permettre de ��remettre � z�ro�� certaines valeurs. Dans le cas d'un jeu, on pourra ainsi ne pas sauvegarder le temps de jeu depuis le d�but de la partie.

Mis � jour le 7 mai 2015 bouye Romain

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

Mis � jour le 7 mai 2015

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.

Code Java : S�lectionner tout
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. 
    [...] 
}

Mis � jour le 7 mai 2015 bouye Clement Cunin

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

Code java : S�lectionner tout
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;  
}

� votre avis, qu'affiche l'ex�cution de ce morceau de code�?

Remarque�: le label peut aussi �tre utilis� en conjonction avec le mot-cl� continue. De la m�me mani�re, le label indique � quel niveau de boucle le continue s'applique.

Mis � jour le 22 juillet 2004 bulbo

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

Code Java : S�lectionner tout
1
2
3
public void method (String... args) { 
   //  
}

� l'int�rieur de la m�thode, le param�tre args est un tableau contenant les diff�rents param�tres pass�s � la m�thode. Ainsi, cette m�thode peut s'utiliser de la mani�re suivante�:

Code Java : S�lectionner tout
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 ();

En r�alit�, il ne s'agit ni plus ni moins qu'une nouvelle mani�re de d�clarer une m�thode avec un tableau en param�tre. En effet, pour le compilateur, cette d�claration correspond � la d�claration d'une m�thode avec un tableau de String (String[]) en param�tre. Et lors de son utilisation, les diff�rents param�tres de l'ellipse sont automatiquement stock�s dans un tableau. Ainsi, les exemples d'utilisations ci-dessus correspondent en r�alit� au code suivant�:

Code Java : S�lectionner tout
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[]{});

Attention�: on ne peut toutefois utiliser qu'un seul type d'argument variable par m�thode, et il doit obligatoirement �tre en derni�re position dans la liste des param�tres.

Mis � jour le 7 mai 2015 adiGuba bouye

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

Code Java : S�lectionner tout
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() { 
    [...] 
}

Cependant, il devient assez p�nible � la longue de devoir �crire le nom long de la classe partout dans le code�; encore plus quand le code est tr�s long.

En utilisant un import dans l�ent�te du fichier, il est possible d�sormais d'utiliser le nom court de la classe partout o� celle-ci est r�f�renc�e. Notre code devient donc�:

Code Java : S�lectionner tout
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() { 
    [...] 
}

Lors de la compilation, le compilateur remplacement automatiquement toutes les occurrences du nom court MaClasse par le nom long mon.paquet.a.moi.MaClasse.

Note�: il est �galement possible d'utiliser un import wildcard (large) qui permettra d'utiliser le nom court de toutes les classes de ce package�:

Code Java : S�lectionner tout
import mon.paquet.a.moi.*;

Mis � jour le 28 septembre 2015 bouye

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

Code Java : S�lectionner tout
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); 
    } 
}
Code Java : S�lectionner tout
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); 
    } 
}

Ce m�canisme est proche du mot-cl� using namespace du C++. Toutefois, il est conseill� de limiter son utilisation afin de faciliter la lecture du code et �viter des conflits potentiels. On peut pour cela importer seulement l'�l�ment qui nous int�resse, par exemple�:

Code Java : S�lectionner tout
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"); 
    } 
}

Mis � jour le 7 mai 2015 adiGuba bouye

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

Code Java : S�lectionner tout
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(); 
    } 
}

Ici, nous avons d� utiliser le nom long de la classe. Utiliser le mot-cl� import permet de supprimer cet inconv�nient en indiquant � l'avance dans quel package se situe la classe ClasseA et permet donc d'�crire�:
Code Java : S�lectionner tout
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(); 
    } 
}

Ici, nous avons pu utiliser le nom court de la classe. On se retrouve avec la m�me �criture que si la classe ClasseA �tait dans le m�me package que la classe ClasseB.

Supposons maintenant que la classe ClasseA poss�de la m�thode statique suivante�:

Code Java : S�lectionner tout
1
2
3
public static void staticMethod() { 
    [...] 
}

Pour l'appeler depuis la classe ClasseB, il faut normalement �crire

Code Java : S�lectionner tout
ClasseA.staticMethod();

Ici, nous avons r�f�renc� le nom de la m�thode en utilisant le nom de la classe. En faisant un import static de la m�thode, on se retrouve comme si la m�thode statique faisait partie de la classe ClasseB�; ce qui nous permet d'�crire�:

Code Java : S�lectionner tout
1
2
3
4
5
import static package_a.ClasseA.staticMethod; 
  
[...] 
  
staticMethod();

Ces deux clauses d'importation sont ind�pendantes, si je ne fais que le import, je pourrais �crire�:

Code Java : S�lectionner tout
ClasseA

mais je devrais �crire�:

Code java : S�lectionner tout
ClasseA.staticMethod();

� l'inverse je pourrais tr�s bien ne faire que l'import static et je me retrouverais � devoir �crire�:

Code Java : S�lectionner tout
package_a.ClasseA

mais � pouvoir �crire directement�:

Code Java : S�lectionner tout
staticMethod();

En r�sum� il est important de bien retenir que�:

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

Mis � jour le 7 mai 2015 le y@m's

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.

Code Java : S�lectionner tout
(condition)? r�sultat_1�: r�sultat_2

Si la condition est v�rifi�e alors le r�sultat est r�sultat_1�; sinon, c'est r�sultat_2.
� noter que r�sultat_1 est �valu� seulement si la condition est v�rifi�e, et que r�sultat_2 est �valu� seulement si la condition n'est pas v�rifi�e.

Cet op�rateur fournit un moyen compact d'�crire une affectation conditionn�e:

Code Java : S�lectionner tout
String chaine = (nouvelleChaine�!= null)? nouvelleChaine�: "";

� la place de�:

Code Java : S�lectionner tout
1
2
3
4
String chaine = ""; 
if (nouvelleChaine�!= null) { 
    chaine = nouvelleChaine; 
}

Attention�: utilis� abusivement, il devient rapidement illisible.

Mis � jour le 21 octobre 2015 JMLLB

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.


Comment d�pr�cier une entit�?
Si vous cr�ez une biblioth�que ou du code destin� � �tre utilis� par quelqu'un d'autre, vous pourriez �tre amen� � d�conseiller l'emploi d'une entit� (membre, d'une m�thode ou d'une classe).

Pour les versions les plus anciennes de Java (de Java�1.1 � Java�5), un simple tag javadoc @deprecated dans la documentation de cette entit� suffit. Par exemple�:

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

Depuis Java�5, il est �galement possible d'utiliser l'annotation @Deprecated. Par exemple�:

Code Java : S�lectionner tout
1
2
3
4
5
6
public class MaClass { 
    @Deprecated 
    public void maMethodeDepreciee() { 
        [...] 
    }  
}

Le tag javadoc @deprecated et l'annotation @Deprecated peuvent �tre utilis�s en m�me temps.

Mis � jour le 7 mai 2015 bouye Clement Cunin

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

Code Java : S�lectionner tout
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.

Ici, t, un tableau, est une instance de la classe int[] qui �tend elle-m�me la classe Object (toutes les classes Java h�ritent de cette classe)�; les deux premiers tests retournent donc la valeur true. Cependant, le 3e et le 4e tests ne compilent pas puisque la classe int[] n�h�rite ni n'est un des anc�tres des classes Object[] et String�: elles sont incompatibles et les classes Object[] et String sont non valides�; donc le compilateur rejette ces expressions. Nous pouvons cependant contourner le probl�me en stockant la valeur de t dans une variable o d'un type commun � toutes les classes (ici, Object).

De la m�me mani�re�:

Code Java : S�lectionner tout
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.

Ici, p, un objet, est une instance la classe Point qui �tend elle-m�me la classe Object (toutes les classes Java h�ritent de cette classe)�; les deux premiers tests retournent donc la valeur true. Cependant, le 3e et le 4e tests ne compilent pas puisque la classe Point n�h�rite ni n'est un des anc�tres des classes Object[] et String�: elles sont incompatibles et les classes Object[] et String sont non valides�; donc le compilateur rejette ces expressions. Nous pouvons cependant contourner le probl�me en stockant la valeur de p dans une variable o d'un type commun � toutes les classes (ici, Object).

Lorsqu'un test effectu� avec instanceof r�ussit, alors il est possible d'effectuer un cast entre la valeur et la classe test�e sans jamais g�n�rer d'exception de type ClassCastException�:

Code Java : S�lectionner tout
1
2
3
4
Object o = new Point(); 
if (o instanceof Point) { 
    Point p = (Point)b; // Ce cast ne l�ve jamais de ClassCastException. 
}

Lorsque la valeur � tester est null, le test �choue et retourne tout le temps la valeur false.

Par exemple�;

Code Java : S�lectionner tout
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.

Mis � jour le 9 juin 2015 bouye

Le mot-cl� throw (��jette�� � l�imp�ratif) est une instruction qui permet de lancer une exception.

Par exemple�:

Code Java : S�lectionner tout
1
2
IOException ex = new IOException("Erreur de lecture sur le fichier�!"); 
throw ex;

Ici, nous cr�ons une nouvelle exception de type IndexOutOfBoundsException et nous la lan�ons imm�diatement. Son lancement interrompt le flot d�ex�cution du programme et cette erreur va remonter la pile d�ex�cution des appels de fonctions jusqu'� ce qu'elle soit captur�e. Suivant le type de l'exception, il peut �tre n�cessaire de la d�clarer dans la signature de la m�thode en y ajoutant le mot-cl� throws (avec un s � la fin).

Mis � jour le 16 septembre 2015 bouye

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

Code Java : S�lectionner tout
1
2
3
public void MaMethode() throws IndexOutOfBoundsException, IOException, NullPointerException { 
    [...] 
}

Ici, la signature de la m�thode MaMethode() indique que cette derni�re peut g�n�rer des exceptions de type IndexOutOfBoundsException, IOException et NullPointerException. Il s'agit d'une indication que tout code appelant cette m�thode doit se pr�parer � g�rer ces exceptions en cas d'erreur d�ex�cution de la m�thode. Certaines d�clarations et certains traitements sont obligatoires en fonction du type de l'exception g�n�r�e.

Mis � jour le 16 septembre 2015 bouye

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

Code Java : S�lectionner tout
1
2
3
try { 
    [...] // Op�ration pouvant g�n�rer une exception. 
}

Dans les JDK les plus r�cents, un bloc try permet �galement de s'assurer de la fermeture automatique de certaines ressources (fichier, flux, socket, etc.) ce qui �vite de devoir les g�rer manuellement.

Mis � jour le 16 septembre 2015 bouye

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

Code Java : S�lectionner tout
1
2
3
4
5
try { 
    [...] // Op�ration pouvant g�n�rer une exception. 
} catch (MonException ex) { 
    [...] // Traitement de l'erreur. 
}

Plusieurs blocs catch peuvent �tre positionn�s les uns apr�s les autres pour g�rer diff�rents types d'exceptions et il est �galement possible, dans les JDK les plus r�cents, de capturer plusieurs types d'exceptions dans un m�me bloc catch

Mis � jour le 16 septembre 2015 bouye

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

Code Java : S�lectionner tout
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. 
}

Ou�:

Code Java : S�lectionner tout
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. 
}

Mis � jour le 16 septembre 2015 bouye

Proposer une nouvelle r�ponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plut�t sur le forum de la rubrique pour �a


R�ponse � la question

Liens sous la question
pr�c�dent sommaire suivant
 

Les sources pr�sent�es sur cette page sont libres de droits et vous pouvez les utiliser � votre convenance. Par contre, la page de pr�sentation constitue une �uvre intellectuelle prot�g�e par les droits d'auteur. Copyright � 2025 Developpez Developpez LLC. Tous droits r�serv�s Developpez LLC. Aucune reproduction, m�me partielle, ne peut �tre faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'� trois ans de prison et jusqu'� 300 000 � de dommages et int�r�ts.