Java - Paquets

Les packages sont utilisés en Java pour éviter les conflits de dénomination, contrôler l'accès, faciliter la recherche / localisation et l'utilisation des classes, interfaces, énumérations et annotations, etc.

UNE Package peut être défini comme un regroupement de types associés (classes, interfaces, énumérations et annotations) assurant la protection d'accès et la gestion des espaces de noms.

Certains des packages existants en Java sont -

  • java.lang - regroupe les classes fondamentales

  • java.io - les classes d'entrée, les fonctions de sortie sont regroupées dans ce package

Les programmeurs peuvent définir leurs propres packages pour regrouper des groupes de classes / interfaces, etc.

Puisque le package crée un nouvel espace de noms, il n'y aura pas de conflit de nom avec les noms d'autres packages. À l'aide de packages, il est plus facile de fournir un contrôle d'accès et de localiser les classes associées.

Créer un package

Lors de la création d'un package, vous devez choisir un nom pour le package et inclure un package avec ce nom en haut de chaque fichier source qui contient les classes, interfaces, énumérations et types d'annotations que vous souhaitez inclure dans le package.

L'instruction package doit être la première ligne du fichier source. Il ne peut y avoir qu'une seule instruction de package dans chaque fichier source, et elle s'applique à tous les types du fichier.

Si une instruction de package n'est pas utilisée, la classe, les interfaces, les énumérations et les types d'annotations seront placés dans le package par défaut actuel.

Pour compiler les programmes Java avec des instructions de package, vous devez utiliser l'option -d comme indiqué ci-dessous.

javac -d Destination_folder file_name.java

Ensuite, un dossier avec le nom de package donné est créé dans la destination spécifiée et les fichiers de classe compilés seront placés dans ce dossier.

Exemple

Regardons un exemple qui crée un package appelé animals. Il est recommandé d'utiliser les noms des packages avec des lettres minuscules pour éviter tout conflit avec les noms des classes et des interfaces.

L'exemple de package suivant contient une interface nommée animals -

/* File name : Animal.java */
package animals;

interface Animal {
   public void eat();
   public void travel();
}

Maintenant, implémentons l'interface ci-dessus dans le même package animals -

package animals;
/* File name : 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();
   }
}

Maintenant, compilez les fichiers java comme indiqué ci-dessous -

$ javac -d . Animal.java 
$ javac -d . MammalInt.java

Maintenant, un package / dossier avec le nom animals sera créé dans le répertoire courant et ces fichiers de classe y seront placés comme indiqué ci-dessous.

Vous pouvez exécuter le fichier de classe dans le package et obtenir le résultat comme indiqué ci-dessous.

Mammal eats
Mammal travels

Le mot-clé d'importation

Si une classe souhaite utiliser une autre classe dans le même package, le nom du package n'a pas besoin d'être utilisé. Les classes d'un même package se trouvent sans aucune syntaxe particulière.

Exemple

Ici, une classe nommée Boss est ajoutée au package de paie qui contient déjà Employee. Le patron peut alors faire référence à la classe Employee sans utiliser le préfixe de paie, comme le montre la classe Boss suivante.

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

Que se passe-t-il si la classe Employé ne fait pas partie du package de paie? La classe Boss doit ensuite utiliser l'une des techniques suivantes pour faire référence à une classe dans un package différent.

  • Le nom complet de la classe peut être utilisé. Par exemple -
payroll.Employee

  • Le package peut être importé à l'aide du mot-clé import et du caractère générique (*). Par exemple -

import payroll.*;
  • La classe elle-même peut être importée à l'aide du mot-clé import. Par exemple -
import payroll.Employee;

Note- Un fichier de classe peut contenir n'importe quel nombre d'instructions d'importation. Les instructions d'importation doivent apparaître après l'instruction package et avant la déclaration de classe.

La structure des répertoires des packages

Deux résultats majeurs se produisent lorsqu'une classe est placée dans un package -

  • Le nom du package devient une partie du nom de la classe, comme nous venons de le voir dans la section précédente.

  • Le nom du package doit correspondre à la structure de répertoires où réside le bytecode correspondant.

Voici un moyen simple de gérer vos fichiers en Java -

Placez le code source d'un type de classe, d'interface, d'énumération ou d'annotation dans un fichier texte dont le nom est le nom simple du type et dont l'extension est .java.

Par exemple -

// File Name :  Car.java
package vehicle;

public class Car {
   // Class implementation.   
}

Maintenant, placez le fichier source dans un répertoire dont le nom reflète le nom du package auquel appartient la classe -

....\vehicle\Car.java

Maintenant, le nom de classe qualifié et le chemin seraient les suivants -

  • Nom de la classe → véhicule.
  • Nom du chemin → véhicule \ Car.java (dans Windows)

En général, une entreprise utilise son nom de domaine Internet inversé pour ses noms de package.

Example- Le nom de domaine Internet d'une entreprise est apple.com, alors tous ses noms de package commenceraient par com.apple. Chaque composant du nom du package correspond à un sous-répertoire.

Example - La société avait un package com.apple.computers contenant un fichier source Dell.java, il serait contenu dans une série de sous-répertoires comme celui-ci -

....\com\apple\computers\Dell.java

Au moment de la compilation, le compilateur crée un fichier de sortie différent pour chaque classe, interface et énumération qui y sont définies. Le nom de base du fichier de sortie est le nom du type et son extension est.class.

Par exemple -

// File Name: Dell.java
package com.apple.computers;

public class Dell {
}

class Ups {
}

Maintenant, compilez ce fichier comme suit en utilisant l'option -d -

$javac -d . Dell.java

Les fichiers seront compilés comme suit -

.\com\apple\computers\Dell.class
.\com\apple\computers\Ups.class

Vous pouvez importer toutes les classes ou interfaces définies dans \ com \ apple \ computers \ comme suit -

import com.apple.computers.*;

Comme les fichiers source .java, les fichiers .class compilés doivent se trouver dans une série de répertoires qui reflètent le nom du package. Cependant, le chemin d'accès aux fichiers .class ne doit pas nécessairement être le même que le chemin d'accès aux fichiers source .java. Vous pouvez organiser vos répertoires source et classe séparément, comme -

<path-one>\sources\com\apple\computers\Dell.java

<path-two>\classes\com\apple\computers\Dell.class

En faisant cela, il est possible de donner accès au répertoire des classes à d'autres programmeurs sans révéler vos sources. Vous devez également gérer les fichiers source et de classe de cette manière afin que le compilateur et la machine virtuelle Java (JVM) puissent trouver tous les types utilisés par votre programme.

Le chemin complet du répertoire classes, <chemin-deux> \ classes, est appelé chemin d'accès aux classes et est défini avec la variable système CLASSPATH. Le compilateur et la JVM construisent le chemin d'accès à vos fichiers .class en ajoutant le nom du package au chemin d'accès aux classes.

Dites que <chemin-deux> \ classes est le chemin de la classe et que le nom du package est com.apple.computers, le compilateur et la JVM chercheront les fichiers .class dans <chemin-deux> \ classes \ com \ apple \ computers.

Un chemin de classe peut inclure plusieurs chemins. Les chemins multiples doivent être séparés par un point-virgule (Windows) ou deux-points (Unix). Par défaut, le compilateur et la JVM recherchent le répertoire courant et le fichier JAR contenant les classes de la plateforme Java afin que ces répertoires soient automatiquement dans le chemin des classes.

Définir la variable système CLASSPATH

Pour afficher la variable CLASSPATH actuelle, utilisez les commandes suivantes sous Windows et UNIX (Bourne shell) -

  • Sous Windows → C: \> définissez CLASSPATH
  • Sous UNIX →% echo $ CLASSPATH

Pour supprimer le contenu actuel de la variable CLASSPATH, utilisez -

  • Sous Windows → C: \> définissez CLASSPATH =
  • Sous UNIX →% unset CLASSPATH; exporter CLASSPATH

Pour définir la variable CLASSPATH -

  • Sous Windows → définissez CLASSPATH = C: \ users \ jack \ java \ classes
  • Sous UNIX →% CLASSPATH = / home / jack / java / classes; exporter CLASSPATH