Faq java

FAQ Java

Date de publication : 12/10/2006

Dernière mise à jour : 07/06/2009

Cette faq a été réalisée à partir des questions fréquemment posées sur les forums de
http://www.developpez.com et de 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 Comment participer à
cette faq ?.

Sur ce, nous vous souhaitons une bonne lecture.

L'équipe Java

Ont contribué à cette FAQ :

bazinou - bobuse - iubito - Clément Cunin - Johann Heymes -
Ronan Le Gallo - Christophe Ludet - Jean-Baptiste Bugeaud
- Grégory Danelon - Sébastien Meric - Romain Guy - Pierre-
Yves Varoux - Ioan Calapodescu - bahamouth - duj - braim
- bulbo - Ricky81 - L'équipe Java - Debernad - jcarre -
Seigne David - cyberzoide - xavlours - christopheJ - willowII
- Nourdine Falola - laffreuxthomas - adiGuba - aDamas -
mavina - Baptiste Wicht - NiCo5130 - elitost - jeje99 - afrikha
- Morpheus2144 - vasilov - le y@m's - romuluslepunk -
JMLLB - djo.mos - glob - osopardo - sironimo - divxdede -
natha - Pierre Chauvin - tchize - sinok - mlny84 - gifffftane -

FAQ Java

1. Informations générales (5) .........................................................................................................................................................4
2. Concepts fondamentaux (52) .....................................................................................................................................................7
2.1. Les mots-clés (17) .......................................................................................................................................................... 17
2.2. Les notions (17) ..............................................................................................................................................................30
3. Généralités (79) ....................................................................................................................................................................... 47
3.1. Gestion des nombres et chaînes de caractères (25) ....................................................................................................... 48
3.2. Gestion des dates (8) ...................................................................................................................................................... 65
3.3. Gestion des threads (6) ...................................................................................................................................................69
3.4. Structures de données -Tableaux et collections (18) ..................................................................................................... 72
3.5. La reflexivité (16) ...........................................................................................................................................................84
3.6. De C++ à Java (4) ..........................................................................................................................................................91
3.7. JNI (2) .............................................................................................................................................................................93
4. Fichiers, flux et réseaux (32) .................................................................................................................................................. 95
4.1. Flux et fichiers (21) ........................................................................................................................................................96
4.2. Sérialisation (4) .............................................................................................................................................................108
4.3. Réseaux (7) ................................................................................................................................................................... 110
5. Le développement (23) ..........................................................................................................................................................115
5.1. Installation et compilation (2) ...................................................................................................................................... 116
5.2. Exécution (6) ................................................................................................................................................................ 118
5.3. Les erreurs et exceptions (7) ........................................................................................................................................ 122
5.4. Les warnings (8) ........................................................................................................................................................... 125
6. Système (14) .......................................................................................................................................................................... 131
7. Astuces et divers (25) ............................................................................................................................................................139

-3-
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le reste, ce document constitue une oeuvre
intellectuelle protégée par les droits d'auteurs. Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs : -
Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la la licence GNU FDL traduite en français ici. Permission vous est donnée
de distribuer, modifier des copies des contributions de Clément Cunin et Johann Heymes tant que cette note apparaît clairement : "Ce document issu de http://
www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission vous est donnée de distribuer, modifier des copies de cette page
tant que cette note apparaît clairement". - Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.

FAQ Java

Sommaire > Informations générales
Comment bien utiliser cette faq ?
Auteurs : L'équipe Java ,
Le but :
Cette faq a été conçue pour être la plus simple possible d'utilisation. Elle tente d'apporter des réponses simples et
complètes aux questions auxquelles sont confrontés tous les débutants (et les autres).

L'organisation :
Les questions sont organisées par thème, les thèmes pouvant eux-même contenir des sous-thèmes. Lorsqu'une question
porte sur plusieurs thèmes, celle-ci est insérée dans chacun des thèmes rendant la recherche plus facile.

Les réponses :
Les réponses contiennent des explications et des codes sources. Certaines sont complétées de fichier à télécharger
contenant un programme de démonstration. Ces programmes sont volontairement très simples afin qu'il soit aisé de
localiser le code intéressant. Les réponses peuvent également être complétées de liens vers d'autres réponses, vers la
documentation en ligne de Sun ou vers un autre site en rapport.

Nouveautés et mises à jour :
Lors de l'ajout ou de la modification d'une question/réponse, un indicateur est placé à coté du titre de la question.
Cet indicateur reste visible pour une durée de 15 jours afin de vous permettre de voir rapidement les modifications
apportées.

J'espère que cette faq pourra répondre à vos questions. N'hésitez pas à nous faire part de tous commentaires/remarques/
critiques.

lien : Comment participer à cette faq ?

Comment participer à cette faq ?
Cette faq est ouverte à toute collaboration. Pour éviter la multiplication des versions, il serait préférable que toutes
collaborations soient transmises aux administrateurs de la faq.
Plusieurs compétences sont actuellement recherchées pour améliorer cette faq :

Rédacteur :
Bien évidemment, toute nouvelle question/réponse est la bienvenue.

Web designer :
Toute personne capable de faire une meilleur mise en page, une feuille de style ou de belles images...

Correcteur :

-4-

FAQ Java

Malgré nos efforts des fautes d'orthographe ou de grammaire peuvent subsister. Merci de contacter les administrateurs
si vous en débusquez une... Idem pour les liens erronés.

lien : Quels sont les droits de reproduction de cette FAQ ?

Quels sont les droits de reproduction de cette FAQ ?
Les codes sources présentés sur cette page sont libres de droits, et vous pouvez les utiliser à votre convenance. Pour le
reste, ce document constitue une oeuvre intellectuelle protégée par les droits d'auteurs.

Ce document issu de http://www.developpez.com est soumis à deux licences, en fonction des contributeurs :

- Les contributions de Clément Cunin et Johann Heymes sont soumises aux termes de la licence GNU FDL traduite
en français ici. Permission vous est donnée de distribuer, modifier des copies des contributions de Clément Cunin et
Johann Heymes tant que cette note apparaît clairement :
"Ce document issu de http://www.developpez.com est soumis à la licence GNU FDL traduite en français ici. Permission
vous est donnée de distribuer, modifier des copies de cette page tant que cette note apparaît clairement".

- Pour ce qui est des autres contributions : Copyright © 2004 Developpez LLC : Tous droits réservés Developpez LLC.
Aucune reproduction, ne peux en être faite sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon
la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts. Cette page est déposée à la SACD.

Où trouver d'autres sources d'information ?
•
Les cours et didacticiels de www.developpez.com
•
Les forums de la section Java de www.developpez.com
•
La FAQ Struts
•
La Javadoc : toutes les informations utiles sur les classes, leurs méthodes ... à toujours avoir sous la main.
•
Les didacticiels de Sun
•
La FAQ de JGuru, beaucoup plus complète que celle-ci ...

Remerciements
Un grand merci à tous ceux qui ont pris de leur temps pour la réalisation de cette FAQ.

Aux rédacteurs :
Remerciements tout d'abord à tous ceux qui ont rédigé les questions et les réponses.
Clément Cunin, Johann Heymes, Nicolas Cuny, Ronan Le Gallo, Christophe Ludet, Jean-Baptiste Bugeaud, Sebastien
Andreo, Grégory Danelon, Sébastien Meric, Romain Guy, Pierre-Yves Varoux, Ioan, bahamouth, duj, Braim, bulbo,
Ricky81, Debernad, jcarre, David Seigne, xavlours, christopheJ, willowII, Nourdine Falola, laffreuxthomas.

Aux correcteurs :
Remerciements également aux personnes qui ont relu les textes pour supprimer un maximum de fautes de français.

-5-

FAQ Java

Nicolas Cuny, Jonathan Muller, Etienne Bar, Bestiol, Ukyuu.

Aux visiteurs :
Remerciements enfin à tous ceux qui ont consulté cette FAQ, et qui, par leurs remarques, nous ont aidé à la
perfectionner.

Et pour finir, un merci tout spécial à Clément Cunin, qui est à l'origine de cette FAQ, à cyberzoide pour notre logo et
ses conseils avisés et à tous les membres de l'équipe qui nous ont fourni outils et logiciels nécessaires pour la réalisation
de ce document.

-6-

FAQ Java

Sommaire > Concepts fondamentaux
Qu'est-ce que Java ?
Auteurs : Clément Cunin ,
Java est un langage orienté objet développé par la société Sun. La syntaxe générale est très proche de celle du C, mais
Java n'est pas une surcouche du C et la syntaxe est beaucoup plus claire que celle du C++.

Les avantages :
Les avantages de Java son nombreux. Le byte-code, tout d'abord, qui assure à Java une portabilité complète vers de très
nombreux systèmes. L'importance de l'api de base qui offre tous les services de base, notamment pour la construction
des interfaces graphiques. La 3ème force de Java, c'est son adaptabilité dans de nombreux domaines, autant pour le
web que pour les systèmes embarqués.

Liste des Système disposant d'une implémentation de Java :
Windows 3.1/95/98/NT4/2000/ME/XP/CE, MacOS, Solaris, Linux, AIX, OS/2, IRIX, UnixWare, HP/UX, Digital Unix,
AmigaOS, BeOS, OpenVMS, FreeBSD, SunOS, RiscOS

Cette liste n'est pas exhaustive et est donnée à titre d'exemple.

Que sont le JRE, le JDK et le SDK ?
JRE :
Java Runtime Environement, c'est le kit destiné au client pour pouvoir exécuter un programme Java. Il se compose
essentiellement d'une machine virtuelle Java (JVM) capable d'exécuter le byte-code et les bibliothèques standard de
Java.

SDK :
Standard Development Kit, c'est le kit destiné au programmeur. Ce kit est composé d'un JRE, d'un compilateur et de
nombreux programmes utiles, des exemples de programmes Java, les sources de toutes les classes de l'api.

JDK :
Java Development Kit, c'est l'ancien nom du SDK. Le JDK a été renommé SDK depuis la version 1.2.2.

Comment installer le JDK ?
Auteurs : natha ,
Windows

Télécharger le JDK
Rendez-vous à cette page pour trouver les dernières versions disponibles.

Téléchargez celui intitulé "JDK 6 Update 5" (en date de cette FAQ). Il contient également le JRE de la même version
(donc inutile de télécharger le JDK ET le JRE). Ce téléchargement conviendra à toute utilisation standard de Java :
applet, application Desktop, application console.

Installer

-7-

FAQ Java

Suivez les étapes d'installation. Je vous conseillerais sous Windows d'installer le JDK dans un répertoire C:Java
jdk_1.6.0_05 (1.6.0_05 pouvant changer selon la version). Idem pour le JRE dans C:Javajre_1.6.0_05 . Ceci par
commodité et d'éviter ainsi l'utilisation du classique "Program Files" pouvant être pénible à l'utilisation à cause de
l'espace.

Il va falloir ensuite positionner la variable d'environnement PATH afin de pouvoir exécuter les programmes du JDK
de n'importe où (javac, etc.) :

• Ouvrez les propriétés du "Poste de travail" ("clic-droit/propriétés" sur l'icône OU "Panneau de configuration/
Système").
• Allez dans l'onglet "Avancé" puis cliquez sur le bouton "Variables d'environnement".
• Créez une nouvelle variable utilisateur en cliquant sur le bouton "Nouveau".
• Donnez le nom "Path" et comme valeur le chemin vers le répertoire bin de votre installation du JDK (n'oubliez
pas le répertoire "bin").
• Validez ces modifications en cliquant sur le bouton "OK".
• Pour tester votre installation, lancez un terminal : Démarrer/Exécuter puis "cmd"
• Tapez "javac -version", vous devriez avoir ce genre de résultat : "javac 1.6.0_05".

Linux (via apt-get ou synaptic)

Pour télécharger, installer et configurer le JDK, il vous suffit d'installer les derniers paquets proposés dans les dépôts
de votre distribution.

Sous Ubuntu par exemple j'ai les paquets sun-java6-jdk, sun-java6-jre et sun-java6-source (sans oublier les dépendances
proposées automatiquement). Le 3e, sun-java6-source, permet d'installer le src.zip du JDK contenant les sources. Livré
séparément il permet d'avoir une autocomplétion détaillée dans les IDE modernes (à moins que vous ne connaissiez
l'API par coeur).

Et voilà ! Vous pouvez compiler du code Java !

lien : Que sont le JRE, le JDK et le SDK ?

Où puis-je trouver le jre/jdk pour Mac ?
Auteurs : bulbo ,
Contrairement aux autres plateformes, il n'est pas distribué par Sun mais par Apple. Il est possible de le télécharger
sur le site suivant:
http://www.apple.com/macosx/features/java
Remarque: La dernière version disponible au moment de l'écriture de cette question est la 5.0.

Il faut noter qu'il est aussi possible de télécharger le JDK 6 pour les développeurs ici.

Quelle sont les différences entre application, applet et servlet ?
Application :
Une application Java est un programme utilisant le langage de programmation Java et qui tourne généralement sur la
machine où se trouve au départ le code. Il a le même but qu'un programme C ou d'un autre langage.

Applet :

-8-

FAQ Java

L'applet est récupérée à distance à travers un navigateur Web et s'exécute sur celui-ci. En raison de ce téléchargement à
distance, les règles de sécurité concernant les applets sont très strictes ( pour éviter notamment les virus ). Par exemple,
une applet ( contrairement à une application ), ne permet pas forcément l'écriture sur le disque local ou l'impression.

Servlet :
Une servlet peut être considéré comme une applet coté serveur. Une servlet est destinée à ajouter des fonctionnalités
à un serveur web.

Où peut-on trouver les sources des classes de l'API de Sun ?
Où ?
Sun distribue le code source de toutes les classes de l'API avec le JDK (installation de composant optionnel !). Vous
pouvez donc retrouver les sources dans le fichier 'src.jar', dans le répertoire d'installation du JDK.

Pourquoi ?
Même si cette cette approche n'est pas à conseiller aux débutants, il peut parfois être très utile de consulter le code
source des classes l'API. Cela peut permettre, par exemple, d'estimer la complexité de certains algorithmes, ou de mieux
comprendre le fonctionnement d'un objet particulier (et ainsi le surcharger plus efficacement). En cherchant bien, on
peut également trouver des classes non documentées...

lien : Que sont le JRE, le JDK et le SDK ?

Qu'est-ce que Java Web Start ?
Auteurs : Ronan Le Gallo , Clément Cunin , Jean-Baptiste Bugeaud ,
JavaWebStart est l'implémentation de référence par Sun de la spécification JNLP (JavaNetworkLaunchingProtocol)
qui définit un mécanisme d'installation et de mise à jour supportant des fonctionnalités évoluées grâce à HTTP et XML.

L'idée de JWS est de "mimer" le comportement d'une applet pour une application Java. Un serveur héberge
l'application ; le client Web Start se connecte au serveur, télécharge l'application et l'exécute. Les règles de sécurité
sont semblables à celles des applets.

L'intérêt principal est la facilité de déploiement des applications. Lors d'une mise à jour, seul le serveur est à modifier,
les clients téléchargeront la nouvelle application au prochain démarrage. Ce système est très intéressant pour les grosses
entreprises qui ne peuvent pas se permettre d'aller mettre à jour une application sur les milliers de postes de leurs
collaborateurs.

Les avantages :
• Fonctionnement en mode déconnecté.
• Exécution externe au browser -> intégration facile & large support.
• Mise à jour incrémentale et modulaire des applications.
• Support d'un exécution sécurisée dans un environnement de type sandbox.
• Certains services avancés accessibles sans certificat (ouverture d'un flux fichier, sauvegarde d'un flux fichier,
mécanisme de persistance entre sessions, impression, téléchargement de ressources, ...).

-9-

FAQ Java

• Migration facile depuis une application Java standard.

lien : http://www.up2go.net/

Comment connaître la version de la JVM installée ?
Depuis une console :

java -version

Depuis un programme :
Lors de l'exécution, la version de la JVM est accessible via les propriétés système (Comment accéder aux valeurs des
variables d'environnement ?).

String version = System.getProperty("java.vm.version");

Retourne le numéro de version complet de la JVM. Ce numéro peut comporter des informations spécifique. Par
exemple : "1.5.0_06-b05"

String version = System.getProperty("java.version");

Retourne le numéro de version exacte, y compris les éventuelles updates, mais sans informations spécifiques. Par
exemple : "1.5.0_06"

String version = System.getProperty("java.specification.version");

Retourne le numéro de version des spécifications, c'est à dire le numéro de version sans les versions de mises à jours.
Par exemple : "1.5"

Quelles sont les convention de nommage en Java ?
Les variables :
Les noms variables sont écrits en minuscules sauf la première lettre de chaque de mot à partir du deuxième. Il est
également recommandé de choisir un nom de variable court mais suffisamment explicite (garder à l'esprit qu'un autre
programmeur sera peut-être obligé de comprendre votre code plus tard).

public int maVariableEntiere;

Note : Une variable peut commencer par le caractère '_' ou '$', mais c'est fortement déconseillé par SUN.

Les constantes :
Afin de bien les différencier des variables ; les constantes sont écrites en majuscule, les mots sont séparés par le caractère
'_'.

public final static int MA_CONSTANTE

- 10 -

FAQ Java

Les méthodes :
Le nom des méthodes suit les mêmes règles de construction que les variables, mais le premier mot devrait toujours être
un verbe à l'infinitif, suivi éventuellement de mots pour qualifier l'action.

Les classes et interfaces :
Les noms de classes sont écrits en minuscule, chaque première lettre d'un mot est en majuscule.

public class MaClasse

Les paquets :
Les noms de paquet sont intégralement écrits en minuscule, sans caractère de séparation. Afin d'éviter au maximum
les risques de conflit de nommage, il est recommandé de placer son travail dans un paquet commençant par un nom de
domaine internet (com, edu, gov, mil, en, fr, etc ...) suivit du nom de l'organisation ou du projet.

com.developpez.javaorg.w3c.domorg.xml.sax

lien : JavaStyle - Les conventions de codage pour Java

Qu'est ce qu'un décompilateur ?
Auteurs : Ricky81 ,
Un décompilateur est un outil permettant de récupérer le code source d'une classe ou d'un ensemble de classes à
partir d'un byte code. Sans aller aussi loin, des outils proposent tout simplement l'analyse d'une classe en affichant ses
principales caractéristiques.
C'est le cas de javap, disponible dans le SDK.

E:>javap java.lang.Object
Compiled from "Object.java"
public class java.lang.Object{
public native int hashCode();
static {};
public java.lang.Object();
protected void finalize();
throws java/lang/Throwable
public final native void notify();
public final native void notifyAll();
public final void wait();
throws java/lang/InterruptedException
public final native void wait(long);
public final void wait(long,int);
public final native java.lang.Class getClass();
protected native java.lang.Object clone();
throws java/lang/CloneNotSupportedException
public boolean equals(java.lang.Object);
public java.lang.String toString();
}

Pour plus d'informations sur la commande javap :

- 11 -

FAQ Java

javap -help

lien : Qu'est qu'un obfuscateur ?

Qu'est qu'un obfuscateur ?
Qu'est que c'est, quel est le but ?
Pour assurer l'indépendance de la plate-forme, les programmes Java sont distribués sous forme de bytecode, cette forme
est très proche du code source original. Le bytecode est donc très facile à décompiler ce qui augmente le risque d'une
attaque par analyse du code source (reverse engineering). Cette attaque consiste à décompiler une application pour
comprendre ce qu'elle fait exactement (dans le cas de la cryptographie) ou pour comprendre comment elle le fait (dans
le cas d'espionnage industriel).
Pour se protéger de ce type d'attaque, on peut avoir recours à un "obfuscateur". Il s'agit d'un utilitaire qui transforme
le bytecode en un bytecode équivalent mais plus difficile à décompiler.

Comment ça marche ?
Plusieurs techniques permettent de rendre plus difficile la décompilation du bytecode. La première se base sur les
principes d'optimisation du code, en réordonnant les micro-instructions. D'autres techniques, plus radicales, changent
l'organisation de la mémoire, le nom des identifiants, ajoute du code parasite ou des "goto" : le bytecode est souvent
légèrement moins rapide mais surtout très difficile à comprendre.

Quel obfuscateur en Java ?
• RetroGuard : un des meilleurs obfuscateurs Open Source.

lien : Qu'est ce qu'un décompilateur ?

Qu'est-ce que le PATH ?
Auteurs : adiGuba ,
Le PATH n'est pas une notion propre à Java, mais se retrouve dans la plupart (voir la totalité) des systèmes
d'exploitations.
Il s'agit d'une variable d'environnement qui contient une liste de répertoires dans lesquels vont être recherchés les
fichiers exécutables.

Attention, sous Unix/Linux et assimilé, les chemins sont séparés par deux-points (':'), alors que sous Windows le
séparateur est un point-virgule (';').

Ainsi, afin de pouvoir utiliser les outils du JRE/JDK, il peut être nécessaire de modifier le PATH afin d'y ajouter le
répertoire bin du JRE/JDK.

On peut modifier le PATH de manière temporaire avec les commandes suivantes (depuis une console) :

Sous Unix/Linux :

export PATH=$PATH:/_chemin_du_jdk_/bin

Sous Windows :

- 12 -

FAQ Java

set PATH=%PATH%;C:_chemin_du_jdk_bin

Il est également possible de définir le PATH de manière définitive :

Sous Unix/Linux, en effectuant la manipulation ci-dessus dans le fichier de configuration de l'utilisateur (~/.bashrc).
Sous Windows via l'onglet "Avancé" des propriétés du poste de travail.

Qu'est-ce que le CLASSPATH ?
Auteurs : adiGuba ,
Le CLASSPATH permet de spécifier à la machine virtuel Java les emplacements à partir desquels les resources
(bytecode et autres) devront être recherché.
A l'instar de la variable d'environnement PATH, le CLASSPATH se présente sous la forme d'une liste d'éléments, qui
peuvent correspondre à un répertoire ou à une archive (*.jar ou *.zip).

Lorsque la machine virtuelle a besoin de charger une resource ou une classe, elle le recherche dans les divers éléments
du CLASSPATH dans l'ordre de leur déclaration.

Chaque élément du CLASSPATH correspond à une racine, et les classes sont recherchées dans les sous-répertoires
correspondant au nom de leurs packages.

Par exemple, pour un CLASSPATH comportant les deux éléments suivants :

• Le répertoire /projet/classes
• L'archive /projet/lib/archive.jar

Lors du chargement de la classe com.monsite.MaClasse, la JVM recherchera d'abord le fichier /projet/classes/com/
monsite/Maclasse.class.
Si ce dernier n'existe pas, la JVM recherchera alors le fichier com/monsite/Maclasse.class à l'intérieur de l'archive /
projet/lib/archive.jar.

lien : Comment modifier le CLASSPATH ?

Comment modifier le CLASSPATH ?
Auteurs : adiGuba ,
Il y a différentes manières de définir le CLASSPATH.

Lorsqu'on compile ou qu'on lance un programme Java, deux solutions s'offre à nous :

1) En créant une variable d'environnement CLASSPATH.

Exemple Unix/Linux :

export CLASSPATH=./lib/archive.jar:./classes
java ma.classe.Principale

Exemple Windows :

- 13 -

FAQ Java

set CLASSPATH=./lib/archive.jar;./classes
java ma.classe.Principale

2) En utilisant les options -classpath ou -cp de java/javac.

Exemple Unix/Linux :

java -classpath ./lib/archive.jar:./classes ma.classe.Principale

Exemple Windows :

java -classpath ./lib/archive.jar;./classes ma.classe.Principale

Si la variable d'environnement CLASSPATH existe, elle est ignoré et écrasé par l'usage de ces options.

Lorsqu'on exécute un jar exécutable avec l'option -jar de java, les deux solutions précédentes ne fonctionnent pas.
La seule et unique solution consiste à renseigner l'attribut Class-Path de son fichier Manifest. A noter toutefois que le
jar exécutable fera automatiquement partie du CLASSPATH.

Lorsqu'on exécute une application Java Web Start, les différents éléments du CLASSPATH sont défini dans le
descripteur *.jnlp via l'élément resources.

Remarque : la plupart des EDIs permettent de configurer simplement le CLASSPATH depuis leur interface graphique.

lien : Qu'est-ce que le CLASSPATH ?
lien : Qu'est-ce que Java Web Start ?
lien : Comment créer un jar exécutable ?

Qu'est-ce que le BOOTCLASSPATH ?
Auteurs : adiGuba ,
Le BOOTCLASSPATH fonctionne de la même manière que le CLASSPATH, si ce n'est qu'il est prioritaire sur ce
dernier : il est utilisé pour définir les classes standards de l'API. Il dépend donc fortement de la machine virtuelle et
ne devrait donc pas être modifié

Il est toutefois possible de le remplacer ou d'y ajouter des éléments à la fin ou en tête de liste avec les options non-
standard -Xbootclasspath, -Xbootclasspath/a et -Xbootclasspath/p de la JVM de Sun (reportez-vous à la documentation
pour les autres JVM).

Attention toutefois : le fait d'utiliser cette technique pour remplacer une classe du fichier rt.jar (qui comporte toutes
les classes standard de l'API) vient à l'encontre de la licence d'utilisation de la JVM de Sun.

Quelle est la taille maximum du code d'une méthode ?
Auteurs : afrikha ,
Bien que cela ne vienne pas à l'esprit, il existe une taille maximum pour le code d'une méthode sur certaines machines
et qui est de 65535 octets. Cela peut sembler énorme et suffisant, ce qui est vrai pour la grande majorité des cas mais

- 14 -

FAQ Java

avec les editeurs graphiques qui générent du code cette limite peut étre dépassée assez aisément : vous obtientrez alors
une erreur du type code too large.

lien : Lien sur le sujet

Quels sont les différents modes d'invocation de méthode ?
Auteurs : adiGuba ,
Selon le types des méthodes, Java dispose de quatre mode d'invocation, défini par les instructions invokevirtual,
invokespecial, invokestatic et invokeinterface.

• invokestatic permet d'invoquer les méthodes statiques, qui par définition ne sont lié à aucune instance de classe.
La résolution de la méthode est donc effectué lors de la compilation.
• invokespecial permet d'invoquer les méthodes d'instances qui peuvent être résolues dès la compilation et qui ne
dépendent donc pas du type de l'instance, c'est à dire les méthodes privées (private), les appels de méthode de la
classe parente (dont l'appel est préfixé par super), ou encore pour les appels de constructeur (ainsi que this() ou
super()).
• invokeinterface permet d'invoquer une méthode sur une référence dont le type est une interface. Etant donné
qu'il ne s'agit pas d'un type concret, la résolution de la méthode est forcément effectué à l'exécution selon le type
réel de l'instance.
• Enfin, invokevirtual permet d'invoquer les méthodes d'instances virtuelles d'une classe. C'est à dire que la
résolution de la méthode à appeler est effectué lors de l'exécution selon le type réel de l'instance.

Dans tous les cas, la présence, le nombre et le type des paramètres et des valeurs de retour sont vérifié à la compilation.

Ainsi, les méthodes invoqués avec invokeinterface et invokevirtual nécessitent un traitement supplémentaire lors de
l'exécution afin de rechercher la bonne méthode selon le type exacte de la référence sur laquelle elles sont utilisées.
Toutefois les JVMs modernes peuvent optimiser ce type d'appel de méthodes en se basant sur l'état de l'application (en
particulier le nombre et le type des classes chargées).

A noter également l'existence de la JSR-292 pour Java SE 7, dont l'objectif est d'introduire l'instruction invokedynamic
afin de mieux supporter les langages de scripts. Cette instruction serait nettement moins contraignante car elle ne
vérifierait pas la présence de la signature de méthode dans la classe à la compilation mais seulement lors de l'exécution,
et devrait introduire un mécanisme de gestion d'erreur (une méthode par défaut à appeler si la méthode demandée
n'existe pas).

Il faut préciser que ces appels se font au niveau du bytecode et non au niveau Java.

lien : JSR 292

[Java 5.0] Comment spécifier qu'un paramètre doit implémenter plusieurs interfaces ?
Auteurs : adiGuba ,
Dans le langage, on ne peut spécifier qu'un type pour un paramètre. Ainsi, si une méthode doit utiliser des objets qui
implémentent deux interfaces, on ne peut en utiliser qu'un seul dans la définition de la méthode, ce qui oblige à un cast
potentiellement dangereux à l'exécution :

public void method(Serializable data) {
Comparable cData = (Comparable) data; // throw ClassCastException
// Traitement ici
}

- 15 -

FAQ Java

Ce type de code a le désavantage de provoquer une exception si le type passé en paramètre n'implémente pas la seconde
interface.

Avec les Generics de Java 5.0 il est possible de reporter ce problème à la compilation. En effet les Generics ne se limitent
pas seulement à paramétrer des classes, ils peuvent également s'appliquer aux méthodes, et ainsi permettent donc de
spécifier plusieurs contraintes grâce à la covariance :

public <T extends Serializable & Comparable<T>> void method(T data) {
// 'data' implémente les interfaces Serializable et Comparable
// Traitement ici
}

Dans cet exemple, la méthode est paramétrée par un type T qui implémente à la fois les interfaces Serializable et
Comparable<T>. Ainsi, si la méthode est utilisée avec un objet qui n'implémente pas ces deux interfaces, le compilateur
génèrera une erreur à la compilation.

- 16 -

FAQ Java

Sommaire > Concepts fondamentaux > Les mots-clés
Quels sont les différents mot-clés du langage Java ?
Auteurs : Baptiste Wicht ,
Un mot-clé est tout simplement un mot qui a été reservé pour une utilisation spéciale par le langage; vous ne pouvez
donc pas employer des mots-clés comme noms de variable, ou nom de classe.

Pour avoir une liste de tous les mots-clés du langage Java et de leurs significations, vous pouvez lire cet article.

Que signifient les mots-clés public, private et protected ?
Auteurs : Ioan Calapodescu ,
Ces trois mots clefs du langage java 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 vide (rien, pas de modificateur). Il ne faut pas
confondre ce dernier avec public.

Voici les caractéristiques de ces modificateurs, du plus permissif au plus restrictif :

Mot-clé Portée Remarques
public Les variables, méthodes Il ne peut y avoir qu'une
ou classes publiques sont seule classe publique
accessibles par tout objet. par .java et celle-ci doit
obligatoirement porter le
nom du fichier .java
"rien" Les variables, méthodes Attention : les variables
ou classes définies sans sans modificateur ne sont
modificateur sont accessibles pas accessibles aux classes
par toute classe appartenant fille définies dans un autre
au même package. 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 Il est fortement conseillé de
ou classes définies comme déclarer comme privés tous
privées ne sont accessibles les attributs d'une classe, et
que par la classe dans de créer des méthodes de type
laquelle elles sont définies. get/set 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'abscence de mot-clé de visibilité ne correspond pas à une visibilité "package-
only" :

• Tous les membres (attributs et méthodes) d'une interface ou d'une annotation sont obligatoirement public.

- 17 -

FAQ Java

• Tous les constructeurs d'une enum sont obligatoirement private.

Que signifie le mot-clé static ?
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 peux ainsi les utiliser sans avoir
une instance créée. De nombreuses classes ont des membres ou méthodes statiques. Par exemple la classe Math :

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 faire des variables statiques 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.

publioc class MaClasse{
public static Map uneVariableStatique = new HashMap();
static{
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 à la QR Quels sont les différents types de classes internes (nested classes) ?.

lien : Que signifie le mot-clé final ?

Que signifie le mot-clé final ?
Devant une méthode :

- 18 -

FAQ Java

On indique que cette méthode ne pourra plus être redéfinie dans une classe fille. Ce qui entraîne une certaine
optimisation dans les appels à cette méthode.

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. La solution consisterait à "encapsuler" String dans une classe de notre conception.

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 :

private final int i = 5;

private final int i;
{
i = 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 static, elle peut être initialisée :

private static final int X = 5;

private static final int X;
static {
X = 5;
}

Pour une variable locale (ou pour un paramètre de la méthode), cela permet également de référencer l'instance dans
une classe anonyme.

Que signifient les mots-clés this et super ?
Auteurs : Ioan Calapodescu , tchize ,
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 devrais mettre en valeur cette définition plutôt succincte :

public MaClasse extends ClasseMere {
private String attribut;
/** On peut acceder aux constructeurs de la super-classe*/
public MaClasse(String uneValeur){
super(uneValeur);

- 19 -

FAQ Java

//on appelle ici le constructeur de la classe mère
}
/** On peut aussi accéder aux constructeurs de la classe elle-même*/
public MaClasse(String uneValeur){
this("une valeur par défaut");
//on appelle ici le constructeur définis un peu plus haut
}
/** 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 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 peux faire quelque chose en plus avant
super.uneAutreMethode();
//mais aussi après
}
}

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

public class Englobante {
private Object attribut;

public final class Interne {
private Object attribut;

private switch() {
Englobante.this.attribut = this.attribut;
}
}
}

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. Pour plus d'informations, voir Qu'est-ce que l'héritage ?

lien : Qu'est-ce que l'héritage ?

Que signifie le mot-clé strictfp ?
Auteurs : Romain Guy , Clément Cunin ,
Ce mot clé, 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 mot-clés public ou synchronized. Avec quelques restrictions : strictfp
s'applique en tant que modificateurs 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".

- 20 -

FAQ Java

Les effets :
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.

/** 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 les mêmes calculs quelle que soit la machine virtuelle sur laquelle l'opération
est effectuée.

Que signifie le mot-clé transient ?
Auteurs : Romain Guy ,
Le mot-clé transient est lié à la sérialisation des classes Java (voir : Qu'est-ce que la sérialisation ?). Il permet d'interdire
la sérialisation de certaines variables d'une classe.

// 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, 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 demo n'est jamais initialisé avec sa valeur par défaut. De plus, comme cet attribut est transient, il
n'est pas écrit dans le fichier. Cela implique que demo ne reçoit aucune valeur et contient donc 0.

- 21 -

FAQ Java

Ce mot-clé trouve des applications dès lors qu'une donnée sensible ne doit en aucun cas apparaître 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.

lien : Qu'est-ce que la sérialisation ?

Que signifie le mot-clé volatile ?
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é et toutes les JVM ne le prennent pas en compte.

Et le goto en Java ?
goto
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 & 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.

while(true) {
// instructions

if( condition ) {
// quitte la boucle
break;
}
if( condition ) {
// retourne au début de la boucle
continue;
}
}

- 22 -

FAQ Java

Pour plus d'informations sur break et continue, regardez le lien ci dessous.

lien : Comment utiliser les mots-clés break et continue ?

Comment utiliser les mots-clés break et continue ?
Auteurs : bulbo ,
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 une chaîne suivie de ":" et qui se place devant l'instruction de boucle.

Voici un exemple :

Boucle1: while(true){
System.out.println("Boucle 1");

Boucle2: for(int ind=0; ind < 10; ind++) {

Boucle3: while(true){
break Boucle2;
}
}

break;
}

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

Pourquoi mon switch ne veut-il pas compiler ?
Auteurs : bulbo ,
L'instruction switch n'accepte que les types de base, c'est à dire:

• byte
• char
• short
• int
• long
• float
• double

Il n'est pas possible de faire un switch sur une String par exemple. Il faudra passer par une séquence de if .. else if:

if ("A".equals(maString))
{
// ...

- 23 -

FAQ Java

}
else if ("B".equals(maString))
{
// ...
}

Il est possible aussi que le compilateur reporte cette erreur:
case expressions must be constant expressions
En effet l'instruction case n'accepte que des constantes.
Des constantes explicites comme dans ce cas:

case 1:
...
break;

Ou une variable déclarée comme constante à l'aide du mot-clé final.
Ainsi si vous obtenez une erreur avec le code suivant:

int a = 1;

switch (maVar)
{
case a:
...
}

Vous ne l'aurez plus avec celui-ci:

final int a = 1;

switch (maVar)
{
case a:
}

[Java 5.0] Comment fonctionne l'ellipse (nombre d'arguments variable) ?
Auteurs : adiGuba ,
L'ellipse 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 :

Méthode avec un nombre d'argument variable :
public void method (String... args) {
//
}

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

Exemple d'utilisation :

- 24 -

FAQ Java

Exemple d'utilisation :
// avec 1 paramètre :
method ("param1");

// avec plusieurs paramètres :
method ("param1", "param2", "param3");

// sans paramètres :
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
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 :

// avec 1 paramètre :
method ( new String[]{"param1"} );

// avec plusieurs paramètres :
method ( new String[]{"param1", "param2", "param3"} );

// sans paramètres :
method ( new String[]{} );

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.

lien : Présentation de Tiger : l'ellipse

[Java 5.0] Comment fonctionne la boucle for étendu ?
Auteurs : adiGuba ,
Le nouveau for de Java 5.0 permet de parcourir tous les éléments d'un élément 'itérable' sans se soucier de son
fonctionnement. Il se présente de la forme suivante :

La boucle for étendu :
for ( Type variable : Iterable ) {
// ...
}

• Type correspond au type de l'élément de la variable qui contiendra les différentes valeurs.
• variable est justement le nom de cette variable à l'intérieur de la boucle.
• Iterable est l'élément dont les valeurs seront parcourues. Ce doit obligatoirement être soit un tableau, soit une
classe implémentant l'interface Iterable.

L'interface Iterable décrit une unique méthode iterator() retournant un Iterator qui sera utilisé par la boucle for pour
parcourir les différents éléments. Les Collections de Java implémentent bien entendu cette interface. De plus, le type
de la variable doit correspondre au type paramétré de l'Iterator, ce qui permet de se passer de cast et d'utiliser un
code sécurisé :

Parcours d'une liste paramétrée
List<String> list = new ArrayList<String>();

- 25 -

FAQ Java

Parcours d'une liste paramétrée
list.add("chaine1");

// Affichage des éléments en MAJUSCULE :
for (String s : list) {
System.out.println(s.toUpperCase());
}

Si la boucle est utilisée avec un tableau, le type de la variable doit correspondre avec le type du tableau. Si elle est utilisée
avec un objet implémentant l'interface Iterable, le type de la variable doit correspondre au type paramétré d'Iterable
(par exemple,* List<String> implémente Iterable<String> et permet donc d'utiliser une String dans la boucle).

Et du fait de son fonctionnement, il est possible de l'utiliser avec n'importe quel type de classe du moment que cette
dernière implémente correctement l'interface Iterable<T> (T étant le type à utiliser dans la boucle for...

lien : Présentation de Tiger : la nouvelle boucle for
lien : java.lang.Iterable

[Java 5.0] Comment parcourir un tableau à 2 dimensions avec un for étendu ?
Auteurs : bulbo ,
Le code suivant parcourt un tableau à 2 dimensions d'entiers et les affiche.

int tab[][] = { {1, 2, 3}, {7, 8, 9} };

for(int ligne[] : tab)
{
for(int element : ligne)
{
System.out.println("Item : " + element);
}
}

[Java 5.0] Qu'est-ce que l'import static ?
Auteurs : adiGuba ,
L'import static 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 suivant sont identiques
mis à part que le second utilise un import static pour accéder aux méthodes de la classe Math :

Utilisation normale des méthodes statiques :
public Class Test {
public void calcul (int i) {
Math.round(Math.cos(i*(Math.PI/6)-Math.PI/2)*Math.E);
}
}

Utilisation d'un import static :
import static java.lang.Math.*;

- 26 -

FAQ Java

Utilisation d'un import static :
public Class Test {
public void calcul (int i) {
round(cos(i*(PI/6)-PI/2)*E);
}
}

Ce mécanisme est proche du mot-clef 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 :

Importation de System.out seulement :
import static java.lang.System.out;

public Class Test {
public void print () {
out.println("Message d'information");
System.err.println("Message d'erreur");
}
}

Quelle est la différence entre "import" et "import static" ?
Auteurs : le y@m's ,
Le import et le import static n'ont pas la même fonction.
Le import se fait sur une classe (ou un ensemble de classes via le *) 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 paquage différent de celui contenant
la classe).
Le 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 :

package package_b;

public class ClasseB {
private package_a.ClasseA a;

public CLasseB() {
a = new package_a.ClasseA();
}
}

Le import permet de supprimer cet inconvénient en indiquant à l'avance dans quel package se situe la classe ClasseA
et permet donc d'écrire

package package_b;

- 27 -

FAQ Java

import package_a.ClasseA;

public class ClasseB {
private ClasseA a;

public CLasseB() {
a = new ClasseA();
}
}

On se retrouve avec la même écriture que si la classe ClasseA était dans le même package que la classe ClasseB.
Supposont maintenant que la classe ClasseA posséde la méthode statique suivante :

public static void staticMethod() {
// code
}

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

ClasseA.staticMethod();

En faisant un import static de la méthode on se retrouve comme si la méthode statique faisait partie de la classe ClasseB
et nous permet d'écrire

import static package_a.ClasseA.staticMethod;

...

staticMethod();

Ces deux imports sont indépendants, si je ne fait que le import je pourrait écrire

ClasseA

mais je devrais écrire

ClasseA.staticMethod();

A l'inverse je pourrais très bien ne faire que l'import static et je me retrouverais à devoir écrire

package_a.ClasseA

mais à pouvoir écrire directement

staticMethod();

En résumé il est important de bien retenir que

• le import ne permet la simplification d'écriture que pour les classes

- 28 -

FAQ Java

• le 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
• le import et le import static sont indépendants

lien : [Java 5.0] Qu'est-ce que l'import static ?

Qu'est-ce que l'opérateur ternaire?
Auteurs : JMLLB ,
On le considère souvent comme une syntaxte réduite de l'instruction if traditionnelle.
Mais c'est avant tout un opérateur au sens où il produit une valeur.

(A) ? B : C

Si A alors le résultat est B sinon c'est C.
A noter que B est évalué seulement si A et que C est évalué seulement si non A.

Il fournit un moyen compact d'écrire une affectation conditionnée:

chaine=(nouvelleChaine!=null) ? nouvelleChaine : "";

à la place de:

if (nouvelleChaine!=null) {chaine=nouvelleChaine;} else {chaine="";}

NB: Utilisé abusivement il devient rapidement illisible.

- 29 -

FAQ Java

Sommaire > Concepts fondamentaux > Les notions
Qu'est-ce que l'héritage ?
L'héritage est un des principaux concepts de la programmation orientée objet. L'héritage permet de définir une relation
de "filiation" entre classes. Ainsi une classe fille (ou sous-classe) étend une classe mère (ou super-classe). L'héritage
permet en général de spécialiser une classe.

Pour indiquer qu'une classe hérite d'une autre, il faut utiliser le mot-clé extends :

public class Fille extends Mere{
//ici le code spécifique de la classe fille
}

L'héritage implique plusieurs choses :

La fille hérite du type de la mère :

public class Couleur(){
String nom;
public Couleur(String nom){
this.nom = nom;
}
}
public class Rouge extends Couleur{
public Rouge(){
super("rouge");
}
}
public class AutreClasse(){
public void setCouleur(Couleur uneCouleur){
//etc.
}
public static void main(String[] args){
AutreClasse ac = new AutreClasse();
ac.setCouleur(new Couleur("vert"));
ac.setCouleur(new Rouge());
}
}

La fille hérite de plusieurs attributs, méthodes et constructeurs de la mère

L'accès à ces attributs ou méthodes se fait avec le mot clef super. Pour plus d'informations, voir Que signifient les mots-
clés this et super ?

Voici comment est définie l'accessibilité aux composantes de la super-classe, en fonction des modificateurs :

Mot-clé Accès
public Oui
"rien" Oui, seulement si la classe fille se trouve dans
le même package que la super-classe.
protected Oui, quel que soit le package de définition de
la classe fille.
private Non.

- 30 -

FAQ Java

Regardez les liens ci dessous qui pourront vous éclairer un peu plus sur cette notion.

lien : Que signifient les mots-clés this et super ?
lien : Comment faire pour hériter de plusieurs classes ?
lien : Qu'est ce qu'une interface ?

Qu'est ce qu'une classe abstraite ?
Auteurs : Sébastien Meric , Clément Cunin ,
Qu'est ce qu'une classe abstraite
Une classe abstraite est une classe incomplète. Elle regroupe un ensemble de variables et de méthodes mais certaines
de ses méthodes ne contiennent pas d'instructions, elles devront être définies dans une classe héritant de cette classe
abstraite.

A quoi ça sert ?
En général à définir les grandes lignes du comportement d'une classe d'objets sans forcer l'implémentation des détails
de l'algorithme. Prenons l'exemple d'une chaîne de montage automobile, laquelle sort un modèle de voiture particulier.
On peut choisir de faire une nouvelle chaîne de montage pour le modèle à pare-choc métalisé, une pour le modèle à pare-
choc en plastique, etc. Ou on peut décider de faire une chaîne de montage générique, de laquelle sortiront des véhicules
non finis, que l'on terminera sur d'autres petites chaînes.

Comment ça marche ?
Premièrement comme indiqué ci dessus, une "abstract class" est incomplète, elle est donc non instanciable et doit être
héritée. Certaines classes abstraites disposeront de méthodes abstraites (que les classes enfants devront implémenter).
Voici un exemple de déclaration :

/** La classe abstraite employée : */
public abstract class Employe {
// bla bla bla

/** définition d'une méthode abstraite
* on notera qu'il n'y a pas d'instruction et un point-virgule à la fin
*/
public abstract void licencier();
}

// Class Ouvrier
public class Ouvrier extends Employe {
// définition du code de licencier
public void licencier() {
// on definit le code
System.out.println("Dehors !");
}
}

// Class Patron
public class Patron extends Employe {
// définition du code de licencier
public void licencier() {
System.out.println("Veuillez comprendre que dans la conjoncture actuelle ... !");
}
}

- 31 -

Faq java

Recommandé

Recommandé

Contenu connexe

En vedette

En vedette (20)

Similaire à Faq java

Similaire à Faq java (20)

Faq java