Paquets (package) Java

Pour mieux organiser les classes, Java fournit le mécanisme de paquets, utilisé pour distinguer les espaces de noms des noms de classes.

Le rôle du paquet

• 1、Organiser les classes ou interfaces fonctionnellement similaires ou liées dans le même paquet, ce qui facilite la recherche et l'utilisation des classes.

• 2、Comme les dossiers, les paquets utilisent également un stockage en arborescence de répertoires. Les noms des classes dans le même paquet sont différents, et les noms des classes dans des paquets différents peuvent être identiques. Lorsque plusieurs classes portant le même nom dans des paquets différents sont appelées simultanément, il est nécessaire d'ajouter le nom du paquet pour les différencier. Par conséquent, les paquets peuvent éviter les conflits de nom.

• 3、Les paquets limitent également les droits d'accès, seules les classes ayant des droits d'accès au paquet peuvent accéder aux classes d'un paquet donné.

Java utilise le mécanisme de paquet (package) pour éviter les conflits de nommage, contrôler l'accès, fournir la recherche et la localisation des classes (class), interfaces, énumérations (enumerations) et commentaires (annotations).

La syntaxe de la déclaration de package est :

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

Par exemple, le contenu d'un fichier Something.java

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

Donc, son chemin devrait être net/java/util/Something.java En conséquence, le rôle du package (paquet) est de classer et de sauvegarder différemment les programmes java, ce qui rend leur appel par d'autres programmes java plus pratique.

Un paquet (package) peut être défini comme un ensemble de types interconnectés (classes, interfaces, énumérations et commentaires), fournissant des fonctionnalités de protection d'accès et de gestion d'espace de nommage pour ces types.

Voici quelques paquets dans Java :

• java.lang-Paquetage des classes de base

• java.io-Fonctions contenant des fonctionnalités d'entrée/sortie

Les développeurs peuvent regrouper un ensemble de classes et d'interfaces, etc., et définir leur propre paquet. De plus, dans la pratique du développement, cela est fortement recommandé. Une fois que vous avez terminé l'implémentation des classes, regrouper les classes associées permet aux autres développeurs de mieux déterminer quels classes, interfaces, énumérations et commentaires, etc. sont associés.

Comme le paquet crée un nouveau namespace (espace de nommage), il ne会产生任何与其他包中的名字的命名冲突。L'utilisation de ce mécanisme de paquet facilite la mise en œuvre du contrôle d'accès et rend la localisation des classes associées plus simple.

Créer un paquet

Lors de la création d'un paquet, vous devez choisir un nom approprié pour ce paquet. Par la suite, si un autre fichier source contient des classes, interfaces, énumérations ou types de commentaires fournis par ce paquet, la déclaration de ce paquet doit être placée en début de ce fichier source.

La déclaration de paquet doit être placée en première ligne du fichier source, chaque fichier source ne peut avoir qu'une seule déclaration de paquet, et chaque type dans ce fichier s'y applique.

Si un fichier source ne contient pas de déclaration de paquet, les classes, fonctions, énumérations, commentaires, etc. y seront placés dans un paquet sans nom (unnamed package).

instance

Considérons un exemple, cet exemple crée un paquet appelé animals. Il est généralement préférable d'utiliser des lettres minuscules pour nommer pour éviter les conflits avec les noms de classes et d'interfaces.

Ajoutez une interface (interface) dans le paquet animals :

/*　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 paquet :

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. Pour exécuter, utilisez la commande suivante :

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

mot-clé import

Pour pouvoir utiliser les membres d'un paquet, nous devons explicitement importer ce paquet dans le programme Java. L'instruction "import" permet de réaliser cette fonctionnalité.

Dans un fichier source Java, l'instruction import doit être située après l'instruction package et avant toute définition de classe, elle peut être absente ou présente plusieurs fois, et son format grammatical est :

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

Si une classe dans un paquet souhaite utiliser une autre classe de ce paquet, le nom du paquet peut être omis.

instance

Le paquet payroll suivant contient déjà la classe Employee, ajoutez une classe Boss au paquet payroll. Lorsque la classe Boss fait 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.

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 paquet payroll ? La classe Boss doit utiliser l'une des méthodes suivantes pour faire référence aux classes d'autres paquets.

utilisez le nom complet de la classe pour décrire, par exemple :

payroll.Employee

par import mot-clé pour introduire, utilisez l'astérisque "*"

import  payroll.*;

utilisez import mot-clé pour introduire la classe Employee:

import  payroll.Employee;

Attention :

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

structure de répertoire du package

Placer une classe dans un paquet a deux principaux résultats :

• Le nom du paquet devient une partie du nom de la classe, comme nous l'avons discuté précédemment.

• Le nom du paquet doit correspondre à la structure de répertoire où se trouvent les bytecode correspondants.

Voici un mode simple de gestion des fichiers java :

Placez le code source des classes, interfaces, etc. dans un texte, le nom de ce fichier est le nom de ce type, et il se termine par .java. Par exemple :

//　nom de fichier  :  Car.java
　
package  vehicle;
　
public  class  Car  {
　　　//　implémentation de la classe　　
}

Ensuite, placez le fichier source dans un répertoire, ce répertoire doit correspondre au nom du paquet où se trouve la classe.

....\vehicle\Car.java

Maintenant, le nom de classe et le chemin corrects seront les suivants :

• nom de classe -> 　vehicle.Car

• nom de chemin -> 　vehicle\Car.java (dans le système Windows)

Généralement, une entreprise utilise la forme inversée de son nom de domaine internet comme nom de paquet. Par exemple : le nom de domaine internet est oldtoolbag.com, tous les noms de paquets se terminent par com.w3codebox en début. Chaque partie du nom du paquet correspond à un sous-répertoire.

par exemple : il y a un com.w3codebox.test paquet, ce paquet contient un nommé w3Si vous avez le fichier source codebox.java, alors il devrait y avoir une série de sous-répertoires comme suit :

....\com\w3codebox\test\w3codebox.java

Lors de la compilation, le compilateur crée un fichier de sortie différent pour chaque type de classe, d'interface, etc. définie dans le paquet, le nom du fichier de sortie étant le nom de ce type, avec .class comme extension. Par exemple :

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

Maintenant, nous utilisons-doption pour compiler ce fichier, comme suit :

$javac　-d　.　w3codebox.java

Les fichiers compilés seront placés ainsi :

.\com\w3codebox\test\w3codebox.class
.\com\w3codebox\test\Google.class

Vous pouvez importer tous \com\w3codebox\test\ Les classes, interfaces, etc. définies dans :

import　com.w3codebox.test.*;

Les fichiers .class générés après compilation devraient être placés dans le même répertoire que les fichiers .java sources, et le répertoire où ils sont placés devrait correspondre au nom du paquet. Cependant, il n'est pas nécessaire que le chemin des fichiers .class soit le même que celui des fichiers .java. Vous pouvez organiser séparément les répertoires de code source et de classes.

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

De cette manière, vous pouvez partager votre répertoire de classes avec d'autres programmeurs sans révéler votre code source. Gérer ainsi le code source et les fichiers de classes permet au compilateur et au moteur java virtuel (JVM) de trouver tous les types utilisés dans votre programme.

L'adresse absolue du répertoire des classes s'appelle chemin de classe. Est définie dans la variable système CLASSPATH Dans ce répertoire. Le compilateur et le moteur java virtuel construisent le chemin des fichiers .class en ajoutant le nom du paquet au chemin de classe.

<path- two>\classes est le chemin de classe, et le nom du paquet est com.w3codebox.test, et le compilateur et le JVM recherchent dans 　<path-two>\classes\com\w3Recherche de fichiers .class dans codebox\test.

Un chemin de classe peut contenir plusieurs chemins, et les chemins multiples doivent être séparés par des séparateurs. Par défaut, le compilateur et le JVM recherchent le répertoire courant. Les fichiers JAR contiennent des classes liées au plateau Java, donc leurs répertoires par défaut sont placés dans le chemin de classe.

Set CLASSPATH system variable

Use the following command to display the current CLASSPATH variable:

• Windows Platform (DOS Command Prompt): C:\> set CLASSPATH

• UNIX Platform (Bourne shell): # echo $CLASSPATH

Delete the current CLASSPATH variable content:

• Windows Platform (DOS Command Prompt): C:\> set CLASSPATH=

• UNIX Platform (Bourne shell): # unset CLASSPATH; export CLASSPATH

Set CLASSPATH variable:

• Windows Platform (DOS Command Prompt): C:\> set CLASSPATH=C:\users\jack\java\classes

• UNIX Platform (Bourne shell): # CLASSPATH=/home/jack/java/classes; export CLASSPATH