Paquet Java
Afin de mieux organiser les classes, Java fournit un mécanisme de package pour distinguer l'espace de noms des noms de classe.
Le rôle des packages
1 Organiser les classes ou les interfaces avec des fonctions similaires ou connexes dans le même package pour faciliter la recherche et l'utilisation des classes .
2 Comme les dossiers, les packages sont également stockés dans un répertoire arborescent. Les noms des classes dans le même package sont différents et les noms des classes dans différents packages peuvent être identiques. Lorsque des classes portant le même nom de classe dans deux packages différents sont appelées en même temps, le nom du package doit être ajouté pour les distinguer. eux. Par conséquent, les packages peuvent éviter les conflits de noms.
3 Les packages limitent également les autorisations d'accès. Seules les classes disposant d'autorisations d'accès aux packages peuvent accéder aux classes d'un certain package.
Java utilise le mécanisme du package pour éviter les conflits de noms, le contrôle d'accès et fournir la recherche et l'emplacement des classes, des interfaces, des énumérations et des annotations. Le format de syntaxe de l'instruction du package
est :
package pkg1[．pkg2[．pkg3…]];
Par exemple, si un fichier Something.java a son contenu
package net.java.util
public class Something{
...
}, alors son chemin doit être net/java/ util/Something .java est enregistré comme ceci. La fonction du package est de classer et de sauvegarder différents programmes Java afin qu'ils puissent être appelés plus facilement par d'autres programmes Java.
Un package peut être défini comme un ensemble de types interconnectés (classes, interfaces, énumérations et annotations), fournissant des fonctions de protection d'accès et de gestion d'espace de noms pour ces types.
Voici quelques packages en Java :
classes de base java.lang-packaging
java.io- Fonctions contenant des fonctions d'entrée et de sortie
Les développeurs peuvent empaqueter eux-mêmes un ensemble de classes et d'interfaces et définir leur propre package. Et cela vaut la peine de préconiser de le faire dans le développement réel. Une fois que vous avez terminé l'implémentation de la classe vous-même, le regroupement des classes associées peut permettre aux autres programmeurs de déterminer plus facilement quelles classes, interfaces, énumérations, annotations, etc.
Étant donné que le package crée un nouvel espace de noms, cela ne provoquera pas de conflits de noms avec les noms d'autres packages. L'utilisation du mécanisme de package facilite la mise en œuvre du contrôle d'accès et facilite la localisation des classes associées.
Création d'un package
Lors de la création d'un package, vous devez donner au package un nom approprié. Plus tard, si un autre fichier source contient des classes, des interfaces, des énumérations ou des types d'annotations fournis par ce package, la déclaration du package doit être placée au début du fichier source.
La déclaration de package doit être sur la première ligne du fichier source. Il ne peut y avoir qu'une seule déclaration de package par fichier source, et chaque type de ce fichier s'y applique.
Si aucune déclaration de package n'est utilisée dans un fichier source, les classes, fonctions, énumérations, annotations, etc. seront placées dans un package sans nom.
Exemple
Regardons un exemple qui crée un package appelé animaux. Utilisez généralement des lettres minuscules pour éviter les conflits avec les noms de classe et d'interface.
Ajouter une interface au package animaux :
/* 文件名: Animal.java */
package animals;
interface Animal {
public void eat();
public void travel();
}Ensuite, ajoutez l'implémentation de l'interface au même package :
package animals;
/* 文件名 : 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é animaux. Utilisez la commande suivante pour exécuter :
$ mkdir animals $ cp Animal.class MammalInt.class animals $ java animals/MammalInt Mammal eats Mammal travel
import password
Afin d'utiliser les membres d'un certain package, nous devons importer explicitement le package dans le programme Java. Cette fonction peut être accomplie à l'aide de l'instruction "import".
Dans le fichier source Java, l'instruction d'importation doit être située après l'instruction du package et avant les définitions de toutes les classes. Il peut y avoir aucune ou plusieurs instructions. Le format de syntaxe est :
import package1[.package2…].(classname|*);
. S'il se trouve dans un package, si une classe souhaite utiliser une autre classe dans ce package, le nom du package peut être omis.
Exemple
Le package de paie suivant contient déjà la classe Employee. Ensuite, ajoutez une classe Boss au package de paie. La classe Boss n'a pas besoin d'utiliser le préfixe de paie pour faire référence à la classe Employee. Des exemples de la classe Boss sont les suivants.
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 de paie ? La classe Boss doit utiliser l'une des méthodes suivantes pour référencer des classes dans d'autres packages
Utilisez le nom complet de la classe, par exemple :
payroll.Employee
Introduit avec le mot-clé import, utilisez le caractère générique " *"
import payroll.*;
Utilisez le mot-clé import pour introduire la classe Employee
import payroll.Employee;
Remarque :
Un fichier de classe peut contenir n'importe quel nombre d'instructions d'importation. L'instruction import doit être placée après la déclaration du package et avant la déclaration de la classe.
Structure du répertoire du package
Il y aura deux résultats principaux lorsque la classe est placée dans le package :
Le nom du package devient une partie du nom de la classe, comme nous l'avons vu précédemment.
Le nom du package doit correspondre à la structure de répertoires où se trouve le bytecode correspondant.
Ce qui suit est un moyen simple de gérer vos propres fichiers en Java :
Mettez le code source des classes, des interfaces, etc. dans un texte, le nom de ce fichier est le nom de ce type, avec .java comme extension. Par exemple :
// 文件名 : Car.java
package vehicle;
public class Car {
// 类实现
}Ensuite, placez le fichier source dans un répertoire correspondant au nom du package où se trouve la classe.
....\vehicle\Car.java
Maintenant, le nom de classe et le chemin corrects ressembleront à ceci :
Nom de classe-> 🎜>Chemin-> véhiculeCar.java (sous Windows)
Habituellement, une entreprise utilise la forme inverse de son nom de domaine Internet comme nom de package. est apple .com, tous les noms de packages commencent par com.apple. Chaque partie du nom du package correspond à un sous-répertoire.
Par exemple : cette société possède un package com.apple.computers, qui contient un fichier source appelé Dell.java. En conséquence, il devrait y avoir une série de sous-répertoires comme suit :
....\com\apple\computers\Dell.java
Quand. Lors de la compilation, le compilateur crée un fichier de sortie différent pour chaque type de classe, d'interface, etc. défini dans le package. Le nom du fichier de sortie est le nom de ce type, avec .class comme suffixe d'extension. Par exemple :
// 文件名: Dell.java
package com.apple.computers;
public class Dell{
}
class Ups{
}Maintenant, nous utilisons l'option -d pour compiler ce fichier comme suit :
$javac -d . Dell.java
Cela placera le fichier compilé comme suit :
.\com\apple\computers\Dell.class.\com\apple\computers\Ups.class
Vous pouvez importer toutes les classes, interfaces, etc. définies dans compapplecomputers comme suit :
import com.apple.computers.*;
Les fichiers .class compilés doivent être les mêmes que les fichiers sources .java, et le répertoire dans lequel ils sont placés doit être le même que le package. Faites correspondre les noms. Cependant, il n'est pas obligatoire que le chemin du fichier .class soit le même que celui du fichier .java correspondant. Vous pouvez organiser les répertoires sources et classes séparément.
<path-one>\sources\com\apple\computers\Dell.java <path-two>\classes\com\apple\computers\Dell.class
De cette façon, vous pouvez partager votre répertoire de classe avec d'autres programmeurs sans révéler votre code source. Cette gestion du code source et des fichiers de classe permet au compilateur et à la machine virtuelle Java (JVM) de trouver tous les types utilisés dans votre programme.
Le chemin absolu vers le répertoire de classe est appelé chemin de classe. Défini dans la variable système CLASSPATH. Le compilateur et la machine virtuelle Java construisent le chemin d'accès au fichier .class en ajoutant le nom du package au chemin de classe.
<path-two>classes est le chemin de classe, le nom du package est com.apple.computers, et le compilateur et la JVM trouveront le fichier .class dans <path-two>classescomapplecompters.
Un chemin de classe peut contenir plusieurs chemins. Plusieurs chemins doivent être séparés par des délimiteurs. Par défaut, le compilateur et la JVM recherchent dans le répertoire courant. Les fichiers JAR contiennent des classes liées à la plate-forme Java, leurs répertoires sont donc placés par défaut dans le chemin des classes.
Définissez la variable système CLASSPATH
Utilisez la commande suivante pour afficher la variable CLASSPATH actuelle :
Plateforme Windows (sous ligne de commande DOS) -> C:> définir CLASSPATH
Plateforme UNIX (sous Bourne shell) -> % echo $CLASSPATH
Plateforme Windows (sous ligne de commande DOS) -> C:> set CLASSPATH=
Plateforme UNIX (sous Bourne Shell) -> % non défini CLASSPATH ; export CLASSPATH
Définir la variable CLASSPATH :
Plateforme Windows (sous ligne de commande DOS) -> set CLASSPATH=C:usersjackjavaclasses
Plateforme UNIX (sous Bourne shell)-> % CLASSPATH=/home/jack/java/classes; export CLASSPATH
