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.