nom complet

Les paquetages
Principe général

Les paquetages offrent un mécanisme général pour la partition
des modèles et le regroupement des éléments de modélisation.
Chaque paquetage est représenté graphiquement par un
dossier.
Nom du paquetage
Un paquetage possède des éléments de
modélisation
La relation de possession est une composition entre les éléments de
modélisation et leur paquetage associé; elle implique la destruction de tous les
éléments de modélisation contenus dans un paquetage lorsque ce dernier est
détruit.
Les animaux
Animal
Lion
Tigre
Ours
Un élément de modélisation ne peut appartenir qu’à un seul paquetage.
Organisation en paquetages
Les paquetages divisent et organisant les modèles de la même manière
que les répertoires organisent les systèmes fichiers.
L’objectif de la décomposition en paquetage est d’avoir une cohérence
forte entre éléments d’un même paquetage et un couplage faible entre
paquetages.
En général, le contenu d’un paquetage est constitué d’éléments qui
forment un tout cohérent et qui sont proche sémantiquement.
Un paquetage est lui-même un élément de modélisation. Il peut ainsi
contenir d’autres paquetages.
Représentation graphique 1
Un paquetage englobant
Paquetage emboîté
Une classe
Paquetage
emboîté + 1
Une autre classe
Un autre paquetage
emboîté
Lorsqu’une partie ou la totalité du contenu est représentée, le nom du
paquetage est placé dans l’onglet du dossier.
Représentation graphique 2
Un paquetage englobant
Un paquetage
emboîté
Une classe
Un autre paquetage
emboîté
Espace de nommage
Chaque paquetage définit un espace de nommage.
Cela signifie que tous les éléments contenus dans un paquetage se distinguent
par leur appartenance au paquetage englobant.
Deux éléments de modélisation, contenus dans deux paquetages différents,
peuvent ainsi porter le même nom.
Banque
Transaction
commerce
Compte
Client
Compte
Client
Impossible
Définit dans 2 espaces de nommage
différents : autorisé
Nom complet/Nom simple (1)
L’identification d’un élément est obtenue par son nom qui est unique
dans le contexte du paquetage englobant. On parle alors de nom simple.
Le nom complet préfixe le nom simple avec des informations liées à la
hiérarchie des paquetages englobants.
L’opérateur :: permet de séparer les différents noms de la hiérarchie de
paquetages.
Zoo
Zoo::Mammifère
Nom complet : paquetage Mammifère
contenu dans le paquetage Zoo
Mammifère
Nom complet/Nom simple (2)
Le nombre de préfixes d’un nom complet n’est pas limité.
De plus, le nom complet est utilisé aussi bien pour les paquetages que pour
les autres éléments de modélisation.
Zoo
Mammifère
Exotique
Zoo::Mammifère::
Exotique::Kangourou
Kangourou
Il est à noter qu’un paquetage ne peut pas être instancié; il s’agit
uniquement d’un conteneur qui définit un espace de nommage, sans
existence dans le monde réel.
Dépendances entre paquetages (1)
Les dépendances entre paquetages représentent des relations entre
paquetages et non entre éléments individuels.
UML définit deux stéréotypes standard associés aux paquetages :
<<importe>> et <<accède>>.
Les relations de dépendance ainsi stéréotypées impliquent que les
éléments du paquetage destination sont visibles dans le paquetage source;
toutefois, il n’y a pas de relation de possession entre ces paquetages.
Destination1
Source
<<importe>>
<<accède>>
Destination2
Dépendances entre paquetages (2)
La dépendance stéréotypée <<importe>> ajoute les éléments du
paquetage destination à l’espace de nommage défini par le paquetage
source.
Il faut vérifier l’unicité des noms. Si ce n’est pas le cas, il faudra utiliser
le nom complet pour les différencier.
La dépendance stéréotypée <<accède>> permet de référencer des
éléments du paquetage destination. Il est nécessaire d’utiliser leur nom
complet.
Chaque élément contenu dans un paquetage possède un paramètre qui
signale si l’élément est visible ou non à l’extérieur de ce paquetage.
Les valeurs prises par le paramètre sont :
public (symbolisé par +)
privé (symbolisé par -)
Dépendances entre paquetages (3)
Les éléments publics sont accessibles de l’extérieur du paquetage et
constituent les exportations du paquetage.
Ceux qui sont privés ne sont pas accessibles, même s’il existe une
dépendance stéréotypée.
Classe non visible
P2
P1
<<importe>>
- Réalisation
+ Fournisseur
+ Client
+ Entrepôt
Classes d’exportation de P2
Organisation d’un programme JAVA
Un programme JAVA est composé de deux types de fichiers :

–
–



de fichiers d’extension .java contenant les sources du
programme
de fichiers d’extension .class contenant les classes résultant de
la phase de compilation.
L’exécution d’un programme JAVA utilise uniquement tous les
fichiers d’extension .class contenant les classes du
programme.
L’exécution d’un programme JAVA est réalisée avec la
commande java avec comme argument le fichier d’extension
.class contenant la classe principale.
La compilation d’un fichier d’extension .java est réalisée avec
l’utilisation de la commande javac.
Modèle de classes d’un programme JAVA
Fichier.java
1..*
1
1
Programme
JAVA
Classe écrite
en JAVA
compilation
1
1..*
1..*
Fichier.class
0..1
Classe publique
écrite
en JAVA
0..*
Classe privée
écrite
en JAVA
Construction d’un programme java dans un
seul fichier
public class Essai
{ …. }
class toto
{…}
class tata
{…}
Essai.java
javac Essai.java
Essai.class
Exécution : java Essai
toto.class
tata.class
Construction d’un programme composé de
plusieurs fichiers contenant une seule classe
F1.java
(fichier principal)
public class F1
{
…
new F2 ();
…
}
F2.java
public class F2
{
… new F3 ( );
….
}
F3.java
public class F3
{
…
}
Répertoire
Rep11
javac F1.java
F1.class
Exécution : java F1
F2.class
Répertoire Rep11
F3.class
Construction d’un programme java sur
plusieurs fichiers contenant plusieurs classes
F1.java
F2.java
public class F1
{
… new F2();
}
class F4
{
…
}
public class F2
{
… new F4 ( );
…. New F3 ( );
}
F3.java
public class F3
{
…
}
class F5
{
… new F3 ();
}
Répertoire
Rep11
javac F1.java
F1.class
F4.class
Exécution : java F1
F2.class
F3.class
Répertoire
Rep11
F5.class
Construction d’un programme java sur plusieurs
fichiers contenant plusieurs classes (1)
F4.class
F1.class
F1.java
public class F1
{
… new F2();
}
class F4
{
…
}
F2.java
public class F2
{
… new F4 ( );
…. New F3 ( );
}
F3.java
public class F3
{
…
}
class F5
{
… new F3 ();
}
Répertoire
Rep11
javac F2.java
F2.class
Exécution : java F1
F3.class
Répertoire
Rep11
F5.class
Construction d’un programme java sur plusieurs
fichiers contenant plusieurs classes (2)
F1.java
F2.java
public class F1
{
… new F2();
}
class F4
{
…
}
Public class F2
{
… new F4 ( );
…. New F3 ( );
}
F3.java
Public class F3
{
…
}
Class F5
{
… new F3 ();
}
Répertoire
Rep11
javac F2.java
Erreur, la classe F4 n’est pas connue
Remarques

Toute classe publique doit être définie dans un fichier de même nom.

Une classe privée peut être définie dans un fichier ayant déjà une
classe publique ou un autre fichier possédant le même nom.
 ceci est à éviter.
La compilation d’un fichier java génère la création de fichiers .class,
chaque fichier correspondant au résultat de la compilation d’une
classe.


Lors de la compilation d’un fichier java, toutes les classes utilisées
dans ce fichier doivent être accessible au compilateur. Autrement dit, si
ce n’est pas le cas, le compilateur doit pouvoir les générer.

La compilation d’un fichier java peut donc être :
– explicite (l’utilisateur a utilisé la commande javac)
– implicite (dans un fichier le compilateur a rencontre une classe. Or
il n’existe pas de fichier .class correspondant. Il va donc rechercher
le fichier de même nom et le compiler.)
Utilisation de classes situées dans un autre
répertoire

Lors de la phase de compilation, le compilateur vérifie que
toutes les classes utilisées dans le fichier compilé sont
accessibles.

JAVA autorise à ce que ces classes soient situées dans un autre
répertoire.

Le compilateur doit donc connaître où sont situés ces
répertoires.

Ceci est possible grâce à l’utilisation de l’option – classpath.
Utilisation d’une classe située dans un autre
répertoire
F3.java
Public class F3
{
…
}
Class F5
{
… new F3 ();
}
F2.java
Public class F2
{
… new F4 ( );
…. New F3 ( );
}
Répertoire Rep12
javac –classpath .;…\Rep12
Rep12 : F3.java
F3.class
F5.class
F1.java
public class F1
{
… new F2();
}
class F4
{
…
}
F1.java
Rep11: F1.java F1.class
F4.class
F2.java F2.class
java –classpath .;…\Rep12
F1
Répertoire
Rep11
Génération d’une classe dans un autre
répertoire (1)
fichiers
répertoires
F2.java
rep11
D:\ rep1
rep12
public class F2
{
…. new F4 ( );
.. new F3();
}
F1.java
F3.java
public class F1
{
… new F2();
}
class F4
{
…
}
public class F3
{
…
}
class F5
{
… new F3 ();
}
D:\rep1\rep11> javac –d D:\rep1\rep12 F3.java
rep12 : F3.class
F5.class
Rep11 : F2.java
F1.java
F3.java
Génération d’une classe dans un autre
répertoire (2)
D:\rep1\rep11> javac –classpath .;…\rep12 F1.java
rep12 : F3.class
F5.class
rep11 : F1.java F1.class F4.class
F2.java F2.class
F3.java
Exécution :
D:\rep1\rep11> java –classpath .;…\rep12 F1
Utilisation des paquetages en JAVA

Un paquetage en UML correspond à un package en JAVA.

La création d’un package nécessite deux étapes :
– La première consiste à déterminer dans chaque fichier java, à quel package
vont appartenir les classes générées (à savoir les fichiers .class).
– La seconde consiste à placer les fichiers .class générés à une position bien
précise de l’arborescence des fichiers.

L’indication d’un package se fait par l’utilisation du mot clé package :
package nom_du_package ;

Le nom du package doit correspondre à un répertoire dans le système
de fichiers. C’est dans celui-ci que seront stockés les fichiers .class.

L’utilisation d’une classe d’un package implique l’utilisation du mot
clé import :
import nom_du_package.*;
Exemple avec un paquetage
F3package
<< importe >>
+ F2
+ F1
- F4
+ F3
Création et utilisation d’un package
Répertoire rep1
Répertoire F3package;
F1.java
F2.java
import F3package.*;
public class F2
{
.. new F3();
}
F3.java
package F3package;
public class F3
{
…
}
class F5
{
…
}
public class F1
{
… new F2();
}
class F4
{
…
}
javac F1.java
rep1 : F1.java F1.class
F4.class
F2.java F2.class
F3package :
java F1
F3.java F3.class
F5.class
Remarques


Le fichier F5.java se retrouve bien dans le répertoire F3package.
JAVA pourra donc la retrouver.
import F3package.*;
public class F2
{
.. new F3();
}

Dans ce fichier, nous pouvons
utiliser toutes les classes du
package F3package.
Dans ce fichier, nous n’utilisons que la classe F3 du package
F3package. Aussi nous pouvons utiliser l’instruction suivante :
import F3package.F3;
Exemple complété
F3package
<< importe >>
+ F2
- F5
+ F1
interdit
en UML
+ F3
- F4
Création et utilisation d’une classe privée d’un
package hors du package
Répertoire rep1
Répertoire F3package;
F2.java
import F3package.*;
public class F2
{
.. new F3();
… new F5();
}
F1.java
public class F1
{
… new F2();
}
class F4
{
…
}
F3.java
package F3package;
public class F3
{
…
}
class F5
{
… new F3 ();
}
javac F1.java
Erreur : F3package.F5 is not defined in a public class or interface;
cannot be accessed from outside
Association dans un package
F3package
<< importe >>
+ F2
+ F3
- F5
+ F1
- F4
Création et utilisation d’une classe privée d’un
package dans le package
Répertoire rep1
Répertoire F3package;
F2.java
import F3package.*;
public class F2
{
.. new F3();
}
F1.java
F3.java
package F3package;
public class F3
{
… new F5();
}
class F5
{
…
}
public class F1
{
… new F2();
}
class F4
{
…
}
javac F1.java
rep1 : F1.java F1.class F4.class
F2.java F2.class
java F1
F3package :
F3.java
F3.class F5.class
Association entre classes publiques
F3package
<< importe >>
+ F2
+ F3
+ F5
+ F1
- F4
Utilisation de plusieurs classes publiques d’un
package
Répertoire rep1
Répertoire F3package;
F2.java
import F3package.*;
public class F2
{
.. new F3();
… new F5();
}
F1.java
public class F1
{
… new F2();
}
class F4
{
…
}
F3.java
package F3package;
public class F3
{
…
}
package F3package;
public class F5
{
… new F3 ();
}
javac F1.java
rep1 : F1.java F1.class F4.class
F2.java F2.class
java F1
F3package :
F3.java F5.java
F3.class F5.class
Ou se situe le package ?

Dans les exemples que nous avons étudiées, le package était
dans le répertoire courant autrement dit dans le répertoire où on
lançait la compilation et l’exécution du programme java.

JAVA nous donne la possibilité de placer les packages ou on le
désire. Pour cela, nous devons utiliser l’option –classpath.
Le package ne se situe pas dans le répertoire courant (1)
Répertoire rep2
Répertoire rep1
Répertoire F3package
F1.java
F2.java
Import F3package.*;
public class F2
{
.. new F3();
}
public class F1
{
… new F2();
}
class F4
{
…
}
F3.java
Package F3package;
public class F3
{
…
}
class F5
{
… new F3 ();
}
…\rep1> javac –classpath .;…\rep2 F1.java
rep1 : F1.java F1.class F4.class
F2.java F2.class
F3package :
F3.java F3.class
F5.class
…\rep1> java –classpath .;…\rep2 F1
Le package ne se situe pas dans le répertoire courant (2)
Répertoire rep2
Répertoire rep1
Répertoire F3package
F1.java
F2.java
Import F3package.*;
public class F2
{
.. new F3();
}
F3.class
F5.class
public class F1
{
… new F2();
}
class F4
{
…
}
…\rep1> javac –classpath .;…\rep2 F1.java
rep1 : F1.java F1.class F4.class
F2.java F2.class
F3package :
F3.class
F5.class
…\rep1> java –classpath .;…\rep2 F1
Paquetages à stocker hors du répertoire courant
F2package
<<importe>>
F3package
+ F3
+ F2
- F5
<<accède>>
+ F1
Accès à une classe sans l’utilisation de import
Répertoire rep2
Répertoire rep1
Rép. F2package
F1.java
Rép. F3package
F2.java
public class F1
{
…
new F2package .F2() ;
}
class F4
{
…
F3.java
package F2package;
import F3package.*;
public class F2
{
.. new F3();
}
Package F3package;
public class F3
{
…
}
class F5
{
… new F3 ();
}
}
…\rep1> javac
–classpath .;…\rep2
F2package : F2.java
F2.class
…\rep1> java
F1.java
F3package : F3.java
F3.class F5.class
–classpath .;…\rep2
F1
Organisation des paquetages
Fpackage
F2package
<<importe>>
F3package
+ F3
+ F2
- F5
<<importe>>
+ F1
Organisation des paquetages en JAVA
Répertoire rep1
Répertoire Fpackage
F1.java
import Fpackage.F2package.*;
public class F1
{
…
new F2() ;
}
class F4
{
…
Rép. F2package
F2.java
package Fpackage.F2package;
import Fpackage.F3package.*;
public class F2
{
.. new F3();
}
}
…\rep1> javac
rep1 :
F1.java
F1.class
F4.class
F1.java
F2package : F2.java
F2.class
Rép. F3package
F3.java
package Fpackage.F3package;
public class F3
{
…
}
class F5
{
… new F3 ();
}
Exemple de modèle ne contenant que des
paquetages
F2package
F1package
+ F1
<<importe>>
<<accède>>
F3package
+ F3
+ F2
- F5
+ F4
Programme ne contenant que des packages (1)
Répertoire rep2
Rép. F1package
F1.java
package F1package;
public class F1
{
…
new F2package .F2() ;
}
class F4
{
…
Rép. F2package
Rép. F3package
F2.java
package F2package;
import F3package.*;
public class F2
{
.. new F3();
}
}
F3.java
Package F3package;
public class F3
{
…
}
class F5
{
… new F3 ();
}
…\rep2> javac F1package\F1.java
F1package : F1.java
F1.class
F4.class
F2package : F2.java
F2.class
…\rep2> java F1package.F1
F3package :F3.java
F3.class
F5.class
Programme ne contenant que des packages (2)
Répertoire rep1
Répertoire rep2
Rép. F1package
F1.java
package F1package;
public class F1
{
…
new F2package .F2() ;
}
class F4
{
…
Rép. F2package
F2.java
package F2package;
import F3package.*;
public class F2
{
.. new F3();
}
}
Rép. F3package
F3.java
Package F3package;
public class F3
{
…
}
class F5
{
… new F3 ();
}
…\F1package> javac –classpath .;…\rep2 F1.java
F1package : F1.java
F1.class
F4.class
F2package : F2.java
F2.class
F3package :F3.java
F3.class
F5.class
Création d’une archive



Une archive (d’extension .jar) contient les fichiers .class et
également les packages.
Les archives Java permettent une diffusion plus efficace des
programmes : on n’a plus qu’à transférer un seul fichier au lieu de
tous ceux constituant le programme.
L’utilitaire jar permet de créer des archives. Voici quelques
informations :
Usage : jar {ctx} [vf0] [jar-file] files …
Options:
c crée une nouvelle archive
t liste le contenu d’une archive
x restitue les fichiers nommés (tous par défaut) d’une archive
v génère un affichage sur la sortie standard d’erreur
f spécifie le nom de l’archive
0 annule la compression de l’archive
Informations complémentaires

Exemple : pour archiver deux fichiers F1.class et F2.class dans
une nouvelle archive (a1.jar), il suffit de procéder de la manière
suivante:
jar cvf a1.jar f1.class f2.class

Si un nom de fichier correspond à un répertoire, alors ce dernier
sera archivé dans son intégralité.

L’utilisation d’une archive implique l’utilisation de l’option
classpath

Exemple : l’utilisation de la classe f2.class par un programme p1
se réalise de la manière suivante :
javac –classpath .; …\a1.jar p1.java
Exemple : utilisation d’une archive sans
package (1)
rep1
rep1
F3.java
public class F3
{
…
}
Class F5
{
… new F3 ();
}
F3.class
F3.java
F5.class
F3.class
F3.java
F5.class
F3.jar
…\rep1>jar cvf F3.jar F3.class F5.class
…\rep1>javac F3.java
rep2
….\rep1>move F3.jar …\rep2
F3.jar
Exemple : utilisation d’une archive sans
package (2)
rep11
F1.java
(fichier principal)
public class F1
{
…
new F2 ();
…
}
F2.java
rep2
F3.jar
public class F2
{
… new F3 ( );
….
}
javac –classpath .;…\rep2\F3.jar F1.java
Répertoire Rep11
F1.class
Exécution : java F1
F2.class
Exemple : utilisation d’une archive avec un
package
Répertoire rep2
Répertoire rep1
F2.java
Import F3package.*;
public class F2
{
.. new F3();
}
Répertoire F3package
F1.java
F3.class
F5.class
public class F1
{
… new F2();
}
class F4
{
…
}
…\rep2> jar cvf F3.jar F3package
…
…\rep1>javac –classpath .;…\rep2\F3.jar F1.java