FAQ Langage JavaConsultez toutes les FAQ

Nombre d'auteurs : 41, nombre de questions : 296, dernière mise à jour : 8 mars 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 langage (166)
précédent sommaire suivant
 

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

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

Ce code décrit une classe publique nommée Hello.
Cette classe est contenue dans un package nommé test.
Cette classe contient une méthode publique statique nommée main() qui sert de point d’entrée à notre programme.
Cette méthode prend en paramètre un tableau de chaînes de caractères noté String[] et nommé args.
Dans le corps de cette méthode, nous imprimons la chaine de caractères « Hello World! » sur la console en invoquant la méthode println() d'un membre public statique out situé dans une classe nommée System (ou plus exactement java.lang.System).

Attention : à partir de maintenant, la casse des lettres (majuscules/minuscules) est importante.

Pour compiler ce programme :
  • 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.


Une fois les sources compilées, pour lancer ce programme :
  • 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!


Félicitations ! Vous venez de compiler, puis de lancer votre tout premier programme écrit en Java.

Vous pouvez bien sûr procéder de manière similaire en créant un nouveau projet dans un IDE tel que NetBeans, Eclipse ou encore IntelliJ IDEA. La procédure exacte varie d'IDE en IDE, mais sur le principe cela reste identique :

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


Vous devriez voir le message Hello World! s'afficher dans l’écran ou la palette de sortie de votre projet.

Mis à jour le 7 mai 2015 bouye Mickael Baron

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 :

Code Java : Sélectionner tout
1
2
3
4
int unEntier; 
float unFlottant = 5.5f; 
String maChaine; 
Voiture maVoiture;

Expression
Une expression effectue le plus souvent une action en affectant une valeur dans une variable, ou encore en invoquant une méthode. Une expression peut elle-même avoir un type.

Par exemple :

Code Java : Sélectionner tout
1
2
3
4
5
6
unEntier++; 
unFlottant += 8.75f; 
maChaine = trouverLeDernierAcquereur(); 
maVoiture = new Voiture(); 
maVoiture.demarre(); 
System.out.println("Salut le monde !");

Structure de contrôle
Une structure de contrôle permet de contrôler le flot du programme, ce qui permet, entre autres, de sauter des blocs d'instructions en effectuant des tests ou encore de répéter un même bloc d'instruction un certain nombre de fois. Les structures de contrôle peuvent souvent faire plusieurs lignes et ne pas avoir de terminaison par un ;.

Par exemple :

Code Java : Sélectionner tout
1
2
3
4
if (unEntier < 5) { 
    // Faire quelque chose. 
    [...] 
}

Ou :

Code Java : Sélectionner tout
1
2
3
4
for (int index = 0 ; index < 10 ; index++) { 
    // Faire quelque chose. 
    [...] 
}

Ou encore :

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

Mis à jour le 8 juin 2015 bouye

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 :

Code Java : Sélectionner tout
1
2
3
4
public class Hello { 
    // Contenu du bloc. 
    [...] 
}

Ou une méthode :

Code Java : Sélectionner tout
1
2
3
4
public static void main(String[] args) {  
    // Contenu du bloc. 
    [...] 
}

Nous verrons par la suite que d'autres structures de contrôles telles que les boucles for, while ou les tests if ou switch définissent également des blocs. Il est également souvent possible de définir des blocs à l’intérieur d'autres blocs bien que leur signification exacte puisse varier suivant la manière dont ils sont déclarés :

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

Mis à jour le 8 juin 2015 bouye

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 :

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


Ici, le premier bloc ne voit que la variable a ; la variable b lui est inconnue. Le second bloc peut par contre accéder aux deux variables, a et b. Mais aucun de ces deux blocs ne peut accéder à la variable c. De même, le troisième bloc ne voit ni a, ni b. Depuis l’extérieur de ces trois blocs, aucune variable n'est visible.

Note : en cas particulier, on peut citer les modificateurs d’accès qui permettent de référencer, utiliser et d’accéder aux membres, méthodes et classes internes d'une classe depuis l’extérieur du bloc de code défini par la classe.

Mis à jour le 8 juin 2015 bouye

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.

Mis à jour le 14 mai 2015 bouye

  • Literals dans les spécifications du langage Java.

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.

Mis à jour le 13 mai 2015 bouye

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.


Cependant, à partir du JDK 1.5, le compilateur supporte le mécanisme d'auto-boxing/auto-unboxing qui permet de bénéficier d'un mécanisme de conversion implicite entre les types primitifs et les types wrapper objets équivalents.

Mis à jour le 13 mai 2015 bouye

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.

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

Tenter d'invoquer une méthode ou d'accéder à un membre d'instance sur une référence vide génèrera une exception de type java.lang.NullPointerException.

Code Java : Sélectionner tout
1
2
String chaine = null; 
chaine.length(); // Génère une NullPointerException.

La valeur null est un literal mais ne dispose pas d'un type wrapper. Cependant, depuis le JDK 1.1, l'API Java dispose de la classe java.lang.Void (avec un grand V) dont la seule valeur légale possible est la valeur null.

Code Java : Sélectionner tout
1
2
3
4
public Void maMethode() { 
   [...] 
   return null; // Null est la seule valeur possible. 
}

Attention : contrairement à d'autres langages de programmation, la valeur null ne dénote pas une adresse mémoire à l'index 0.

Mis à jour le 10 juillet 2015 bouye

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 :

Code Java : Sélectionner tout
boolean test = (maReference == null);

Ou encore :

Code Java : Sélectionner tout
1
2
3
4
 if (maReference == null) { 
   // Traitement à effectuer en cas de référence nulle. 
   [...] 
}

Ou :

Code Java : Sélectionner tout
1
2
3
4
 if (maReference != null) { 
   // Traitement à effectuer en cas de référence non nulle. 
   [...] 
}

Attention : la valeur null ne dénote pas une adresse mémoire à l'index 0. Et il n'est pas valide de tester l'égalité d'une référence avec la valeur 0 pour tenter de vérifier si elle est vide. Par exemple, de manière générale, le code suivant ne compile pas et n'est pas un test correct pour vérifier qu'une référence est à la valeur null :

Code Java : Sélectionner tout
1
2
boolean testNull = (maReference == 0); // Test non valide. 
boolean testNonNull = (maReference != 0); // Test non valide.

Note : ce code peut cependant compiler si maReference est un type numérique qui peut être converti en un type primitif par le mécanisme d'auto-unboxing. Le test pour vérifier si la référence est null reste cependant non valide, et ce bout de code peut même mener à une NullPointerException si la référence est vide.

Méthodes de la classe Objects
Depuis le JDK 7, il est possible d'invoquer la méthode publique statique isNull() de la classe utilitaire java.util.Objects pour tester si une référence est à la valeur null. Cette méthode renvoie la valeur true si la référence contient la valeur null. La méthode publique statique nonNull() permet d'effectuer le test opposé.

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

La classe utilitaire java.util.Objects dispose, de plus, de plusieurs variantes de la méthode publique statique requireNonNull() qui génère une exception de type NullPointerException lorsque la référence testée est à la valeur null. Cette méthode est utile pour, par exemple, valider les paramètres reçus dans une méthode et signaler les exceptions nécessaires dans le cas contraire.

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

Mis à jour le 10 juillet 2015 bouye

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 :

Code Java : Sélectionner tout
1
2
3
4
// Commentaire #1. 
int unEntier = 5; // Commentaire #2. 
// Commentaire #3. 
// Commentaire #4.

Commentaires sur plusieurs lignes
Les commentaires sur plusieurs lignes débutent par le séparateur /* (une barre oblique suivie d'une « étoile » ou star). Tout ce qui est situé après ce séparateur, y compris les sauts de ligne et retours chariot sera considéré comme un commentaire et sera donc ignoré par le compilateur. Pour terminer ce commentaire, il faut utiliser le séparateur */.

Par exemple :

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

Commentaires de documentation
Les commentaires de documentation sont une extension des commentaires sur plusieurs lignes. Ils débutent par le séparateur /** (barre oblique suivie de deux étoiles) et se termine par le séparateur */. Ces commentaires permettent d'attacher de la documentation sur des membres, méthodes ou classes pour décrire leur comportement, leur condition d'utilisation, les cas particuliers, les plages de valeurs retournées ou encore les exceptions signalées en cas d'erreur. Il est possible d'y ajouter du code via des balises HTML ou encore de rajouter des balises de documentation (javadoc tag ou documentation tag) qui permettront de formater correctement la page lorsque la documentation destinée aux développeurs sera générée à partir du code source. Les IDE modernes (NetBeans, Eclipse, IntelliJ IDEA, etc.) peuvent également afficher cette documentation lorsque vous êtes en train d'éditer du code dans cet IDE ce qui facilite le développement.

L’outil le plus connu pour générer la documentation à partir du code est le compilateur de documentation javadoc qui est fourni avec le JDK. Cependant, il est tout à fait possible d'utiliser des outils tiers, par exemple Doxygen, pour générer des pages de documentation équivalentes. Les balises à utiliser et les formats de sortie supportés de même que la présentation finale de la documentation dépendent bien sûr de l'outil que vous utiliserez pour vos propres projets.

Prenons, par exemple, la méthode contains() de la classe java.lang.String. Si on accède au code source de cette classe contenu dans le JDK ou via le dépôt de code de l'OpenJDK, on peut lire :

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

Lorsque l'outil javadoc est lancé sur le code de cette classe, ces quelques lignes de commentaires de description de cette méthode vont servir à construire une section de description de la méthode contains() qui va venir s’insérer dans la page de documentation de la classe String dans la documentation de l'API Java. Le générateur de documentation ignorera bien sûr les commentaires normaux et ne prendra en compte que les commentaires de documentation.

Mis à jour le 9 juin 2015 bouye

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 :

Code HTML : Sélectionner tout
1
2
3
4
5
6
<HTML> 
    <BODY> 
        Documentation du package <b>com.masociete.monpack</b>. 
        @since 1.0 
    </BODY> 
</HTML>

Depuis le JDK 5, le fichier package.html peut être remplacé par un fichier source Java spécial nommé package-info.java. Ce fichier ne doit contenir que la ligne de déclaration du package, avec ses commentaires javadoc et surtout ses éventuelles annotations. Par exemple :

Code Java : Sélectionner tout
1
2
3
4
5
6
/** 
 * Documentation du package <b>com.masociete.monpack</b>. 
 * @since 1.0 
 */ 
@MonAnnotation 
package com.masociete.monpack;

Mis à jour le 10 octobre 2015 adiGuba

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

Mis à jour le 7 juillet 2015 bouye

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.

Code java : Sélectionner tout
1
2
System.gc (); 
//Appel explicite au Garbage collector
Néanmoins, cette méthode ne garantit pas le passage du GC. Elle permet seulement d'augmenter la probabilité que le GC se déclenche. Il est préférable de mieux gérer ses objets plutôt que d'utiliser cette méthode.

Mis à jour le 10 octobre 2015 Clement Cunin

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.

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

Mis à jour le 10 octobre 2015 Clement Cunin

En utilisant la méthode:

Code java : Sélectionner tout
Class c = Class.forName("com.developpez.MaClasse");
On utilise le ClassLoader du système. Ce ClassLoader cache l'information et ne rechargera pas la classe lors d'un nouvel appel a forName, et ce même si le fichier « .class » a changé depuis le dernier chargement.

Il y a deux solutions :

1 - la classe n'est pas présente dans le CLASSPATH

C'est le cas le plus simple, il suffit d'utiliser un nouveau URLClassLoader à chaque fois pour recharger une nouvelle version de la classe.

Code java : Sélectionner tout
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");
Attention, il faut créer à chaque fois un nouvel URLClassLoader, sinon la classe est cachée par le loader.

Si la classe est présente dans le CLASSPATH c'est le ClassLoader du système qui la charge (et la met dans son cache).

2 - La classe est présente dans le CLASSPATH

Dans ce cas, on ne peut pas utiliser l'URLClassLoader. Il faut créer son propre ClassLoader qui hérite de la classe ClassLoader
Code java : Sélectionner tout
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;  
  }  
}
Dans ce code, nous avons créé une nouvelle méthode « loadNewClass » qui recharge le fichier « .class » à chaque fois.

Le fait de ne pas avoir redéfini la méthode loadClass permet à ce nouveau ClassLoader d'utiliser le ClassLoader du système pour charger d’éventuelles classes mères ou interfaces.

Si la méthode loadClass est redéfinie il faut qu'elle puisse aussi trouver les super-classes et interfaces des classes qui seront chargées, et ce, sans recharger celles déjà présentes dans le système.

Mis à jour le 10 octobre 2015 bulbo

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 :

Code java : Sélectionner tout
1
2
3
public String getReference(Object anObject){  
    return anObject.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(anObject)); 
}

Mis à jour le 10 octobre 2015 bulbo

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 1er 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).

Code java : Sélectionner tout
1
2
3
4
long start = System.currentTimeMillis(); 
// ... instructions à chronométrer 
long duree = System.currentTimeMillis() - start; 
System.out.println(duree);

System.nanoTime()

Depuis le JDK 5, il est possible d'utiliser la méthode statique nanoTime() de la classe System. Elle renvoie un long représentant la valeur du timer en nanosecondes.

Code java : Sélectionner tout
1
2
3
4
long start = System.nanoTime(); 
// ... instructions à chronométrer 
long duree = System.nanoTime() - start; 
System.out.println(duree);

Ce temps n'est pas lié à un référentiel de temps universel, aussi ne doit-on l'employer que pour mesurer une différence de temps. La précision est de l'ordre de la nanoseconde.

Il faut aussi noter que ce n'est pas exactement le temps utilisé par votre application, mais le temps qui s'est écoulé depuis le début à la fin de votre code. Pendant ce temps, d'autres applications tournent sur votre ordinateur et utilisent ce qu'on appelle du temps CPU. Pour connaître exactement le temps CPU nécessaire, il faut utiliser la méthode getCurrentThreadCpuTime() de l'interface java.lang.management.ThreadMXBean à la place de System.nanoTime() ou currentTimeMillis() et vous aurez le temps CPU.

Mis à jour le 10 octobre 2015 bentechno bigboomshakala

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 © 2017 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.

 
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -