TP de Java

1
TP de Java
Package et Outils SDK
_____________________
Sujets abordés dans ce TP :
Introduction au package
Définition de package
Package local
Droits d’accès
Introduction aux outils SDK
javac et java
jar
javadoc
1) Introduction
Dans ce TP nous vous proposons de développer la notion de package en Java, et l’utilisation des
outils SDK. On rappelle qu’en Java les différentes classes sont structurées sous forme de package
correspondant à un regroupement de classes, sous un identificateur commun (correspondant au
nom du package). Ces packages sont structurés à la manière d’un arbre en packages et sous-
packages. Cette notion facilite le développement et la cohabitation d’applications
« conséquentes », en isolant l’ensemble des classes existantes. L’implémentation de package
complique les mises en œuvre du code Java via les outils standards SDK. Ce TP développe
l’utilisation de ces outils dans le cadre d’utilisation de packages.
2) Package
Introduction
L’importation de package en Java se fait via l’instruction import en en-tête de fichier. Le
séparateur ‘.’ est utilisé pour séparer les noms de packages et de sous-packages. Le suffixe ‘*’
définit que toutes les classes du package doivent être importées. Le suffixe ‘*’ peut également être
substitué par un nom de classe, afin de filtrer individuellement les classes importées du package.
L’importation de toutes les classes d’un package n’augmente ni la taille du byte code Java, ni le
temps d’exécution du programme. Le filtrage des classes lors de l’importation d’un package n’a
d’utilité que de limiter les ambiguïtés en cas de classes de noms similaires entre différents
packages importés. Dans ce cas, on utilise le nom du package en plus du nom de la classe pour
lever ces ambiguïtés. L’exemple suivant résume ces différents principes (déjà évoqués dans les TP
précédents), pour l’utilisation de deux classes Vector en parallèle :
import java.lang.*;
import java.util.Vector;
class Vector {}
class Stack {
private java.util.Vector v1;
private Vector v2;
String stackName;
}
Dans cet exemple, l’importation complète (*) du package java.lang est effectuée. Cette directive
est en fait facultative (nous l’utilisons ici à titre d’exemple), en effet ce package est
obligatoirement importé par défaut dans les programmes Java. Implémenter le code suivant afin
de vérifier cette importation par défaut. Vous pouvez vérifier que la classe String est définie dans
le package java.lang, vous l’utilisez cependant ici sans avoir recours à l’instruction import
java.lang.String.
class Default {
String s1;
}
Définition de package
L’API specification SDK contient plusieurs packages standards. Il est cependant possible pour un
programmeur Java de définir ses propres packages à l’aide du mot clé package. Créer un
répertoire (package), dans ce répertoire (package) créer un sous-répertoire (myp). Dans ce sous-
répertoire (myp), créer un fichier (MyClass.java). Implémentez le code suivant dans ce fichier, et
compilez-le :
package myp;
public class MyClass {
public void print()
{System.out.println("first package");}
}
Retourner dans le répertoire (package), implémenter le code suivant dans un fichier (App.java) et
le mettre en œuvre :
import myp.*;
public class App {
public static void main(String args[])
{
MyClass my = new MyClass();
my.print();
}
}

2
Dans cet exemple, vous avez défini votre premier package myp constitué d’une classe MyClass.
Vous avez importé et mis en oeuvre ce package dans votre programme principal à l’aide de
l’instruction import myp.*.
Retourner dans votre répertoire (myp) et créer un sous-répertoire (mypp). Dans ce sous-répertoire
(mypp), créer un fichier (MyPClass.java) et implémenter le code suivant, compiler :
package myp.mypp;
public class MyPClass {
public void print()
{System.out.println("first sub-package");}
}
Retourner dans le répertoire (package), redéfinir le fichier (App.java) de la façon suivante et le
mettre en œuvre :
import myp.*;
import myp.mypp.*;
public class App {
public static void main(String args[])
{
MyClass my = new MyClass(); my.print();
MyPClass myp = new MyPClass(); myp.print();
}
}
Dans cet exemple, vous avez défini votre premier sous-package mypp du package myp constitué
d’une classe MyPClass. Vous avez importé et mis en oeuvre ce package dans votre programme
principal à l’aide de l’instruction import myp.mypp.*.
Package local
Cependant, sans le savoir vous avez déjà défini des packages à plusieurs reprises dans vos
programmes Java. En effet, lorsque vous compilez différentes classes stockées en (.class) dans un
même répertoire, vous constituez un package local (sans nom). Implémenter l’exemple suivant et
le mettre en oeuvre.
class Random {}
public class App {
public static void main(String args[])
{System.out.println(new Random());}
}
Placer ensuite la définition de la classe Random en commentaire, sans supprimer le fichier
(Random.class) du répertoire local, recompiler l’ensemble, commenter. Supprimer ensuite le
fichier (Random.class) du répertoire local et recompiler l’ensemble.
Vous voyez dans cet exemple qu’il n’est pas nécessaire d’avoir les sources correspondantes aux
définitions des classes pour les exploiter. Durant la compilation d’un fichier source, les (.class) des
classes utilisées dans ce fichier source sont recherchées dans le répertoire local par le compilateur.
De cette manière le répertoire local constitue un package local. Reprendre le fichier de la manière
suivante, recompiler l’ensemble. Que pouvez vous conclure sur les priorités de recherche à la
compilation entre le package local et les packages externes.
import java.util.*;
class Random {}
public class App {
public static void main(String args[])
{
System.out.println(new Random());
System.out.println(new java.util.Random());
}
}
Droit d’accès
L’introduction de ce TP illustre de quelle manière un package constitue un niveau d’encapsulation
supplémentaire à celui de la classe. En Java, il existe quatre déclarations de droit d’accès
définissables dans une classe pour les données membres et les méthodes : private, pas de
déclaration, protected, et public. Ces déclarations sont utilisées pour définir les accès aux données
membres et aux méthodes entre classes, au sein d’un même package et entre différents packages.
Les déclarations private et pas de déclaration sont utilisées « majoritairement » pour les relations
d’héritage. Les déclarations protected et public sont utilisées majoritairement pour les droits
d’accès aux classes des packages.
On se propose d’illustrer la déclaration public dans un premier temps, reprendre le fichier
(MyClass.java) du package myp de la façon suivante :
package myp;
public class MyClass {
public void print()
{System.out.println("public class, public method");}

3
void print2()
{System.out.println("public class, no public method");}
public void print3()
{print2();new MyClass2().print();}
}
class MyClass2 {
void print()
{System.out.println("no public class, no public
method");}
}
Dans le fichier (App.java) le mettre en oeuvre de la façon suivante. Tenter d’exécuter les lignes en
commentaire, et commenter l’utilisation du mot clé public. D’après vous, quel sens aurait la
déclaration public d’une méthode dans la classe MyClass2 ?
MyClass my = new MyClass();
my.print();
//MyClass2 my2 = new MyClass2();
//my.print2();
my.print3();
Afin d’illustrer l’utilisation de la déclaration protected, rajouter à la définition de la classe
MyClass la donnée membre suivante :
protected int v;
Dans le répertoire (package), définir une classe MyClassE de la façon suivante :
class MyClassE extends MyClass {
MyClassE()
{System.out.println(v);}
}
Mettre en œuvre les classes MyClassE et MyClass de la façon suivante, quelle erreur de
compilation relevez-vous sur l’accès à la donnée membre v de la classe MyClass :
new MyClassE();
MyClass my = new MyClass();
//System.out.println(my.v);
Dans cette partie du TP vous avez illustré l’utilisation des droits d’accès protected et public dans
le cadre de la définition de packages. Dans les TP précédents, vous avez illustré les déclarations
private et sans déclaration dans le cadre des relations d’héritage. Le tableau suivant résume
l’utilisation des droits d’accès en Java.
Déclarations
Accessibilité
private
la classe
sans
la classe et les classes du même package
protected
la classe, les classes du même package, et les classes
dérivées
public
partout
2) Outils SDK
Introduction
La plate forme SDK est basée sur l’utilisation de différents outils standards. Plusieurs outils
existent, parmi eux javac, java, jar, et javadoc sont couramment utilisés. Vous pouvez accéder à la
documentation des outils SDK depuis la page principale J2SDK Documentation
(C:\j2sdk1.4.1_02\docs\index.html), en ouvrant le lien Tool Documentation. Dans cette partie
nous introduisons l’utilisation de ces outils dans un cadre général, et plus particulièrement pour
l’exploitation de package.
javac et java
Sans le savoir, vous avez utilisé à plusieurs reprises ces outils standards SDK lors de la mise en
oeuvre de vos différents programmes Java. En effet, à chaque compilation/exécution de vos
programmes (dans votre environnement de programmation) vous avez fait appel respectivement à
javac et java. Implémenter la classe suivante :
public class App
{
public static void main(String args[])
{ System.out.println("Hello World"); }
}
Ouvrir une fenêtre shell, et exécuter les commandes suivantes :
javac App.java
java App
Dans cet exemple, vous avez directement utilisé les outils javac et java pour la compilation d’un
fichier Java, et l’exécution du fichier (.class) correspondant au « byte code » de ce fichier. Comme
vous pouvez le voir, ces appels sont relativement « simples » lorsqu’ils sont appliqués à un seul

4
fichier. Cependant, l’implémentation de package complique ces appels. Définir la structure de
répertoires et de fichiers suivante :
 tpck [App.java]
o p1 [MyClass1.java]
o p2 [MyClass2.java]
Définir les 3 fichiers Java de la façon suivante :
(App.java) :
package tpck;
import tpck.p1.*;
import tpck.p2.*;
public class App {
public static void main(String args[]) {
new MyClass1().print();
new MyClass2().print();
}
}
(MyClass1.java) :
package tpck.p1;
public class MyClass1 {
public void print() {
System.out.println(toString());
}
}
(MyClass2.java) :
package tpck.p2;
public class MyClass2 {
public void print() {
System.out.println(toString());
}
}
Implémentez le script suivant au niveau du répertoire racine au répertoire tpck, exécutez-le et
commentez le résultat obtenu dans le répertoire class. Détaillez l’action de ce script en vous aidant
de la Tool Documentation de la plate forme J2SDK.
mkdir class
javac -d .\class .\tpck\*.java .\tpck\p1\*.java .\tpck\p2\*.java
Implémentez le script suivant au niveau du répertoire racine au répertoire (tpck), et exécutez-le.
Détailler l’action de ce script en vous aidant de la Tool Documentation de la plate forme J2SDK.
java -cp .\class tpck.App
jar
jar est un outil SDK utilisé pour la création d’archives. Ces archives sont en fait des
concaténations de fichier (.class) et de structures de répertoires associées. Créer un répertoire
(myjar1), dans ce répertoire créer 2 fichiers Java (MyClass1.java) (MyClass2.java) définis de la
façon suivante
MyClass1.java :
class MyClass1 {
void print() {
System.out.println(toString());
}
}
MyClass2.java :
class MyClass2 {
void print() {
System.out.println(toString());
}
}
Dans ce répertoire (myjar1) implémenter et exécuter le script suivant. Détailler l’action de ce
script en vous aidant de la Tool Documentation de la plate forme J2SDK. Utiliser un utilitaire de
compression afin de décompacter l’archive (myjar.jar), commenter le contenu de cette archive.
javac *.java
jar cf myjar.jar *.class
Créer un nouveau répertoire (myjar2), dans ce répertoire implémenter la classe suivante dans un
fichier (App.java).
public class App {

5
public static void main(String args[]) {
new MyClass1().print();
new MyClass2().print();
}
}
Copier dans ce répertoire le fichier (myjar.jar) obtenu précédemment du répertoire (myjar1),
implémenter et exécuter le script suivant. Détaillez l’action de ce script en vous aidant de la Tool
Documentation de la plate forme J2SDK.
javac -classpath .\myjar.jar *.java
java -cp .\;myjar.jar App
Déplacer le fichier (myjar.jar) du répertoire (myjar2) au répertoire (C :\j2sdk1.4.1-02\jre\lib\ext).
Ce répertoire est en fait le répertoire d’extension de la plate forme J2SDK dans lequel il est
possible d’installer toutes librairies externes. Utilisez votre environnement de développement pour
recompiler et exécuter dans le répertoire (myjar2) le fichier (App.java). Vous pouvez également
utiliser le script suivant :
javac App.java
java App
Remarque : Suite à cette manipulation, n’oublier pas de supprimer le fichier (myjar.jar) du
répertoire (C :\j2sdk1.4.1_02\jre\lib\ext).
Au cours des exemples précédents, vous avez vu comment créer avec l’outil SDK jar une archive
simple, et utiliser cette archive dans vos applications Java. L’archive (myjar.jar) créée
précédemment correspond en fait une archive de type « librairie », en effet elle ne contient aucune
classe exécutable. Il est possible de créer avec l’outil SDK jar des archives de type « application »,
pour cela il faut :
1. Intégrer une classe exécutable à l’archive
2. Rédiger un manifeste de l’archive
Créer un répertoire (myjar3), dans ce répertoire copier les fichiers (MyClass1.java)
(MyClass2.java) et (App.java) des répertoires (myjar1) et (myjar2). Dans le répertoire (myjar3),
implémenter un fichier (manifest.mf) de la façon suivante :
Manifest-Version: 1.0
classpath: ./
Main-Class: App
Created-By: 1.3.0 (Sun Microsystems Inc.)
Dans ce répertoire (myjar3) implémenter et exécuter le script suivant. Détaillez l’action de ce
script en vous aidant de la Tool Documentation de la plate forme J2SDK.
mkdir class
javac -d .\class *.java
jar cmf .\manifest.mf myjar.jar -C class\ .
java -jar myjar.jar
Au cours des exemples précédents, vous avez vu comment créer avec l’outil SDK jar des archives
de type « librairie » et « application ». On se propose d’appliquer l’outil SDK jar à la création
d’archive à partir de packages. Créez un répertoire (myjar4), dans ce répertoire copiez votre
package tpck défini précédemment. Egalement, dans ce répertoire (myjar4) implémentez une
fichier (manifest.mf) de la façon suivante :
Manifest-Version: 1.0
classpath: ./
Main-Class: tpck.App
Created-By: 1.3.0 (Sun Microsystems Inc.)
Dans ce répertoire (myjar4) implémenter et exécuter le script suivant. Détaillez l’action de ce
script en vous aidant de la Tool Documentation de la plate forme J2SDK.
mkdir class
javac -d .\class\ .\tpck\*.java .\tpck\p1\*.java .\tpck\p2\*.java
jar cmf .\manifest.mf tpck.jar -C class\ .
java -jar tpck.jar
javadoc
L’outil SDK javadoc permet d’analyser les sources (.java) afin de créer une documentation
automatique. Créer un répertoire (doc1), copier dans ce répertoire les fichiers (MyClass1.java)
(MyClass2.java) et (App.java) du répertoire (myjar3) précédent. Dans ce répertoire (doc1),
implémenter et exécuter le script suivant.
mkdir .\html
javadoc -private -d .\html *.java
Allez consulter le fichier .\html\index.html afin de visualiser la documentation créée. Détaillez
l’action de ce script en vous aidant de la Tool Documentation de la plate forme J2SDK. Re-
exécuter ce script sans l’option private de la commande javadoc, commenter.
Dans ce court exemple, vous avez défini une documentation « vide ». En effet, à aucun moment
vous n’avez commenté vos fichiers sources Java afin de compléter cette documentation. L’outil
SDK javadoc permet d’analyser les commentaires du code si ceux-ci respectent une certaine