1.3 Classes d`objets géométriques

JAVA - TP 1
Exercices d'initiation
1. Exercices sur le langage
1.1 Hello world !
Ecrivez un programme java affichant le message "Hello world !". Modifier ce programme pour
qu'il liste les paramètres de la ligne de commande.
1.2 Hello cyberworld !
Ecrivez une applet java affichant le message "Hello cyberworld !". Pour cela invoquer la
méthode drawString() sur l'objet Graphics recu en parametre dans la méthode paint() de l'applet.
Placez des traces dans les méthodes init(), start(), paint(), stop() et destroy() et
analysez leur invocation.
Modifier l'applet pour quelle affiche un message reçu en parametre.
1.3 Classes d'objets géométriques
On souhaite disposer d'un ensemble de classes permettant de manipuler des objets géométriques
en 2 et 3 dimensions (on ne s'occupe pas de leur représentation graphique).
1.3.1 Architecture des classes
Ecrivez les classes reflétant la structure suivante :
 Shape (*)
 Shape2D (*)
 Rectangle
 Square
 Ellipse
 Circle
 Shape3D (*)
 Sphere

 Cylinder
(*) classe abstraite (non instanciable)
Ces classes doivent permettre de :
identifier les objets lors de leur creation (e.g. : Circle c = new Circle("mon cercle",
2.5))
calculer la surface des objets (methode area())
calculer le perimètre des objets dérivant de Shape2D (methode perimeter())
calculer le volume des objets dérivant de Shape3D (methode volume())
1.3.2 Mise en oeuvre
Ecrivez un petit programme Java mettant en oeuvre ces classes.
1.3.3 Deploiement dans des packages
Deployez ces classes dans les packages :
 shape
 shape.shape2D
 shape.shape3D
1.3.4 Comptabilisation des instances
Ajoutez des variables de classes (count) comptabilisant le nombre d'instances des classes Shape,
Shape2D et Shape3D (prevoir le cas de suppression d'instances).
1.3.5 Génération de la documentation
Insérez des commentaires conformes aux spécifications de l'utilitaire javadoc et générez la
documentation HTML des packages avec cet outil.
2. Exercices sur les API
2.1 Les entrées/sorties
Ecrivez un programme permettant de coder et decoder des données. Ce programme aura l'usage
suivant :
 Aucun argument : lit sur System.in et écrit sur System.out
 1 argument : lit sur le fichier indiqué et écrit sur System.out

 2 arguments : lit sur le fichier indiqué en premier argument et écrit sur le fichier indiqué
en second argument
Le codage sera delocalisé dans la classe Rot13OutputStream qui dérivera de
FilterOutputStream. On choisira un algorithme de chiffrement symétrique et simpliste (e.g.
rot13).
2.2 Les Threads
Pour illustrer les mécanismes de synchronisation entre threads, on se propose de développer une
petite application producteur/consommateur : un thread producer crée des messages (e.g. la date
courante) et les place dans une file d'attente (e.g. un Vector). Un thread consumer retire un
message de la file d'attente et l'affiche. Pour rendre l'application plus réaliste on impose :
 que la file d'attente soit borné. Lorsque la file d'attente est pleine le producteur se met en
attente et lorsqu'elle est vide le consommateur se met en attente.
 que l'on puisse imposer un debit différent au producteur et au consommateur (chaque
thread s'endormira (sleep) entre chaque iteration)
1. Ecrivez les classes Producer et Consumer.
La classe Producer sera de la forme :
public class Producer implements Runnable {
...
/**
* Create a new Producer
*
* @param maxQueueSize the size of the queue
* @param sleepValue the time to sleep between each iteration
*/
public Producer(int maxQueueSize, int sleepValue) {...}
/**
* Start the thread
*/
public void start() {...}
/**
* The thread body
*/
public void run() {
...
while(true) { ...}
...
}
/**
* Put a new message in the queue

*/
public void putMessage() {...}
/**
* Remove and return the first message of the queue
*
* @return the message
*/
public String getMessage() {...}
}
La classe Consumer sera de la forme
public class Consumer implements Runnable {
/**
* Create a new Consumer
*
* @param producer the producer
* @param sleepValue the time to sleep between each iteration
*/
public Consumer(Producer p, int sleepValue) {... }
/**
* Start the thread
*/
public void start() {...}
/**
* The thread body
*/
public void run() {
...
while(true) { ...}
...
}
}
2. Ecrivez une classe Main qui permet de tester ces classes. Par exemple :
public class Main {
public static void main(String[] args) {
Producer p = new Producer(5, 1000);
p.start();
Consumer c = new Consumer(p, 2000);
c.start();
}
}
3. Faites les modifications nécessaires pour que l'on puisse lancer plusieurs consommateurs
simultanément.