Programmation Java/Paquetages
Les paquetages, ou packages, permettent de grouper ensemble des classes rattachées, à la manière des dossiers qui permettent de classer des fichiers. En java, un paquetage particulier correspond à un répertoire. Les classes d'un projet en java devraient toutes être dans un paquetage particulier afin de les catégoriser. Cela a plusieurs avantages :
- retrouver les classes plus facilement
- Par exemple, la fenêtre d'édition
EditorWindow
dans le packageapp.editeur.fenetre
.
- Par exemple, la fenêtre d'édition
- différencier deux classes ayant un nom identique ou similaire mais au rôle différent et éviter un conflit de nom.
- Par exemple, trois classes
Adresse
différentes :- dans un package
courrier.client
pour la gestion d'une adresse postale ; - dans un package
réseau.hôte
pour la gestion d'une adresse IP ; - dans un package
personnage.propriété
pour la gestion de la caractéristique d'adresse d'un personnage de jeu de rôle.
- dans un package
- Par exemple, trois classes
Utilisation
modifierLe fichier à inclure dans un paquetage doit contenir le mot-clé 'package
' suivi du nom du paquetage.
Ce nom peut être composé de plusieurs mots séparés par un point ( .
).
Exemple
modifierpour inclure la classe Toto dans le paquetage 'mesPackages.sousPackage1
', écrire au début du fichier Toto.java :
package mesPackages.sousPackage1;
// ne pas oublier le point-virgule en fin de ligne
La structure des répertoires doit suivre le nom du paquetage, c'est-à-dire que le fichier Toto.java doit se situer dans un sous-répertoire mesPackages/sousPackage1/Toto.java.
Lorsqu'ensuite on désire utiliser la classe Toto depuis une autre classe, il faudra au préalable écrire :
import mesPackages.sousPackage1.Toto;
ou
import mesPackages.sousPackage1.*;
// importation de toutes les classes
// du paquetage mesPackage.sousPackage1
ou utiliser directement une référence au paquetage :
mesPackages.sousPackage1.Toto toto
= new mesPackages.sousPackage1.Toto();
Conventions
modifierEn Java, les programmeurs attribuent généralement un nom qui commence par une minuscule pour un paquetage, et un nom qui commence par une capitale pour une classe.
Les bibliothèques Java destinées à être distribuées regroupent leurs classes dans un ou plusieurs paquetages dont le nom est normalement précédé par un nom de domaine dans l'ordre inverse, par exemple :
package org.wikibooks.exemple;
Cela permet également d'éviter les conflits de nom de paquetages et de classes venant de différents groupes et entités.
Par exemple, une classe org.wikibooks.fr.Test
pourra cohabiter avec une classe org.wikipedia.fr.Test
sans conflit de noms de classe.
Compilation
modifierL'utilisation d'un paquetage nécessite une structure des répertoires correspondant au nom du paquetage. Un projet est composé de plusieurs paquetages, dont la racine est le répertoire qu'il faut passer à java dans le classpath pour qu'il puisse charger les classes des paquetages du projet.
Par exemple, le fichier Toto.java
définit la classe Toto
du paquetage org.wikibooks.exemple
débute par :
package org.wikibooks.exemple;
class Toto ...
et doit se situer dans le répertoire org/wikibooks/exemple
.
Supposons que le chemin du fichier soit /home/me/javaprog/org/wikibooks/exemple/Toto.java
.
La compilation se fait en spécifiant le chemin du package racine (répertoire parent de org) comme classpath, et en spécifiant ensuite le chemin relatif à ce répertoire :
javac -classpath /home/me/javaprog org/wikibooks/exemple/Toto.java
Quand un programme Java utilise cette classe, il doit être compilé et exécuté en spécifiant /home/me/javaprog
(package racine) pour le paramètre classpath, et le nom de la classe doit inclure le nom du package :
java -classpath /home/me/javaprog org.wikibooks.exemple.Toto
Import statique
modifierPour utiliser les membres statiques publiques d'une classe, il faut nommer la classe où ils sont définis.
Exemple 1 :
double r = Math.cos(Math.PI * theta);
L'import statique permet d'importer les membres statiques d'une classe afin de ne pas nommer la classe en question.
Exemple 1 :
// importer le membre statique PI seulement
import static java.lang.Math.PI;
...
double r = Math.cos(PI * theta);
Exemple 2 :
// importer tous les membres statiques de la classe java.lang.Math
import static java.lang.Math.*;
...
double r = cos(PI * theta);
L'abus d'import statique n'est pas conseillé car le code ne contient plus de référence à la classe définissant le membre statique utilisé. Il ne faut l'utiliser que si les membres statiques d'un petit nombre de classes sont utilisés fréquemment.
Importation de paquetages depuis une archive jar
modifierPour importer un paquetage d'un fichier .jar
, il faut s'assurer que le fichier est dans le classpath courant (à compile- et execution-time). Ensuite, l'import se déroule comme si le .jar était décompressé.
Par exemple, pour compiler et lancer une classe d'un projet du dossier parent (contenant deux répertoires : /source
et /libraries
) compiler :
$ javac -classpath libraries/lib.jar source/MainClass.java
Puis le lancer :
$ java -classpath libraries/lib.jar source/MainClass
Cela nécessite que MainClass
soit le package par défaut, ce qui n'est pas très explicite.
Il vaut mieux que la classe principale soit également dans un paquetage.