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 package app.editeur.fenetre.
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.

Programmation Java

Version imprimable

[ Modifier le sommaire ]

Exceptions

Classes de base

Utilisation modifier

Le 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 modifier

pour 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 modifier

En 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 modifier

L'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 modifier

Pour 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 modifier

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