FAQ Langage JavaConsultez toutes les FAQ

Le code suivant vous pr�sente l�impl�mentation du 1^er code type pour d�butant qui affiche ��hello world!�� (��Salut le monde�!��) sur la console�:

1
2
3
4
5
6
7
package test; 
  
public class Hello { 
    public static void main(String[] args) { 
        System.out.println("Hello World!"); 
    } 
}

• cr�ez-vous un nouveau r�pertoire vide dans lequel vous allez travailler�;
• dans ce r�pertoire de travail, cr�ez un nouveau r�pertoire nomm� test. Le nom de ce r�pertoire doit correspondre exactement � celui du package d�clar� dans l�ent�te de notre classe�;
• dans le r�pertoire test, cr�ez un nouveau fichier texte que vous nommerez Hello.java. Le nom de ce fichier doit correspondre exactement � celui de la classe Hello d�crite dans le code�;
• ouvrez ce fichier dans un �diteur de texte simple quelconque (Vi, Emacs, notepad, etc. �vitez les logiciels de traitement de texte tels que Writer ou Word)�;
• copiez le code ci-dessus dans le fichier�;
• enregistrez le fichier�;
• ouvrez un interpr�teur de commande dans votre r�pertoire de travail�;
• si vous avez correctement configur� votre PATH, vous pouvez directement invoquer le compilateur Java�:
  

  Code console :

  S�lectionner tout

  javac test/Hello.java

  �;
• si la compilation fonctionne sans accro, un nouveau fichier nomm� Hello.class fera son apparition dans le r�pertoire test.
  

• ouvrez un interpr�teur de commande dans votre r�pertoire de travail�;
• si vous avez correctement configur� votre PATH, vous pouvez directement invoquer l�interpr�teur Java�:
  

  Code console :

  S�lectionner tout

  java test.Hello

  �;
• votre programme se lancera et affichera sur la console�:
  

  Code console :

  S�lectionner tout

  Hello World!

• cr�ez un nouveau projet Java vierge (ou Standalone Java Application)�;
• cr�ez un nouveau package nomm� test�;
• dans ce package test, cr�ez une nouvelle classe vierge nomm�e Hello�;
• collez-y le code ci-dessus�;
• enregistrez le fichier�;
• lancez l�ex�cution du projet.
  

Une instruction (ou statement) permet de d�finir une action que la JVM doit ex�cuter telle qu'effectuer la somme de deux valeurs ou encore imprimer un message sur la console. G�n�ralement, une instruction tient sur une seule ligne et se termine par le s�parateur ; (��point-virgule�� ou semi-colon), mais ce n'est pas toujours le cas. Il existe trois types d'instructions.

D�claration
Une d�claration permet de d�crire une variable, son type, et �ventuellement sa valeur.

Par exemple�:

1
2
3
4
int unEntier; 
float unFlottant = 5.5f; 
String maChaine; 
Voiture maVoiture;

1
2
3
4
5
6
unEntier++; 
unFlottant += 8.75f; 
maChaine = trouverLeDernierAcquereur(); 
maVoiture = new Voiture(); 
maVoiture.demarre(); 
System.out.println("Salut le monde�!");

1
2
3
4
if (unEntier < 5) { 
    // Faire quelque chose. 
    [...] 
}

1
2
3
4
for (int index = 0�; index < 10�; index++) { 
    // Faire quelque chose. 
    [...] 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
switch (maChaine) { 
    case "Toto": 
    case "Tata": 
        // Faire quelque chose. 
        [...] 
        break; 
    case "Titi": 
        // Faire quelque chose. 
        [...] 
        break; 
    case "Tutu": 
    default: 
        // Faire quelque chose. 
        [...] 
}

Un bloc en Java est une suite de 0 ou plusieurs instructions qui sont plac�es entre {} (accolades ou curly braces).

Comme nous l'avons vu plus haut, certaines structures ouvrent automatiquement des blocs, par exemple, une classe�:

1
2
3
4
public class Hello { 
    // Contenu du bloc. 
    [...] 
}

1
2
3
4
public static void main(String[] args) {  
    // Contenu du bloc. 
    [...] 
}

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
public class Hello { 
  
    // D�finition d'un bloc statique. 
    static { 
        // Contenu du bloc. 
        [...] 
    } 
  
    // D�finition d'un bloc non statique. 
    { 
        // Contenu du bloc. 
        [...] 
    } 
  
    public static void main(String[] args) {  
        // Contenu de la m�thode. 
        [...] 
        // D�finition d'un bloc dans une m�thode. 
        { 
            // Contenu du bloc. 
            [...] 
        } 
        // Contenu de la m�thode. 
        [...] 
    } 
}

La port�e (ou scope) d�finit l��tendue du code dans lequel vous pouvez utiliser une variable, un membre, une m�thode ou encore une classe apr�s sa d�claration. De mani�re g�n�rale, et sauf cas particulier, une variable, un membre, une m�thode, ou une classe d�clar�s dans un bloc ne sont pas visibles depuis l�ext�rieur de celui-ci. De plus, de mani�re g�n�rale, un sous-bloc peut aussi acc�der aux variables, membres, m�thodes et classes qui sont accessibles ou d�finis dans son bloc parent.

Par exemple�:

1
2
3
4
5
6
7
8
9
10
11
12
 // Premier bloc. 
{ 
    int a = 5; 
    // Second bloc. 
    { 
        int b = -2; 
    } 
} 
// Troisi�me bloc. 
{ 
    int c = 7; 
}

Un literal repr�sente un type de base du langage Java. Ces types sont les valeurs bool�ennes (boolean), num�riques (byte, short, char, int, long, float et double), le type objet sp�cial repr�sentant les chaines de caract�res (String) et la valeur null qui d�note une r�f�rence vide.

Les types bool�ens et num�riques sont dits ��types primitifs�� par opposition aux r�f�rences qui permettent de manipuler des objets.

Les diff�rents types primitifs du langage Java sont�:

Valeurs bool�ennes
Le type boolean permet de d�crire des valeurs bool�ennes qui ne peuvent avoir que deux valeurs�: true et false.

Caract�res
Le type char permet de d�crire des symboles Unicode de la table UTF-16 tels que�: 'a', 'A', '1', '@', '►', etc.

Nombres entiers
Les types byte, short, int et long, ainsi que d'une certaine mani�re le type char, permettent de d�finir des valeurs num�riques enti�res.

Nombres � virgule flottante
Les types float et double permettent de d�finir des valeurs num�riques � virgule flottante.

Tous ces types primitifs disposent de types objet �quivalents, dits wrapper (empaquetant) qui permettent de manipuler ces valeurs comme des objets. Par exemple le type boolean a pour type wrapper la classe java.lang.Boolean tandis que le type int a pour type wrapper la classe java.lang.Integer.

Non, ce n'est pas possible. Un type primitif ne peut pas �tre utilis� comme une r�f�rence. Cela implique�:

• il est impossible pour une variable d'un type primitif d'avoir la valeur null�;
• il est impossible d'invoquer une m�thode ou un membre sur un type primitif�: ils n'en ont aucun�;
• il est impossible d'affecter une valeur primitive dans une r�f�rence sans passer par un m�canisme de conversion implicite ou explicite�;
• il est impossible d'affecter la valeur d'une r�f�rence dans un type primitif sans passer par un m�canisme de conversion implicite ou explicite�;
• il est impossible d'utiliser un type primitif en tant que type g�n�rique dans une collection ou une classe qui supporte les Generics.
  

La valeur null est une valeur sp�ciale qui est affect�e aux r�f�rences d'objets ou de tableaux qui sont vides, c'est-�-dire qui ne contiennent pas d'instance d'objet ou de tableau. On peut la rapprocher de concepts et valeurs similaires dans d'autres langages tels que nil ou void. Toute r�f�rence peut avoir la valeur null ce qui inclut les r�f�rences contenues � l�int�rieur des tableaux ou des collections de m�me que les param�tres ou les valeurs de retour des m�thodes.

1
2
3
4
5
6
7
8
9
10
11
int[] tableau1 = null; // Tableau null. 
String chaine = null; // Chaine null. 
Toto[] tableau2 = { null, null, null, null }; // Tableau contenant null. 
maMethode(null); // Passage de param�tre null. 
  
[...] 
  
public Toto maMethode(Tutu valeur) { 
    [...] 
    return null; // M�thode retournant null. 
}

1
2
String chaine = null; 
chaine.length(); // G�n�re une NullPointerException.

1
2
3
4
public Void maMethode() { 
   [...] 
   return null; // Null est la seule valeur possible. 
}

Il existe plusieurs mani�res de tester si une r�f�rence contient la valeur null�:

Tests == et !=
Le test le plus simple consiste � utiliser le test d��galit� == ou de diff�rence !=. Pour tester qu'une variable r�f�ren�ant un objet est � la valeur null, il suffit de faire, par exemple�:

boolean test = (maReference == null);

1
2
3
4
 if (maReference == null) { 
   // Traitement � effectuer en cas de r�f�rence nulle. 
   [...] 
}

1
2
3
4
 if (maReference�!= null) { 
   // Traitement � effectuer en cas de r�f�rence non nulle. 
   [...] 
}

1
2
boolean testNull = (maReference == 0); // Test non valide. 
boolean testNonNull = (maReference�!= 0); // Test non valide.

1
2
boolean testNull = Objects.isNull(maReference); // Renvoie true si la la r�f�rence est nulle. 
boolean testNonNull = Objects.nonNull(maReference);  // Renvoie false si la la r�f�rence est nulle.

1
2
3
4
public void maMethode(Toto maReference) throws NullPointerException { 
    Objects.requireNonNull(maReference, "Le param�tre ne peut pas �tre null�!"); // G�n�re une exception si la r�f�rence est nulle. 
    [...] // Corps de la m�thode. 
}

Il existe plusieurs mani�res d��crire des commentaires (ou comments) dans du code Java�:

Commentaires sur une seule ligne
Les commentaires sur une seule ligne d�butent par le s�parateur // (deux ��barres obliques�� ou slash). Tout ce qui est situ� apr�s ce s�parateur, et ce, jusqu'� la fin de la ligne, sera consid�r� comme un commentaire et sera donc ignor� par le compilateur. Ces commentaires peuvent �tre plac�s sur leur propre ligne ou apr�s la fin d'une instruction.

Par exemple�:

1
2
3
4
// Commentaire #1. 
int unEntier = 5; // Commentaire #2. 
// Commentaire #3. 
// Commentaire #4.

1
2
3
4
5
6
7
8
9
10
11
/* Ceci est un commentaire multiligne, 
je peux donc sauter des lignes 
sans difficult�. 
Et voici la fin du commentaire. */ 
int unEntier = 5;  
/* Il est aussi assez courant de mettre des �toiles 
 * en d�but de chaque nouvelle ligne, 
 * mais en fait rien ne vous y oblige. 
 * C'est juste une convention de codage plut�t commune. 
 */ 
String maChaine;

1
2
3
4
5
6
7
8
9
10
11
12
/** 
 * Returns true if and only if this string contains the specified 
 * sequence of char values. 
 * 
 * @param s the sequence to search for 
 * @return true if this string contains {@code s}, false otherwise 
 * @since 1.5 
 */ 
public boolean contains(CharSequence s) { 
    // Contenu de la methode. 
    [...] 
}

Pour d�finir les commentaires javadoc au niveau du package, il faut cr�er un fichier HTML nomm� package.html dans le r�pertoire du package. Ce fichier sera lu par l'outil javadoc pour g�n�rer la page de documentation du package, et son contenu (entre les balises <body> et </body>) sera alors utilis� comme commentaire pour le package, par exemple�:

1
2
3
4
5
6
<HTML> 
    <BODY> 
        Documentation du package <b>com.masociete.monpack</b>. 
        @since 1.0 
    </BODY> 
</HTML>

1
2
3
4
5
6
/** 
 * Documentation du package <b>com.masociete.monpack</b>. 
 * @since 1.0 
 */ 
@MonAnnotation 
package com.masociete.monpack;

En Java, les exceptions et les erreurs (errors), sont des objets servant � faire remonter des erreurs lors de l�ex�cution du code. Toutes les exceptions utilis�es dans la JVM ou que vous serez amen�s � impl�menter pour vos propres besoins h�ritent de la classe java.lang.Throwable (throwable signifie ��lan�able��). Cette classe dispose de m�thodes et propri�t�s qui sont donc accessibles par toutes les exceptions utilis�es dans la JVM et celles que vous serez amen� � impl�menter.

Une exception ou une erreur peut contenir un message d�crivant l'erreur et accessible via sa m�thode getMessage(). S'il existe, ce message peut �tre en anglais pour des exceptions fournies dans la JVM ou des biblioth�ques tierces (ou m�me dans une langue arbitraire dans ce dernier cas). Il peut �tre localis� dans la langue de votre syst�me d'exploitation si l'exception Java est g�n�r�e � partir d'une erreur syst�me. Pour vos exceptions personnalis�es, il reste enfin possible de fournir un message localis� en surchargeant la m�thode getLocalizedMessage().

Enfin, une exception ou une erreur permet d�acc�der � une trace, c'est-�-dire un tableau contenant les r�f�rences � l'empilement des classes, m�thodes et lignes de code travers�es jusqu�� l'instruction qui a g�n�r� l'exception. Cette trace peut �tre imprim�e dans la console ou un flux en invoquant une des variantes de la m�thode printStackTrace(). Depuis le JDK�1.4, il est �galement possible d�acc�der � ce tableau en invoquant la m�thode getStackTrace().

Le garbage Collector (ramasse-miette) est la partie de la JVM qui s'occupe de la r�cup�ration des zones m�moire. Les phases de lib�ration de la m�moire sont g�r�es de fa�on autonome, il est inutile de lui dire quand passer.

Il existe n�anmoins la fonction gc de la classe java.lang.System qui permet de faire un appel explicite au garbage collector. Cet appel ne garantit pas que tous les objets inutiles seront supprim�s de la m�moire.

1
2
System.gc (); 
//Appel explicite au Garbage collector

Si les param�tres pass�s au constructeur sont incoh�rents ou que la construction provoque une erreur, la cr�ation de l'objet est impossible et doit �tre annul�e. Comme les m�thodes, les constructeurs peuvent g�n�rer des exceptions, c'est la fa�on la plus simple d'annuler l'ex�cution du constructeur. Techniquement, l'objet est cr�� en m�moire (l'allocation de la m�moire a lieu au moment de l'appel du constructeur), mais l'appelant �tant oblig� de traiter l'exception, le pointeur vers cet objet est perdu et sera donc r�cup�r� par le ramasse-miette.

Une solution plus �l�gante consiste � utiliser une m�thode statique servant de fabrique qui va v�rifier les param�tres et ne fait l'appel au constructeur que si ceux-ci sont corrects.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Test { 
    /** Le constructeur est d�clar� protected  
     * pour interdire son utilisation par les clients de la classe.  
     */ 
    protected Test(int val) { 
    }  
  
    public static Test createTest(int val) { 
        if (val < 100) { 
            return new Test(val); 
        } else { 
            return null; // Ou alors on g�n�re une exception...  
        }  
    }  
}

En utilisant la m�thode:

Class c = Class.forName("com.developpez.MaClasse");

1
2
3
4
  // le chemin o� trouver la classe � recharger  
  URL chemins[] = { new URL("file:/C:/MesClasses/") };  
  URLClassLoader loader = new URLClassLoader(chemins);  
  Class c = loader.loadClass("com.developpez.MaClasse");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.io.InputStream;  
  
public class MonLoader extends ClassLoader {  
  
  public Class loadNewClass(String aName) throws Exception {  
    InputStream is = getClass().getResourceAsStream("/" + aName);  
    if (null == is) {  
      return null;  
    }  
  
    byte buffer[] = new byte[is.available()];  
    is.read(buffer);  
    Class c = defineClass(aName, buffer, 0, buffer.length);  
    resolveClass(c);  
    return c;  
  }  
}

La m�thode toString() de la classe Object affiche le nom de l'objet suivi de la r�f�rence de l'objet dans la machine virtuelle (une sorte de pointeur).

Ceci peut s'av�rer utile parfois lors d'une phase de d�bogage, mais comment faire lorsqu'une classe (comme la classe String par exemple) red�finit la m�thode toString()�?

Il faut passer par la m�thode System.identityHashCode(Object).

Le code suivant retourne la m�me chose que le toString() d'Object pour n'importe quel type d'objet�:

1
2
3
public String getReference(Object anObject){  
    return anObject.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(anObject)); 
}

System.currentTimeMillis()

En utilisant la m�thode statique currentTimeMillis() de la classe System. Cette m�thode renvoie un long repr�sentant la diff�rence de temps entre le 1^er janvier 1970 � minuit et le temps syst�me � l'ex�cution de l'instruction. Cette diff�rence s'exprime en fonction de l'unit� de temps de l'OS (la milliseconde, voire quelques dizaines de millisecondes).

1
2
3
4
long start = System.currentTimeMillis(); 
// ... instructions � chronom�trer 
long duree = System.currentTimeMillis() - start; 
System.out.println(duree);

1
2
3
4
long start = System.nanoTime(); 
// ... instructions � chronom�trer 
long duree = System.nanoTime() - start; 
System.out.println(duree);

Il se peut que vous ayez d�j� rencontr� un cas de figure o� vous souhaitiez modifier l'une de vos valeurs (par exemple un Integer) pass�e en param�tre dans le corps de la m�thode :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class MyClass { 
    public static void main(String args[]) { 
        final A a = new A(); 
        Integer integer = 0; 
        a.increment(integer); 
        if (integer != 1) { 
            throw new RuntimeException(String.format("`integer` is equal to %d instead of 1.", integer)); 
        } 
    } 
} 
  
class A { 
    public void increment(Integer integer) { 
        integer += 1; // Ici, nous n'op�rons pas sur une r�f�rence mutable de `integer`. 
        // `integer` est pass� par valeur ici. 
    } 
}

Exception in thread "main" java.lang.RuntimeException: `integer` is equal to 0 instead of 1.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.concurrent.atomic.AtomicReference; 
  
public class MyClass { 
    public static void main(String args[]) { 
        final A a = new A(); 
        AtomicReference<Integer> integer = new AtomicReference<>(0); // on enveloppe notre entier  
        // avec une instance de `AtomicReference`. 
        a.increment(integer); // vaut 1. 
        if (integer.get() != 1) { 
            throw new RuntimeException(String.format("`integer` is equal to %d instead of 1.", 0)); 
        } 
        // pas d'erreur. 
    } 
} 
  
class A { 
    public void increment(AtomicReference<Integer> integer) { 
        integer.set(1); // on met � jour `integer` se trouvant dans `main`. 
    } 
}

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
public class MyClass { 
  
    public static void main(String args[]) { 
        ReferenceHandler<Integer> handler = new ReferenceHandler<>(117); 
        modify(handler); 
  
        if (handler.get() != 259) { 
            throw new RuntimeException("`handler.get()` isn't equal to 259."); 
        } 
        else { 
            System.out.println("`handle.get()` is equal to 259."); 
        } 
    } 
  
    public static void modify(ReferenceHandler<Integer> handler) { 
        handler.set(259); 
    } 
} 
  
class ReferenceHandler<T> { 
  
    private T value; 
  
    public ReferenceHandler(T value) { 
        this.value = value; 
    } 
  
    public void set(T newValue) { 
        this.value = newValue; 
    } 
  
    public T get() { 
        return this.value; 
    } 
  
}

1
2
 
`handle.get()` is equal to 259.