Paquetage Java

Pour mieux organiser les classes, Java fournit un mécanisme de paquetage permettant de différencier les espaces de noms des noms de classes.

Le rôle des paquetages

  • 1. Organiser les classes ou interfaces ayant des fonctionnalités similaires ou connexes dans le même paquetage afin de faciliter la recherche et l'utilisation des classes.

  • 2. Comme les dossiers, les paquetages utilisent également un mode de stockage en répertoire arborescent. Les noms de classes au sein d'un même paquetage sont différents, et les noms de classes de paquetages différents peuvent être identiques. Lorsqu'on appelle en même temps des classes de même nom provenant de deux paquetages différents, il convient d'ajouter le nom du paquetage pour les distinguer. Par conséquent, les paquetages peuvent éviter les conflits de noms.

  • 3. Les paquetages définissent également les autorisations d'accès. Seules les classes disposant de l'autorisation d'accès au paquetage peuvent accéder aux classes d'un paquetage particulier.

Java utilise le mécanisme de paquetage pour éviter les conflits de noms, contrôler l'accès et fournir la recherche et la localisation des classes, interfaces, énumérations et annotations.

La syntaxe de l'instruction package est :

package pkg1[．pkg2[．pkg3…]];

Par exemple, un fichier Something.java avec le contenu suivant :

package net.java.util; public class Something{ ... }

Ensuite, son chemin devrait être :net/java/util/Something.javaenregistré de cette façon. Le package est utilisé pour classer et stocker différents programmes Java, ce qui permet à d'autres programmes Java de les appeler plus facilement.

Un paquetage peut être défini comme un groupe de types interdépendants (classes, interfaces, énumérations et annotations), offrant une protection d'accès et une gestion des espaces de noms pour ces types.

Voici quelques paquetages en Java :

  • java.lang- Paquetages pour les classes de base
  • java.io- Paquetages contenant les fonctionnalités d'entrée/sortie

Les développeurs peuvent eux-mêmes regrouper un ensemble de classes et d'interfaces dans un paquetage et définir leurs propres paquetages. Cela vaut la peine d'être encouragé dans le développement réel. Après avoir terminé l'implémentation des classes, regrouper les classes associées permet aux autres programmeurs d'identifier plus facilement quelles classes, interfaces, énumérations et annotations sont liées.

Comme un paquetage crée un nouvel espace de noms, il n'entraînera pas de conflits de noms avec les noms d'autres paquetages. L'utilisation du mécanisme de paquetage facilite la mise en œuvre du contrôle d'accès et simplifie la localisation des classes associées.

Création de paquetages

Lors de la création d'un paquetage, vous devez choisir un nom approprié pour celui-ci. Ensuite, si un autre fichier source contient des classes, interfaces, énumérations ou types d'annotations fournis par ce paquetage, la déclaration de paquetage doit être placée au début de ce fichier source.

La déclaration de paquetage doit être sur la première ligne du fichier source. Chaque fichier source ne peut avoir qu'une seule déclaration de paquetage, et chaque type de ce fichier s'y applique.

Si un fichier source n'utilise pas de déclaration de package, alors les classes, fonctions, énumérations, annotations, etc. qu'il contient seront placées dans un package sans nom.

Exemples

Regardons un exemple. Cet exemple crée un package appelé animals. Généralement, on utilise des lettres minuscules pour le nommage afin d'éviter les conflits avec les noms de classes et d'interfaces.

Ajoutez une interface au package animals :

Code du fichier Animal.java :

/*Nom du fichier : Animal.java*/ package animals; interface Animal { public void eat(); public void travel(); }

Ensuite, ajoutez l'implémentation de cette interface dans le même package :

Code du fichier MammalInt.java :

package animals; /*Nom du fichier : MammalInt.java*/ public class MammalInt implements Animal{ public void eat(){ System.out.println("Mammal eats"); } public void travel(){ System.out.println("Mammal travels"); } public int noOfLegs(){ return 0; } public static void main(String args[]){ MammalInt m = new MammalInt(); m.eat(); m.travel(); } }

Ensuite, compilez ces deux fichiers et placez-les dans un sous-répertoire appelé animals. Utilisez la commande suivante pour exécuter :

$ mkdir animals
$ cp Animal.class  MammalInt.class animals
$ java animals/MammalInt
Mammal eats
Mammal travel

Le mot-clé import

Afin d'utiliser les membres d'un package, nous devons importer explicitement ce package dans le programme Java.

En Java, le mot-cléimportest utilisé pour importer des types définis dans d'autres classes ou packages, afin que ces types puissent être utilisés dans le fichier source actuel.

importest le mot-clé utilisé pour importer des classes, des interfaces ou des membres statiques depuis d'autres packages. Il vous permet d'utiliser directement des classes d'autres packages dans votre code sans spécifier entièrement le nom du package de la classe.

Dans un fichier source Java, l'instruction import doit se trouver en haut du fichier source Java. Sa syntaxe est :

import package1[.package2…].(classname|*);

L'instruction import est placée après l'instruction package :

//La première ligne non-commentaire est l'instruction package. package com.example; //L'instruction import importe des classes depuis d'autres packages. import java.util.ArrayList; import java.util.List; //Définition de classe public class MyClass { //Membres et méthodes de classe }

Si une classe d’un package veut utiliser une autre classe du même package, le nom du package peut être omis.

Vous pouvez utiliser l’instruction import pour importer une classe spécifique :

import com.example.MyClass;

De cette façon, vous pouvez directement utiliser les méthodes, variables ou constantes de la classe MyClass dans le fichier source actuel.

Vous pouvez également utiliser le joker*pour importer un package ou un sous-package entier :

import com.example.mypackage.*;

De cette façon, vous pouvez importercom.example.mypackagetoutes les classes d’un package, afin de pouvoir utiliser les méthodes, variables ou constantes de n’importe quelle classe de ce package dans le fichier source actuel. Notez que lorsque vous utilisez le joker*pour importer un package entier, seules les classes du package sont importées, pas les sous-packages de ce package.

Lors de l’importation d’une classe ou d’un package, vous devez fournir le nom pleinement qualifié de la classe ou du package. Le nom pleinement qualifié inclut la combinaison du nom du package et du nom de la classe, avec un point.comme séparateur.

Exemples

import java.util.ArrayList; // Importer la classe ArrayList du package java.util
import java.util.*; // Importer toutes les classes du package java.util

import com.example.MyClass; // Importer la classe MyClass du package com.example
import com.example.*; // Importer toutes les classes du package com.example

Exemple

Le package payroll ci-dessous contient déjà la classe Employee. Ensuite, nous ajoutons une classe Boss au package payroll. Lorsque la classe Boss référence la classe Employee, elle n’a pas besoin d’utiliser le préfixe payroll. L’exemple de la classe Boss est le suivant.

Code du fichier Boss.java :

package payroll; public class Boss { public void payEmployee(Employee e) { e.mailCheck(); } }

Que se passe-t-il si la classe Boss n'est pas dans le package payroll ? La classe Boss doit utiliser l'une des méthodes suivantes pour référencer des classes d'autres packages.

Utilisez le nom de classe entièrement qualifié, par exemple :

payroll.Employee

utilisezimportUtilisez le mot-clé pour importer, en utilisant le joker*：

import payroll.*;

Utilisezimportle mot-clé pour importer la classe Employee :

import payroll.Employee;

Remarque :

Un fichier de classe peut contenir un nombre quelconque de déclarations d'importation. Les déclarations d'importation doivent être après la déclaration de package et avant la déclaration de classe.

Structure des répertoires des packages

Mettre des classes dans des packages a deux résultats principaux :

  • Le nom du package fait partie du nom de la classe, comme indiqué précédemment.
  • Le nom du package doit correspondre à la structure de répertoires où réside le bytecode correspondant.

Voici une manière simple de gérer vos propres fichiers Java :

Placez le code source des types tels que les classes et les interfaces dans un fichier texte. Le nom du fichier est le nom du type, avec .java comme extension. Par exemple :

//Nom du fichier : Car.java package vehicle; public class Car { //Implémentation de la classe }

Ensuite, placez le fichier source dans un répertoire qui correspond au nom du package de la classe.

....\vehicle\Car.java

Maintenant, le nom de classe et le chemin corrects ressembleront à ceci :

  • Nom de la classe -> vehicle.Car

  • Nom du chemin -> vehicle\Car.java (sur les systèmes Windows)

Habituellement, une entreprise utilise la forme inversée de son nom de domaine Internet comme nom de package. Par exemple, si le nom de domaine Internet est example.com, tous les noms de package commencent par com.example. Chaque partie du nom de package correspond à un sous-répertoire.

Par exemple, il existe un paquetagecom.example.testqui contient un fichier source nommé Example.java. En conséquence, il doit y avoir une série de sous-répertoires comme suit :

....\com\example\test\Example.java

Lors de la compilation, le compilateur crée un fichier de sortie différent pour chaque type, comme une classe ou une interface définie dans le paquetage. Le nom du fichier de sortie est le nom du type, avec .class comme extension. Par exemple :

//Nom du fichier : Example.java package com.example.test; public class Example { } class Google { }

Maintenant, compilons ce fichier avec l'option -d, comme suit :

$javac -d . Example.java

Cela placera les fichiers compilés comme indiqué ci-dessous :

.\com\example\test\Example.class
.\com\example\test\Google.class

Vous pouvez importer \com\example\test\ les classes, interfaces, etc. définies dans :

import com.example.test.*;

Les fichiers .class compilés doivent être placés, comme les fichiers source .java, dans des répertoires correspondant au nom du paquetage. Toutefois, il n'est pas obligatoire que le chemin du fichier .class soit le même que le chemin du fichier .java correspondant. Vous pouvez organiser les répertoires source et de classes séparément.

<path-one>\sources\com\example\test\Example.java
<path-two>\classes\com\example\test\Google.class

De cette façon, vous pouvez partager votre répertoire de classes avec d'autres programmeurs sans révéler votre code source. Gérer le code source et les fichiers de classes de cette manière permet au compilateur et à la machine virtuelle Java (JVM) de trouver tous les types utilisés dans votre programme.

Le chemin absolu du répertoire de classes est appeléclass pathDéfini dans la variable systèmeCLASSPATHLe compilateur et la machine virtuelle Java construisent le chemin des fichiers .class en ajoutant le nom du paquetage au class path.

<path- two>\classes est le class path, le nom du paquetage est com.example.test, et le compilateur et la JVM rechercheront les fichiers .class dans <path-two>\classes\com\example\test.

Un chemin de classe peut contenir plusieurs chemins. Les chemins multiples doivent être séparés par un délimiteur. Par défaut, le compilateur et la JVM cherchent dans le répertoire courant. Les fichiers JAR contiennent des classes liées à la plateforme Java, donc leurs répertoires sont placés dans le chemin de classe par défaut.

Définition de la variable système CLASSPATH

Utilisez la commande suivante pour afficher la variable CLASSPATH actuelle :

  • Plateforme Windows (ligne de commande DOS) : C:\> set CLASSPATH
  • Plateforme UNIX (sous le shell Bourne) : # echo $CLASSPATH
Vider le contenu actuel de la variable CLASSPATH :
  • Plateforme Windows (ligne de commande DOS) : C:\> set CLASSPATH=
  • Plateforme UNIX (sous le shell Bourne) : # unset CLASSPATH; export CLASSPATH

Définir la variable CLASSPATH :

  • Plateforme Windows (ligne de commande DOS) : C:\> set CLASSPATH=C:\users\jack\java\classes
  • Plateforme UNIX (sous le shell Bourne) : # CLASSPATH=/home/jack/java/classes; export CLASSPATH
Autres extensions