Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les Paquetages

La Programmation Orientée Objet en Java : Les Paquetages

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

Un paquetage peut être défini comme un regroupement de types liés (classes, interfaces, énumérations et annotations) offrant une protection d'accès et une gestion de l'espace de noms.

Certains des paquetages existants en Java qui sont :

  • Java.lang : regroupe les classes fondamentales
  • Java.io : classes pour l'entrée, les fonctions de sortie sont regroupées dans ce paquetage

Les programmeurs peuvent définir leurs propres paquetages pour regrouper un groupe de classes/interfaces, etc. C'est une bonne pratique de regrouper des classes liées implémentées par vous afin qu'un programmeur puisse facilement déterminer que les classes, les interfaces, les énumérations, les annotations sont liées.

Comme le package crée un nouvel espace de noms, il n'y aura aucun conflit de noms avec des noms dans d'autres paquetages. En utilisant les paquetages, il est plus facile de fournir un contrôle d'accès et il est également plus facile de localiser les classes associées.

Création d'un paquetage

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

Le mot clé  package doit être la première ligne dans le fichier source. Il ne peut y avoir qu'un seul paquetage dans chaque fichier source, et il s'applique à tous les types du fichier.

Si un paquetage n'est pas utilisé, la classe, les interfaces, les énumérations et les types d'annotations seront placés dans un paquetage sans nom.

Exemple:

Examinons un exemple qui crée un paquetage appelé animaux . Il est courant d'utiliser des noms de paquetages en minuscule pour éviter tout conflit avec les noms des classes, des interfaces.

Mettre une interface dans les paquetages animaux :

/* File name : Animal.java */
package animals;
interface Animal {
   public void eat();
   public void travel();
}

 Maintenant, mettez une mise en œuvre dans le même paquetage animaux:

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, vous compilez ces deux fichiers et mettez-les dans un sous-répertoire appelé animaux et essayez de lancer comme suit:

$ mkdir animals

$ cp Animal.class  MammalInt.class animals

$ java animals/MammalInt

Mammal eats

Mammal travels

Le mot clé import

Si une classe souhaite utiliser une autre classe dans le même paquetage, le nom du package ne doit pas être utilisé. Les classes dans le même paquetage se rencontrent sans aucune syntaxe spéciale.

Exemple:

Ici, une classe nommée Boss est ajoutée au paquetage de payroll qui contient déjà Employee. Le Boss peut ensuite se référer à la classe Employee sans utiliser le préfixe payroll, comme en témoigne la classe Boss suivante.

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

 Que se passe-t-il si Boss n'est pas dans le paquetage de payroll? La classe Boss doit alors utiliser l'une des techniques suivantes pour se référer à une classe dans un autre paquetage.

  • 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 suivi de l’astérisque (*). Par exemple:
import payroll.*;
  • La classe elle-même peut être importée en utilisant le mot clé import. Par exemple:
import payroll.Employee;

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

Structure du répertoire des packages

Deux grands résultats se produisent lorsqu'une classe est placée dans un paquetage:

  • Le nom du paquetage devient une partie du nom de la classe, comme nous venons de l'expliquer dans la section précédente.
  • Le nom du package doit correspondre à la structure du répertoire où réside le bytecode correspondant.

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

Mettez le code source pour une classe, une interface, une énumération ou un type 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 vehicule;

public class Car {
   // Class implementation. 
}

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

  ....\vehicule\Car.java

 Maintenant, le nom et le nom de la classe qualifiés seraient les suivants:

  • Nom de classe -> vehicule.Car
  • Nom du chemin -> vehicule\Car.java (sous windows)

En général, une entreprise utilise son nom de domaine Internet inversé pour ses noms de paquetages. Exemple: le nom de domaine Internet d'une entreprise est apple.com, tous ses noms de paquetages commencent par com.apple . Chaque composant du nom du package correspond à un sous-répertoire.

Exemple: l’entreprise avait un package com.apple.computers qui contenait un fichier source Dell.java, il serait contenu dans une série de sous-répertoires comme ceci:

....\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 définie dans celui-ci. 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

 Cela mettrait les fichiers 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 sources .java, les fichiers .class compilés doivent figurer 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 être identique au chemin d'accès aux fichiers sources .java. Vous pouvez organiser vos répertoires source et classe séparément, comme suit:

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

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

 Ce faisant, il est possible de donner le 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 façon afin que le compilateur et la machine virtuelle Java (JVM) puissent trouver tous les types utilisés par votre programme.

Le chemin d'accès complet au répertoire des classes, <path-two>\classes, s'appelle le chemin de la classe 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 de la classe.

Dites <path-two>\classes est le chemin de la classe, et le nom du package est com.apple.computers, alors le compilateur et JVM rechercheront les fichiers .class dans <path-two>\classes\com\apple\compters.

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 actuel et le fichier JAR contenant les classes de plateforme Java afin que ces répertoires apparaissent automatiquement dans le chemin de la classe.

Définir la variable système  CLASSPATH

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

  • Dans Windows -> C:\> set CLASSPATH
  • Dans UNIX ->echo $CLASSPATH

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

  • Dans Windows -> C:\> set CLASSPATH=
  • Dans UNIX -> unset CLASSPATH; export CLASSPATH

Pour définir la variable CLASSPATH:

  • Dans Windows -> set CLASSPATH=C:\users\jack\java\classes
  • Dans UNIX ->CLASSPATH=/home/jack/java/classes; export CLASSPATH

 




Vous êtes ici :
Accueil Cours Programmations La Programmation Orientée Objet en Java Les Paquetages