Un package est un ensemble de classes , d'interfaces et d'autres packages regroupés sous un nom. Il correspondent, en quelque sorte, au concept de librairies adapté au langage Java. Un fichier source destiné à faire partie du package monpackage doit préciser son appartenance par la déclaration :
Cette déclaration précise que toutes les classes et interfaces définies dans ce fichier font partie du package monpackage. Elle doit apparaître avant toute déclaration de classes et interfaces. Le nom d'un package sert de convention de nommage : il constitue en sorte de préfixe pour chaque nom figurant dans le fichier source.
package monpackage ;
Dans le langage Java , les variables statiques font forcément partie d'une classe ; le concept de variables globales n'existe pas. De même, toutes les classes font toujours partie d'un package.
Lorsqu'on veut utiliser une classe d'un package, le moyen le plus direct est de nommer cette classes par son absolu (fully qualified name ) :
On aura compris que cette manière de faire est bien trop fastidieuse pour qu'on s'en contente. Pour éviter cette lourdeur, Java dispose de la directive import. Il s'agit de prévenir le compilateur que l'on risque d'utiliser des noms simplifiés pour nos classes et qu'il devra préfixé tout seul les noms de classes quand c'est nécessaire.
CoursJava.monpackage.Date d ; d = new CoursJava.monpackage.Date(15, 9, 57) ;
Une fois cette classe importée, on pourra désormais utiliser les noms simplifiés pour les classes importées.
import CoursJava.monpackage.Date ;
Que se passe-t-il quand dans deux packages importés que l'on veut importer, les noms des classes sont identiques. Il faudra alors prendre sont courage à deux mains et utiliser les noms pleinement qualifiés pour résoudre ce conflit.
Date d = new Date(15, 9, 57) ;
Dans notre exemple Date, nous n'avions besoin d'importer qu'une seule classe. Dans des situations plus réalistes, il est fréquent qu'on soit obliger d'importer plusieurs classes. Il serait fastidieux d'importer une à une toutes les classes qui nous intéressent. Par exemple, pour réaliser une application graphique, il serait bien trop fastidieux d'importer, une à une, toutes les classes qui correspondent aux divers widgets que l'on veut utiliser. Java propose d'importer en bloc, un ensemble de packages par la directive :
Avec cette directive , toutes classes du package monpackage sont importées et on pourra utiliser les noms simplifiés pour toutes ses classes.
import FR.univ-mrs.esil.gbm.touraivane.CoursJava.monpackage.* ;
La directive import se décline également sous la forme :
Cette forme permet de nommer les classes de ce package en utilisant uniquement sa dernière composante : la classe
import CoursJava.monpackage ;
peut désormais être nommée par monpackage.X.
CoursJava.monpackage.X
Ces classes sont considérées comme ``dignes de confiance'' car résidant dans la machine locale. Le chargement de ces classes se fait sans faire appel au vérificateur de code ; ceci permet de réaliser des classes avec des optimisations qui contre-viennent au contrôle de sécurité du code Java .
Une autre manière de spécifier les répertoires où sont stockés les classes consiste à les donner sur la ligne de commande lors de l'invocation de l'interpréteur Java . avec l'option -classpath.
Les packages peuvent être organisés de manière hiérarchique. Le package java de jdk est en fait une collection d'autres packages : lang, awt, etc. Ce package ne contient aucune classe ni interface. Le package java.lang est également une collection d'autres packages : Math, String, etc. Enfin le java.lang.io est un package qui contient les classes pour la gestion des entrées/sorties.
Le nom absolu d'un package définit également la structure du système
de fichier. Par exemple, la classe java.lang.Math se trouve
dans le répertoire java/lang/Math ou
java
lang
Math selon la nature du système d'exploitation
utilisé.
Nous avons déjà évoqué les qualifiers public et private pour les membres des classes ainsi que pour les classes elle-même. Maintenant que nous savons ce que sont les classes, les classes dérivées, les interfaces et packages, nous allons revoir et compléter ces concepts.
Les classes sans qualifier, comme la classe Date que nous avons définie, sont des classes qui accessibles de toutes les classes du package auquel il appartient. Cette appartenance doit se comprendre au sens strict, c'est à dire que la classe Date est accessible à toutes les classes de son package mais n'est pas accessible aux classes des packages contenus celui-ci. Pour rendre accessible notre classe Date à toutes les autres classes, il faut qualifier de public la classe Date :
Java impose une restriction sur les nombre de classes publiques que l'on est autorisé à définir dans une unité de compilation : Il ne doit y avoir qu'une seule classe publique par unité de compilation et le nom de ce dernier doit être le même que celui la classe publique suffixé par l'extension ``.java''.
public class Date { .... }
Les classes peuvent être qualifiés de public ou ne pas être qualifiée.

Les membres d'une classes peuvent être qualifiés public, private ou protected. Il peuvent également ne pas être qualifiés.
- Membres private :
- ils ne sont accessibles qu'à l'intérieur de sa propre classe : c'est l'accessibilité minimale.
- Membres protected :
- ils sont accessibles à partir de sa propre classe, de toutes ses classes dérivées et toutes les classes appartenant au même package. Il n'est pas nécessaire que les classes dérivées appartienne au même package que la classe de base.
- Membres non qualifié :
- ils accessibles à partir de toutes les classes du package.
- Membres public :
- ils sont accessibles à partir de n'importe quelle classe de n'importe quel package : c'est l'accessibilité maximale.

Une méthode privée d'une classe de base peut être redéfinie dans une sous classe en un méthode publique. L'inverse n'est pas permis. Par contre, cette restriction n'existe pas pour les variables d'instances et de classe.
La convention adoptée consiste à préfixer le package par le nom de domaine Internet où il a été réalisé. Pour avoir réaliser le package monpackage à l'ESIL, on conviendra de la nommer :
package FR.univ-mrs.esil.monpackage ;
On remarquera que le domaine de plus haut niveau (ici FR) est noté en majuscule. Cette convention ne résout évidemment pas tous les collisions de noms ; il ne règle le problème qu'entre les divers domaines Internet . Il reste en encore à résoudre les problèmes internes au domaine de l'ESIL . Il suffit alors de raffiner cette convention en subdivisant le domaine ESIL en sous domaines. Par exemple, pour s'assurer que le package monpackage n'est pas en conflit avec d'autres package de l'ESIL , on pourrait décider que celui-ci serait nommé :
package FR.univ-mrs.esil.gbm.touraivane.CoursJava.monpackage ;