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 Ours Tigre Lion 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. commerce Banque Compte Transaction 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 Mammifère Nom complet : paquetage Mammifère contenu dans le paquetage Zoo

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 Kangourou Zoo::Mammifère:: Exotique::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 <<importe>> Source Destination2 <<accède>>

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 - Réalisation P1 <<importe>> + Fournisseur + Entrepôt + Client 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 Classe écrite en JAVA Fichier.java 1..* 1 0..* 0..1 1 Classe publique écrite en JAVA Classe privée écrite en JAVA Programme JAVA compilation 1 1..* 1..* Fichier.class

Construction d’un programme java dans un seul fichier public class Essai { …. } class toto { … } class tata Essai.java javac Essai.java Essai.class toto.class tata.class Exécution : java Essai

Construction d’un programme composé de plusieurs fichiers contenant une seule classe F1.java (fichier principal) public class F2 { … new F3 ( ); …. } F2.java F3.java public class F1 { … new F2 (); } public class F3 { … } Répertoire Rep11 javac F1.java Répertoire Rep11 F1.class F2.class F3.class Exécution : java F1

Construction d’un programme java sur plusieurs fichiers contenant plusieurs classes F1.java public class F2 { … new F4 ( ); …. New F3 ( ); } F2.java F3.java public class F1 { … new F2(); } class F4 … public class F3 { … } class F5 … new F3 (); Répertoire Rep11 javac F1.java Répertoire Rep11 F1.class F4.class F2.class F3.class F5.class Exécution : java F1

Construction d’un programme java sur plusieurs fichiers contenant plusieurs classes (1) F1.java public class F2 { … new F4 ( ); …. New F3 ( ); } F2.java F3.java F4.class Répertoire Rep11 public class F1 { … new F2(); } class F4 … public class F3 { … } class F5 … new F3 (); F1.class javac F2.java Répertoire Rep11 F2.class F3.class F5.class Exécution : java F1

Construction d’un programme java sur plusieurs fichiers contenant plusieurs classes (2) F1.java Public class F2 { … new F4 ( ); …. New F3 ( ); } F2.java F3.java public class F1 { … new F2(); } class F4 … 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 (); Public class F2 { … new F4 ( ); …. New F3 ( ); } F2.java F1.java Répertoire Rep11 public class F1 { … new F2(); } class F4 … Répertoire Rep12 javac –classpath .;…\Rep12 F1.java Rep12 : F3.java F3.class F5.class Rep11: F1.java F1.class F4.class F2.java F2.class java –classpath .;…\Rep12 F1

Génération d’une classe dans un autre répertoire (1) fichiers répertoires public class F2 { …. new F4 ( ); .. new F3(); } F2.java F1.java F3.java rep11 public class F1 { … new F2(); } class F4 … public class F3 { … } class F5 … new F3 (); D:\ rep1 rep12 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 >> + F3 + F2 + F1 - F4

Création et utilisation d’un package Répertoire rep1 Répertoire F3package; F1.java F3.java F2.java public class F1 { … new F2(); } class F4 … package F3package; public class F3 { … } class F5 import F3package.*; public class F2 { .. new F3(); } javac F1.java rep1 : F1.java F1.class F4.class F2.java F2.class F3package : F3.java F3.class F5.class java F1

Remarques Le fichier F5.java se retrouve bien dans le répertoire F3package. JAVA pourra donc la retrouver. Dans ce fichier, nous n’utilisons que la classe F3 du package F3package. Aussi nous pouvons utiliser l’instruction suivante : import F3package.F3; import F3package.*; public class F2 { .. new F3(); } Dans ce fichier, nous pouvons utiliser toutes les classes du package F3package.

Exemple complété F3package + F3 + F2 - F5 + F1 interdit en UML - F4 << importe >> + F3 + F2 - F5 + F1 interdit en UML - F4

Création et utilisation d’une classe privée d’un package hors du package Répertoire rep1 Répertoire F3package; F1.java F3.java F2.java public class F1 { … new F2(); } class F4 … package F3package; public class F3 { … } class F5 … new F3 (); import F3package.*; public class F2 { .. new F3(); … new F5(); } 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 >> + F3 + F2 - F5 + F1 - F4

Création et utilisation d’une classe privée d’un package dans le package Répertoire rep1 Répertoire F3package; F1.java F3.java F2.java public class F1 { … new F2(); } class F4 … package F3package; public class F3 { … new F5(); } class F5 … import F3package.*; public class F2 { .. new F3(); } javac F1.java rep1 : F1.java F1.class F4.class F2.java F2.class F3package : F3.java F3.class F5.class java F1

Association entre classes publiques F3package << importe >> + F3 + F2 + F5 + F1 - F4

Utilisation de plusieurs classes publiques d’un package Répertoire rep1 Répertoire F3package; F1.java F2.java F3.java public class F1 { … new F2(); } class F4 … import F3package.*; public class F2 { .. new F3(); … new F5(); } 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 F3package : F3.java F5.java F3.class F5.class java F1

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 public class F1 { … new F2(); } class F4 … F1.java F3.java Import F3package.*; public class F2 { .. new F3(); } F2.java Package F3package; public class F3 { … } class F5 … new F3 (); …\rep1> javac –classpath .;…\rep2 F1.java F3package : F3.java F3.class F5.class rep1 : F1.java F1.class F4.class F2.java F2.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 public class F1 { … new F2(); } class F4 … F1.java F5.class F3.class Import F3package.*; public class F2 { .. new F3(); } F2.java …\rep1> javac –classpath .;…\rep2 F1.java F3package : F3.class F5.class rep1 : F1.java F1.class F4.class F2.java F2.class …\rep1> java –classpath .;…\rep2 F1

Paquetages à stocker hors du répertoire courant F2package F3package <<importe>> + F3 + F2 - F5 <<accède>> + F1

Accès à une classe sans l’utilisation de import Répertoire rep2 Répertoire rep1 Rép. F2package Rép. F3package F1.java F2.java F3.java package F2package; import F3package.*; public class F2 { .. new F3(); } public class F1 { … new F2package .F2() ; } class F4 Package F3package; public class F3 { … } class F5 … new F3 (); …\rep1> javac –classpath .;…\rep2 F1.java F2package : F2.java F2.class F3package : F3.java F3.class F5.class …\rep1> java –classpath .;…\rep2 F1

Organisation des paquetages Fpackage F2package F3package <<importe>> + F3 + F2 - F5 <<importe>> + F1

Organisation des paquetages en JAVA Répertoire rep1 Répertoire Fpackage Rép. F2package Rép. F3package F1.java import Fpackage.F2package.*; public class F1 { … new F2() ; } class F4 F2.java F3.java package Fpackage.F2package; import Fpackage.F3package.*; public class F2 { .. new F3(); } package Fpackage.F3package; public class F3 { … } class F5 … new F3 (); …\rep1> javac F1.java rep1 : F1.java F1.class F4.class F2package : F2.java F2.class

Exemple de modèle ne contenant que des paquetages F2package F3package F1package <<importe>> <<accède>> + F3 + F1 + F2 - F5 + F4

Programme ne contenant que des packages (1) Répertoire rep2 Rép. F1package Rép. F2package F1.java Rép. F3package package F1package; public class F1 { … new F2package .F2() ; } class F4 F2.java F3.java package F2package; import F3package.*; public class F2 { .. new F3(); } 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 F3package :F3.java F3.class F5.class …\rep2> java F1package.F1

Programme ne contenant que des packages (2) Répertoire rep1 Répertoire rep2 Rép. F1package Rép. F2package F1.java Rép. F3package package F1package; public class F1 { … new F2package .F2() ; } class F4 F2.java F3.java package F2package; import F3package.*; public class F2 { .. new F3(); } Package F3package; public class F3 { … } class F5 … new F3 (); …\F1package> javac –classpath .;…\rep2 F1.java F3package :F3.java F3.class F5.class F1package : F1.java F1.class F4.class F2package : F2.java F2.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 F3.java F3.java F3.class F3.class public class F3 { … } Class F5 … new F3 (); F3.jar F5.class F5.class …\rep1>jar cvf F3.jar F3.class F5.class …\rep1>javac F3.java ….\rep1>move F3.jar …\rep2 rep2 F3.jar

Exemple : utilisation d’une archive sans package (2) rep11 F1.java (fichier principal) rep2 public class F2 { … new F3 ( ); …. } F2.java F3.jar public class F1 { … new F2 (); } javac –classpath .;…\rep2\F3.jar F1.java Répertoire Rep11 F1.class F2.class Exécution : java F1

Exemple : utilisation d’une archive avec un package Répertoire rep2 Répertoire rep1 Répertoire F3package public class F1 { … new F2(); } class F4 … F1.java F5.class F3.class Import F3package.*; public class F2 { .. new F3(); } F2.java …\rep2> jar cvf F3.jar F3package … …\rep1>javac –classpath .;…\rep2\F3.jar F1.java