CAHIER DE TP

Cours de Programmation Orientée

objets
DUT GI
Deuxième année , Semestre 1
 TP 1 : Prise en Main de l’Environnement Java
Les exercices qui vous sont proposés ici ont pour but de vous faire expérimenter les outils de
base du JDK (Java Development Kit) : compilateur, machine virtuelle, documentation...

pour en savoir plus sur JSE (Java Standard Edition) et le JDK:

http://www.oracle.com/technetwork/java/javase/overview/index.html

Exercice 0 : Préparation du TP
Organiser votre espace de travail

Avant tout chose organisez votre espace disque afin de pouvoir par la suite retrouver
facilement le travail effectué lors des différentes séances de TPs. Pour cela :

1. créez dans votre répertoire TPS un sous répertoire Java dans lequel vous mettrez tous
les TPs concernant cette partie du cours.
2. dans le répertoire Java créez un sous répertoire TP01 dans lequel vous rangerez le
travail effectué au cours ce premier TP.

Vérifier la présence de java sur votre poste de travail

1. ouvrir une fenêtre de commandes

o fenêtre Xterm sous Unix,
o fenêtre d'invite de commandes sous Windows (menu Démarrer->Exécuter-
>cmd) (Attention ! pas command.com qui est du vrai MS-DOS pur jus : pas
de rappel des commandes (doskey), noms limités à 8 caractères...)
2. dans cette fenêtre de commandes taper :
1. java -version la réponse doit être java version "1.8.0" ou un numéro
de version supérieur.
2. javac la réponse doit être Usage: javac <options> <source files> ...

Si vous n'obtenez pas les réponses attendues, il faut installer le JDK et configurer votre
environnement avant de pouvoir travailler :

• Installation sous windows :

o documentation d'installation
o Voir la vidéo : installer JDK 17 sous Windows 10
(https://www.youtube.com/watch?v=SxbWLK7qcpY)
• Installation sous linux ( https://docs.oracle.com/en/java/javase/17/install/installation-
jdk-linux-platforms.html)
• Installation sous MacOS (
https://docs.oracle.com/en/java/javase/17/install/installation-jdk-macos.html#GUID-
2FE451B0-9572-4E38-A1A5-568B77B146DE)
Exercice 1 : consulter la documentation en ligne de Java
SE
Ce premier exercice a pour but de vous faire parcourir la documentation de Java SE
mise en ligne par Oracle afin de vous familiariser avec son organisation. NE LE
NEGLIGEZ PAS ! Pour pouvoir travailler efficacement avec java, il est essentiel
de savoir vous servir de cette documentation et de situer rapidement les éléments qui
pourraient vous être utiles.

Plusieurs versions de Java SE sont disponibles, la dernière en date (au 03/01/2022) étant la
version 17. Lorsque vous utilisez les documentations du JDK, il vaut mieux vous référer à
celle correspondant à la version installée sur votre machine (voir exercice 0) :

• La documentation de Java SE version 8 est disponible à l'URL

http://docs.oracle.com/javase/8
• La documentation de Java SE version 17 est disponible à l'URL
http://docs.oracle.com/javase/17

1.1 Tutoriaux java en ligne

En partant de la page d'accueil de la documentation du JDK retrouvez la page du site officiel

d'Oracle pour les tutoriaux en ligne de Java SE (voir image ci-dessous).

La page des tutoriaux Java (capture du 3/01/2022)

 • Quelle est l'URL de la page d'accueil du Tutorial (pensez à l'enregistrer dans vos
favoris, elle vous sera utile par la suite) ?
• Dans la terminologie du Java Tutorial qu'est-ce qu'un trail
• Sur la page d'accueil du Java Tutorial, combien de trails sont-ils proposés pour couvrir
les bases du langage Java ?
• Que sont les Learning Paths et à quoi servent-il ?
• Quels aspects de la plateforme Java couvrent chacun des 4 learning paths proposés ?

1.2 Documentation de l'API de Java SE (8 et 17)

En partant de la page d'accueil de la documentation JDK 8, retrouvez la page présentant l'API

Java 8 (voir figure ci-dessous).

La page
d'accueil de l'API du JDK 8 (capture du 15/12/2020)

• Quelle est l'URL de cette page ? Pensez à l'enregistrer dans vos favoris, elle vous sera
utile par la suite.
 • Que signifie le terme API ?
• L'API Java est structurée autours de la notion de package. Qu'est-ce qu'un package
Java ?

Retrouvez la documentation de la classe Math de l'API java, classe définie dans le package
java.lang.

La description de la classe Math du package java.lang

• Quel est le rôle de cette classe ?

• Quel est le nom et la signature de la méthode qui permet de transformer une valeur
exprimée en radians en une valeur exprimée en degrés ?
• Retrouvez la documentation du package java.net.
o Que propose ce package ?
o Quel est le nom de la classe de ce package qui permet de représenter sous
forme d'un objet java une adresse IP v6 ?
• Retrouvez la documentation de la classe String.
o A quel package appartient cette classe ?
o A quoi sert cette classe ?
o Que fait la méthode toUpperCase de cette classe ?

En partant de la page d'accueil de la documentation JDK 17, retrouvez la page présentant

l'API Java 17(voir figure ci-dessous).
La page d'accueil de l'API du JDK 17 (capture du 3/01/2022)

• Quelle est l'URL de cette page ? Pensez à l'enregistrer dans vos favoris, elle vous sera
utile par la suite.
• Sur cette page les packages n'apparaissent plus directement. L'API est structurée
autour de la notion de modules. Qu'est-ce qu'un module ?
• Dans quel module se trouve le package java.lang
• En utilisant l'outil Search situé en haut de la page de l'API retrouvez la description de
la classe Frame. A quel package appartient cette classe ?

1.3 Documentation des outils du JDK

En partant de la page d'accueil de la documentation JDK retrouvez la page présentant la

documentation des outils du JDK (pensez à l'enregistrer dans vos favoris, elle vous sera utile
par la suite)

Les pages des outils du JDK 8 et du JDK 17 (capture du 03/01/2022)

 • Parcourez cette documentation pour voir les outils de base du JDK. Pour chacun des
outils suivants indiquez son rôle :
o javac
o java
o javadoc
o javap
o jdb
o jar
• Que signifie l'acronyme jar et qu'est-ce qu'un fichier .jar ?
• Que signifie l'option -showversion de l'interpréteur java ? Quelle est la différence
avec l'option -version ?

Exercice 2 : compiler et exécuter un programme java

Exercice 2.1 : HelloWorldApp

Cet exercice reprend la leçon The "Hello World !" Application du programme
d'apprentissage Getting Started des tutoriaux java d'Oracle.

La leçon "Hello World" (capture du 03/01/2022)

Nous n'allez pas ici, suivre ce tutoriel dans son entier, vous pourrez vous y référer pour les
étapes de compilation et d'exécution si nécessaire.

1. Dans votre répertoire de travail (TPS/Java/TP01) créez un répertoire exercice2.

2. Dans ce répertoire TPS/Java/TP01/exercice2, créez avec n'importe quel éditeur de
texte de votre choix (par exemple gedit sous linux, notepad++ sous windows) un
fichier HelloWorldApp.java dont le contenu est le suivant :
3. /**
4. * The HelloWorldApp class implements an application that
5. * simply prints "Hello World!" to standard output.
6. */
 7. public class HelloWorldApp {
8. public static void main(String[] args) {
9. System.out.println("Hello World!"); // Display the string.
10. }
}

11. Compilation de l'application HelloWorldApp.java.

o Quelle commande utilisez-vous pour compiler le fichier HelloWorldApp.java
?
..........................................................................................
o Quel est le nom du fichier créé par cette commande de compilation ?
...............................................................................................
o Que contient-il ? (Affichez son contenu sur la console, commande type sous
Windows, more ou less sous Unix)
...............................................................................................
o Invoquez la commande javap -c HelloWorldApp. Quel est l'effet de celle-ci
?
...................................................................................................
12. Quelle commande utilisez-vous pour executer l'application HelloWorldApp sur la
machine où vous l'avez compilée ?
................................... .........................................................................
13. Modifiez le programme HelloWorldApp.java que vous avez écrit dans l'exercice 1 de
manière à ce qu'il provoque l'affichage suivant :
14. BONJOUR
15. CECI EST MON
PREMIER PROGRAMME JAVA

ou tout autre texte de votre choix.....

recompilez le et exécutez le.

Exercice 2.2 : Portabilité du code Java

Si les versions de java sont compatibles, un même programme doit pouvoir être exécuté sur
des machines différentes sans nécessiter de recompilation.

Exercice 2.3 : Arguments de la ligne de commandes

1. Copiez dans votre répertoire de travail le programme Hello2.java fournit avec ce TP

2. Compilez ce programme et exécutez le successivement avec les commandes :
o java Hello2
o java Hello2 Marie
o java Hello2 Pierre Paul Jacques
3. Constatez. En observant le source du programme Hello2.java, que pouvez-vous en
déduire sur le rôle du paramètre args de la méthode main ?

.............................................................................................................
.............................................................................................................
Exercice 2.4 : Méthodes dépréciées

1. Créez une classe Java qui contient le programme ci dessous

2. import java.util.Date;
3. public class AfficherHeure {
4.
5. public static void main(String[] args) {
6. Date d = new Date();
7. System.out.print("il est " + d.getHours() + " h ");
8. System.out.print(d.getMinutes()+ " m ");
9. System.out.println(d.getSeconds() + " s");
10. }
}

11. Compilez la classe AfficherHeure. Que constatez-vous ?

D'après vous le bytecode généré (fichier AfficherHeure.class) est-il exécutable ?

Vérifiez.

.......................................................................................................................

12. La compilation de cette classe vous indique que certaines méthodes utilisées par ce
programme sont dépréciées. Présentes dans les premières versions de la plateforme
java, ces méthodes ont depuis été remplacées par de nouvelles méthodes introduites
dans les versions successives de la plate-forme java. Toutefois les messages de
"dépréciation" sont simplement des avertissements (warnings), le code compilé est
exécutable. Ces messages sont là pour signifier au programmeur l'utilisation de
méthodes dépréciées qui peuvent s'avérer dangereuses ou risquent de ne plus être
supportées dans de futures versions de java et qu'il serait préférable de remplacer par
de nouvelles fonctionnalités de la plate-forme java.

Quelle option du compilateur java permet de voir le détail des méthodes dépréciées ?
.......................................................................................................................

13. Recompilez la classe AfficherHeure avec cette option. Quelles sont les méthodes
dépréciées utilisées dans AfficherHeure ? Dans quelle classe sont elles définies ?
Que dit la documentation javadoc à leur sujet ?
.............................................................................................................................
.............................................................................................................................
.............................................................................................................................
.............................................................................................................................
..............................................................................................................................

2.4 : Utilisation de classes d'autres packages

1. Dans le programme précédent (AfficherHeure) commentez la première ligne

2. //import java.util.Date;
3. public class AfficherHeure {
4.
5. public static void main(String[] args) {
6. Date d = new Date();
7. System.out.print("il est " + d.getHours() + " h ");
8. System.out.print(d.getMinutes()+ " m ");
 9. System.out.println(d.getSeconds() + " s");
10. }
}

11. Recompiler cette classe ? Que constatez-vous ?

.............................................................................................................................
.............................................................................................................................
.............................................................................................................................
.............................................................................................................................
..............................................................................................................................

12. Dans l'exercice précédent (2.3) vous avez pu constater que plusieurs des méthodes de
la classe Date sont dépréciées. Pour remédier à ce problème, la javadoc de cette classe
vous recommande d'utiliser un objet Calendar du package java.util.

Pour ne plus avoir de message de dépréciation, modifiez le code de AfficherHeure

en utilisant non plus un objet Date mais un objet GregorianCalendar. Pour cela,
remplacez

Date d = new Date(); par Calendar cal = new GregorianCalendar();

et les messages

d.getHours();, d.getMinutes();, d.getHours();

par cal.get(Calendar.HOUR_OF_DAY);, cal.get(Calendar.MINUTE); et

cal.get(Calendar.SECOND); comme le précise la documentation des méthodes
dépréciées.

Recompiliez. Verifiez qu'il n'y a plus de message de dépréciation et que l'exécution

donne bien le résultat attendu.

Exercice 3 : Compilation, exécution, documentation d'une

application simple
Lorsque l'on développe une application constituée de plusieurs fichiers il est important de
bien organiser ceux-ci sur son espace disque. Ainsi, une organisation classique est de séparer
dans différents répertoires les fichiers selon leur nature. Ainsi pour un projet de
développement en JAVA on pourra choisir l'organisation suivante : dans un répertoire
correspondant au projet définir 3 sous répertoires :

• un répertoire src (sources) contenant les fichiers source des classes JAVA
• un répertoire classes contenant les fichiers compilé (byte-code) des classes JAVA
• un répertoire docs contenant la documentation des différentes classes JAVA

Dans l'exercice qui suit, vous allez expérimenter cette organisation avec une application qui
permet l'animation de visages sur l'écran. Cette application est constituée de 3 classes Java :
 • VisageRond qui décrit des objets modélisant un Visage animé.
• Dessin qui décrit l'objet chargé de la gestion et l'affichage des différents objets
Visages qu'il contient
• AppliVisage1 le programe principal qui crée les Visages, les place dans la zone de
dessin et lance l'animation.

a) compilation de l'application

1. Dans votre répertoire de travil (TPS/Java/TP01) Créez un répertoire Visages avec

trois sous répertoires src , docs et classes
2. Copiez dans le répertoire src les fichiers sources des différentes classes de
l'application : VisageRond.java , Dessin.java et AppliVisage1.java fournis avec ce
TP.

Le répertoire Visages et ses sous répertoires.

3. Placez-vous dans le répertoire src (commande cd) et compilez l'application

AppliVisage1 en utilisant la commande
javac -d ../classes AppliVisage1.java
o Quel est le rôle de l'option -d utilisée dans la commande javac ?
......................................................................................................
o Quel aurait été l'effet de la commande javac AppliVisage1.java ?
......................................................................................................
o Quels ont été les fichiers créés par la commande de compilation de la classe
AppliVisage1 ?
......................................................................................................
o Qu'en déduisez-vous ?
.......................................................................................................
.......................................................................................................
.......................................................................................................

b) exécution de l'application

1. Placez-vous dans le répertoire classes (commande cd) et exécutez l'application

AppliVisage1. Pour arrêter l'application, cliquez dans la case de fermeture de la
fenêtre de l'application ou tappez CTRL C sur la ligne de commandes.
o Quelle est la commande utilisée pour lancer cette exécution ?
.............................................................
2. Placez-vous maintenant dans le répertoire Visages et retapez la commande utilisée
précédemment pour l'exécution de l'application AppliVisage1.
o Quel message est affiché ?
.....................................................................
o Que signifie-t'il ?
.....................................................................
3. L'option -classpath (ou -cp) de la commande java permet d'indiquer à l'interpréteur
Java où trouver les classes à charger.
o En utilisant cette option quelle est la commande à utiliser pour lancer
l'application depuis le répertoire Visages ?
.....................................................................................................

pour en savoir plus sur le class path

o
sous windows
(https://docs.oracle.com/javase/8/docs/technotes/tools/windows/classpath.html)
o sous unix
(https://docs.oracle.com/javase/8/docs/technotes/tools/unix/classpath.html)
4. Déplacez le fichier AppliVisage1.class du répertoire classes vers le répertoire
Visages.

Le répertoire Visages et ses sous répertoires après le

déplacement de AppliVisage1.class.

o Toujours en restant positionné dans le répertoire Visages essayez d'éxecuter

l'application AppliVisage1 par la commande java AppliVisage1.

Que constatez-vous ?
..........................................................................................................

Quelle explication pouvez-vous donner ?

............................................................................................................

o Essayez ensuite d'éxecuter l'application AppliVisage1 par la commande

utilisée à la question 3 de cet exercice. Que constatez-vous à nouveau ? Qu'en
déduisez-vous ?
.............................................................................................................
o Quelle valeur faut-il donner à l'option -classpath pour pouvoir lancer
correctement l'exécution depuis le répertoire Visages (avec dans ce repertoire
le fichier AppliVisage1.class, et les fichiers Dessin.class et VisageRond.class
situés dans le répertoire classes) ?
.......................................................................................
c) construction et utilisation de fichiers jar

1. Replacez-vous dans le répertoire classes. Normalement si vous avez respecté les

étapes précédentes, ce répertoire ne doit contenir plus que les fichiers Dessin.class et
VisageRond.class , fichiers contenant le byte-code des classes Dessin et VisageRond.
2. Construisez dans le répertoire classes un fichier JAR (Java Archive) de nom
visages.jar contenant ces deux fichiers.
o Quelle est la commande à utiliser ?
.............................................................................................
o Si vous ne l'avez pas fait, ajoutez l'option v à la commande utilisée ? Quel est
son rôle ?
............................................................................................

pour en savoir plus sur la commande jar

o sous windows
o ( https://docs.oracle.com/javase/8/docs/technotes/tools/windows/jar.html)
o sous unix (https://docs.oracle.com/javase/8/docs/technotes/tools/unix/jar.html)
3. Que fait la commande jar tvf appliquée au fichier jar que vous venez de créer ?
.....................................................................................................
4. Déplacez le fichier jar dans le répertoire Visages.
5. Replacez-vous dans le répertoire Visages et lancez à nouveau l'exécution en utilisant
ce fichier jar dans l'option -classpath de la commande java.
o Quelle est la commande à utiliser pour lancer cette exécution ?
..............................................................................................
6. D'après vous quel est l'interêt des fichiers jars ? (Des éléments de réponse sont dans la
documentation de la commande jar)
..........................................................................................................................
..........................................................................................................................
..........................................................................................................................

d) génération automatique de la documentation

Pour comprendre le fonctionnement et le rôle des différentes classes de l'application Visages

vous allez générer la documentation de celles-ci à l'aide de l'outil javadoc.

1. Si il n'existe pas encore, créez un répertoire docs dans le répertoire Visages

2. Placez vous dans le répertoire src et lancez la commande javadoc -d ../docs *.java.
o Quels fichiers cette commande a-t-elle créés (et où se trouvent-ils) ?
............................................................................................
............................................................................................
3. Le point d'entrée de la documentation générée est le fichier index.html.
o Ouvrez ce fichier depuis votre navigateur et parcourez cette documentation.
o La documentation de la classe VisageRond référence une image
figurevisage.gif fourni avec ce TP. Pour que la documentation soit complète
recopiez cette image dans le répertoire docs.
o En comparant la documentation générée et le strong source des différents
classes Java, pouvez-vous déduire quels ont été les élements des fichiers
sources ayant permis de produire cette documentation ?
 ............................................................................................
............................................................................................
4. Les méthodes setDy et getDy de la classe VisageRond ne sont pas documentées.
o Modifiez le source de la classe VisageRond afin de documenter ces méthodes.
o Regénérez la documentation.
o Vérifiez que vos modifications ont correctement été prises en compte.

pour en savoir plus sur la commande javadoc

• sous windows
(https://docs.oracle.com/javase/8/docs/technotes/tools/windows/javadoc.html)
• sous unix (https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html)

e) Modification d'une classe de l'application

1. Modifiez le source de classe VisageRond afin que la taille par défaut d'un visage soit
de 100x100 pixels au lieu de 50x50 pixels
2. Recompilez cette classe (en prenant bien soin de placer le fichier bytestrong dans le
répertoire classes).
o Quelle commande avez-vous utilisée ?
................................................................................
o Quelles ont été les classes recompilées ?
................................................................................
3. Vérifiez que votre modification fonctionne en réexécutant l'application AppliVisage1.
o Quelle commande avez-vous utilisée pour cette exécution ?
.......................................................................................

f) Erreurs de compilation

1. Sauvegardez dans le répertoire src le fichier : AppliVisage2.java

2. Placez-vous dans le répertoire src et compilez AppliVisage2 avec la commande
javac -classpath ../classes -d ../classes AppliVisage2.java.
o Quels sont les erreurs de compilation et les corrections que vous proposez ?
.........................................................................................................
.........................................................................................................
.........................................................................................................
.........................................................................................................
.........................................................................................................
.........................................................................................................
3. Après avoir effectué ces modifications, recompilez et exécutez l'application
AppliVisage2.

g) Erreurs d'exécution

1. Sauvegardez dans le répertoire src le fichier : AppliVisage3.java

2. Placez vous dans le répertoire src et compilez AppliVisage3 avec la commande
javac -classpath ../classes -d ../classes AppliVisage3.java
3. Exécutez l'application AppliVisage3.
o Que se passe-til ?
..........................................................................................
4. A l'aide du message d'erreur produit, localisez et corrigez l'erreur. Quelle correction
avez-vous effectuée ?
.....................................................................................................................
.....................................................................................................................
.....................................................................................................................
5. Recompilez et réexécutez cette application.
 TP2 : Types simples et instructions de bases Java

Objectifs: Le but de ce TP est de vous faire expérimenter les constructions de base du langage
JAVA (types simples, instructions de contrôle, itérations) qui sont très proches syntaxiquement
de celles utilisées par le langage C. Les programmes que vous aurez à écrire ne feront donc que
très peu appel aux notions d'objets et classes, mais avant d'expérimenter celles-ci, il paraît
préférable de vous assurer que vous maîtrisez correctement ces constructions élémentaires. De
plus, cela vous permettra de parfaire votre maitrise des outils de base (compilateur javac,
interpréteur java) du JDK vus lors du TP1.

Ressource utiles

• Les types simples (entiers, réels, ...) et les instructions de base du langage JAVA:
o les slides de présentation du cours.
• Pour effectuer des lectures au clavier:
o utilisez la classe Scanner (javadoc : JDK 17 ou bien JDK 8) du package standard
java.util (dans le module java.base pour versions du JDK supérieures à 9). Dans
le fichier ScannerDemo.java fourni avec ce TP vous trouverez un exemple
d'utilisation de cette classe pour lire des données au clavier.

Les exercices proposés dans ce TP sont indépendants et sont organisés par thème
(expressions, instructions conditionnelles, itérations. Les thèmes sont présentés selon un
ordre de difficulté croissant.

Chaque thème comporte plusieurs exercices. Traitez ces thèmes selon leur ordre de présentation
en effectuant au moins un des exercices proposés. Lorsque vous aurez abordé tous les thèmes,
vous pourrez revenir en arrière pour réaliser les exercices que vous n'avez pas encore traités.

Rappel: tout programme source JAVA doit avoir comme suffixe .java. La version compilée
d'un programme JAVA a le même nom que le programme source correspondant mais son
suffixe est .class.

Par exemple le programme source MonTP2.java, se compilera en un fichier bytecode

MonTP2.class (obtenu par la commande javac MonTP2.java) , et sera exécuté par la
commande java MonTP2.

Style de codage: Adopter un style de codage uniforme et cohérent est un principe de base dans
l'activité de programmation : cela facilite la lecture et la compréhension du code.

La communauté des développeurs Java a l'habitude de respecter un certain nombre de règles de

base, parmi lesquelles:

1. Les noms de classes sont définis par un identificateur débutant par une majuscule.
2. Les noms de variables locales sont définis par un identificateur débutant par une
minuscule.
3. Les programmes doivent être correctement indentés.
Prenez dès maintenant de bonnes habitudes de codage Java. Il vous est demandé de respecter
impérativement les 3 règles ci-dessus.

Pour en savoir plus sur les bonnes pratiques, vous pouvez vous référer au document de Google:
Google Java Style (https://google.github.io/styleguide/javaguide.html)

Exercice 0 : Organiser votre espace de travail

Avant tout chose organisez votre espace disque afin de pouvoir par la suite retrouver facilement
le travail effectué lors de cette séance de TP. Pour cela, dans le répertoire TPS/Java créé lors
du TP1, ajoutez un sous répertoire TP02 dans lequel vous rangerez le travail effectué au cours
ce second TP.

Thème 1 : Expressions
Exercice 1 : Conversion de températures

En utilisant la formule \(tempC = (5/9)(tempF-32)\) écrire en langage JAVA un programme

Degres.java qui lit une température exprimée en degrés Fahrenheit et affiche sa valeur en
degrés centigrades ou degrés Celsius.

exemples d'exécution du programme :

C:\JAVA\TP2>java Degres
donnez une temperature en Fahrenheit : O.O
cette temperature equivaut a -17.8 degres Celsius
C:\JAVA\TP2>java Degres
donnez une temperature en Fahrenheit : 60.0
cette temperature equivaut a 15.6 degre Celsius
C:\JAVA\TP2>

Exercice 2 : Conversion de durées

Ecrire un programme Hjms.java en langage JAVA qui pour un nombre de secondes donné
calcule et affiche son équivalent en nombre de jours, d'heures, de minutes et de secondes.

exemples d'exécution du programme :

C:\JAVA\TP2>java Hjms
donnez une durée en secondes : 3621
cette durée équivaut à 0 jours 1 heures 0 minutes 21 secondes
C:\JAVA\TP2>java Hjms
donnez une durée en secondes : 567231
cette durée équivaut à 6 jours 13 heures 33 minutes et 51 secondes
C:\JAVA\TP2>
Thème 2 : Instructions conditionnelles
Exercice 1 : Déterminer de l'appartenance d'un point à une couronne

Ecrire un programme Couronne.java en langage JAVA qui pour un pour un point P du plan
détermine si ce point se trouve ou non à l'intérieur de la couronne de centre l'origine et définie
par la donnée de son rayon extérieur rext et son rayon intérieur rint

C:\JAVA\TP2>java Couronne
rayon extérieur : 14
rayon intérieur : 10
donnez un point
x : 12
y : 0
ce point est dans la couronne
C:\JAVA\TP2>

Exercice 2 : Classer 3 nombres

Ecrire un programme TroisNombres.java qui lit 3 nombres au clavier, les classes dans l'ordre
croissant et les affiche du plus petit au plus grand sur la console.

C:\JAVA\TP2>java TroisNombres
1er nombre : 14
2ème nombre : 10
3ème nombre : 17
les nombres dans l'ordre croissant : 10 14 17
C:\JAVA\TP2>

Thème 3 : itérations
Exercice 1 : Moyenne olympique

Ecrire un programme qui lit au clavier une suite de nombres réels positifs ou nuls
(correspondant à des notes), terminée par la valeur -1, et calcule la moyenne olympique de ces
valeurs, c'est à dire la moyenne des notes sans prendre en compte la note la plus élevée ni la
note la moins élevée.

Exemple de trace d'exécution (en vert les valeurs introduites par l'utilisateur):

C:\JAVA\TP3java>MoyenneOlympique
donnez une note ( >=0 ou -1 pour arrêter): 9.6
donnez une note ( >=0 ou -1 pour arrêter): 9.7
donnez une note ( >=0 ou -1 pour arrêter): 10.0
donnez une note ( >=0 ou -1 pour arrêter): 9.8
donnez une note ( >=0 ou -1 pour arrêter): 9.2
donnez une note ( >=0 ou -1 pour arrêter): 9.9
donnez une note ( >=0 ou -1 pour arrêter): -1

La note la plus élevée (10.0)et la note plus basse (9.2) ont été retirées
La moyenne olympique est : 9.75
C:\JAVA\TP3>

Exercice 2 : Affichage de motifs - escaliers

Ecrire un programme affiche un motif triangulaire dont la taille est fixée par une valeur lue au
clavier.

Exemple de trace d'exécution (en vert les valeurs introduites par l'utilisateur):

C:\JAVA\TP3>java Triangle1
donnez taille du motif : 7
*
**
***
****
*****
******
*******
C:\JAVA\TP3>

a) écrire un programme Triangle1.java affichant ce motif en utilisant uniquement des

instructions tant que (while()).

b) écrire un programme Triangle2.java affichant ce motif en utilisant uniquement des

instructions pour (for).
Exercice 3 : Affichage de motifs - pyramides

Même exercice que le précédent mais le motif affiché n'est plus un triangle mais une pyramide
(voir ci-dessous) et le choix des instructions pour le réaliser est laissé à votre jugement.

Exemple de trace d'exécution (en vert les valeurs introduites par l'utilisateur):

C:\JAVA\TP3>java Pyramide
donnez taille du motif : 7
*
***
*****
*******
*********
***********
*************
C:\JAVA\TP3>

Exercice 4 : Suite de Fibonacci

La suite de Fibonacci est définie par la formule de récurrence suivante: u0 = 0 u1 = 1

un = un-1 + un-2 (n >= 3).

a) Ecrire un programme Fibo1.java qui permet de calculer le nième terme de la suite de

Fibonacci, n étant fixé par l'utilisateur.

b) Ecrire un programme Fibo2.java qui permet d'obtenir la valeur et le rang du premier terme
de cette suite supérieure à une valeur donnée par l'utilisateur.

Exercice 5 : Tester si un nombre est premier

Un nombre est n premier si il a seulement deux diviseurs : 1 et n.

Ecrire un programme Premier.java qui permet de tester si un nombre introduit par l'utilisateur
est premier ou non.

Exemple de trace d'exécution (en vert les valeurs introduites par l'utilisateur):

C:\JAVA\TP2>java Premier
donnez un entier positif : 7
7 est un nombre premier

Voulez-vous essayer un autre nombre O/N ? o

donnez un entier positif : 25

25 n'est pas un nombre premier, il est divisible par 5

Voulez-vous essayer un autre nombre O/N ? n

Au revoir
C:\JAVA\TP2>
Exercice 6 : Prix d'un lot

a) Le jeu consiste à découvrir par essais successifs le prix d'un lot . Pour chaque essai, le joueur
reçoit un message : "Trop grand", "Trop petit" ou "BRAVO ! Vous avez trouvé en K essais".
Le jeu est fini quand le joueur a trouvé le prix du lot.

On propose d'écrire un programme JAVA PrixLot1.java qui joue le rôle de meneur de jeu ;
l'exécution de ce programme vous fera tenir le rôle du joueur. Le programme Prixlot1doit
définir le prix du lot en tirant un entier aléatoire entre 1 et 1000 et dialoguer avec le joueur
pendant le jeu.

Pour choisir un nombre au hasard on utilisera la méthode random de la classe Math qui retourne
un réel (double) tiré au hasard et de manière uniforme dans l'intervalle [0 1].

exemple :

double x; x = Math.random();

exemple d'exécution du programme PrixLot1

C:\JAVA\TP3>java PrixLot1
Le but est de chercher un prix entre 0 et 1000
Tapez un prix : 566
Trop grand
Tapez un prix : 400
Trop grand
Tapez un prix : 150
Trop petit
Tapez un prix : 200
Trop petit
Tapez un prix : 214
BRAVO ! Vous avez gagné en 5 essais
C:\JAVA\TP3>

b) Copier dans le fichier PrixLot2.java le fichier PrixLot1.java, et modifier

PrixLot2.java de manière à pouvoir :

• enchaîner plusieurs jeux consécutifs lors d'une même exécution du programme (à la fin
de chaque jeu, il est demandé au joueur de préciser s'il veut s'arrêter ou rejouer)
• limiter le nombre d'essais du joueur lors d'une partie (au début de chaque partie, le
programme demandera le nombre maximum d'essais autorisés).

Exemple d'exécution du porgramme PrixLot2

C:\JAVA\TP3>java PrixLot2
Le but est de chercher un prix entre 0 et 1000
1ère partie. Nombre maximum d'essais : 4
Tapez un prix : 678
Trop petit
Tapez un prix : 920
Trop grand
Tapez un prix : 860
Trop petit
Tapez un prix : 910
Trop petit
PERDU ! Vous avez épuisé le nombre d'essais autorisés
Le prix était : 917

Voulez-vous rejouer O/N ? o

2ème partie. Nombre maximm d'essais : 8
Tapez un prix : 678
Trop grand
Tapez un prix : 333
Trop grand
Tapez un prix : 300
Trop petit
Tapez un prix : 320
Trop petit
Tapez un prix : 324
BRAVO !
Vous avez gagné en 5 essais

Voulez-vous rejouer O/N ? n

C:\JAVA\TP3>

c) En jouant avec le programme précédent, essayer de trouver une stratégie systématique et

efficace. Ecrire un programme PrixLot3.java qui fait jouer l'ordinateur à votre place suivant
la tactique que vous venez de définir ; les deux rôles de meneur de jeu et de joueur sont donc à
la charge du programme, le joueur "ignorant" évidemment le prix connu du meneur de jeu, mais
"sachant" si son essai est plus grand ou plus petit que le prix.

Le programme PrixLot3 effectue 20 parties ; il affiche pour chaque partie le prix tiré au sort
et le nombre d'essais successifs qui ont été nécessaires pour le trouver avec la tactique
programmée.

Pouvez-vous prévoir, pour la tactique que vous avez choisie, l'ordre de grandeur des nombres
d'essais ? Compléter le programme PrixLot3 en lui faisant calculer la moyenne des 20 nombres
d'essais obtenus pour les 20 parties.

Exercice 7 : Calcul de xn

a) Ecrire un programme JAVA Puissance1.java permettant de calculer et d'afficher la valeur

de xn, où x et n sont respectivement un réel et un entier introduits au clavier.

Pour effectuer ce calcul on ne fera pas appel aux méthodes de la classe Math (pow ou exp et
log), mais on utilisera des instructions itératives (for, while ou do while). Le programme
devra permettre de traiter tous les cas possibles : n = 0, n > 0 et n < 0 avec X réel négatif, positif
ou nul. Rappelons que :

• X0 = 1 pour X > 0,
• 00 = 1 par convention,
• X0 n'est pas défini pour X < 0,
• 0n = 0 pour n > 0,
• 0n n'est pas défini pour n < 0.

On pourra organiser le calcul de la façon suivante :

b) à partir du programme Puissance1.java précédent écrire un programme Puissance2.java
qui après chaque calcul de puissance demande à l'utilisateur si il veut faire un autre calcul ou
non.

exemple d'exécution :

C:\JAVA\TP2>java Puissance2
x = 2.0
n = 3.0
xn = 8.0
voulez-vous faire un autre calcul O/N : o
x = 3.5
n = -3
xn = 0.0233236151
voulez-vous faire un autre calcul O/N : n
C:\JAVA\TP2>

Exercice 8 : Valeur approchée de la racine carrée d'un nombre réel positif

On considère un nombre réel positif A ; on sait que la suite (un) n=0,1,2,... définie par la donnée
d'un réel u0 positif et par la relation de récurrence un = (un-1 + A / un-1) * 0,5 (pour n > 0)
converge vers la racine carrée de A . On suppose le nombre A compris entre 1 et 100, et on
prend u0 = A / 2.

Pour obtenir une valeur approchée de racine carrée de A, on cherche le premier terme un tel que
| un2 - A | < E-5 . Le nombre trouvé est une valeur approchée de racine carrée de A ( en effet |
un2 - A | < E-5 implique que | un- rac(A) | < E-5 / ( un+ rac(A) où rac(A) correspond à la racine
carrée de A).

a) Ecrire un programme JAVA Raca1.java qui permet

1. de lire le nombre A,
2. de calculer et d'afficher les approximations intermédiaires et la valeur approchée de la
racine carrée de A définie ci-dessus.

Exemple de l'état de l'écran obtenu par exécution du programme Raca1 :

Entrer un nombre A entre 1 et 100: 19.23

Approximations successives :
u0 = 9.615
u1 = 5.8075
u2 = 4.559367735686612
u3 = 4.388528900180239
u4 = 4.385203650605606
Valeur approchée de la racine carrée = 4.385202389856321
Indications pour écrire le programme :

• définir une constante : static final double EPS = 1E-5;

• utiliser une boucle tant que :
• while (. . . . . . . >= EPS) {
}
b) à partir du programme Raca1.java écrire un programme Raca2.java qui vérifie que le
nombre introduit au clavier est bien un nombre positif supérieur à 1, et dans le cas contraire
affiche un message d'erreur et redemande une nouvelle valeur à l'utilisateur.

Thème 4 : instanciation d'objets - envois de messages

1. En vous inspirant de l'application AppliVisage1 vue lors du TP n°1, écrivez une
seconde application permettant d'animer simultanément deux visages. Le premier ayant
le même mouvement que celui défini dans l'application Applivisage1, le deuxième
partant du centre de l'écran, ayant une taille différente du premier et se déplaçant sur la
seconde diagonale de la fenêtre.

2. Ecrivez une troisième application donnant aux visages qui se déplacent dans la fenêtre
graphique une trajectoire moins répétitive. Au lieu de se déplacer uniquement selon une
diagonale, les visages se déplacent selon les quatre directions Nord-Ouest -> Sud-Est,
Sud-Ouest -> Nord-Est, Sud-Est -> Nord-Ouest et Nord-Est -> Sud-Ouest. La direction
du déplacement d'un visage sera modifiée à chaque rencontre de ce dernier avec un
bord de la fenêtre. Si vous avez le temps vous pouvez aussi animer les visages en les
dotant d'un changement d'expression à chaque changement de direction.
 TP3: Tutoriel d'initiation à l'utilisation de Visual Studio Code
pour développer en Java
Ce document présente le minimum vital pour une utilisation de VSCode pour le développement
Java. Les captures d'écran ont été réalisées sous Windows 10 avec la version 1.63.2 de Viusal
Studio Code et la JDK 17.1.0 d'Oracle .

Avant de commencer, organisez votre espace disque afin de pouvoir par la suite retrouver
facilement le travail effectué lors de cette séance de TP. Pour cela, dans le répertoire TPS/Java
créé lors du TP1, ajoutez un sous répertoire TP03 dans lequel vous rangerez le travail effectué
au cours ce TP.

1. Configuration de VSCode
Avant toute chose, il faut au préalable que vous ayez installé un JDK 11 ou + sur votre
ordinateur. Il vous faut ensuite ajouter à VSCode les extensions qui vous permettront de
travailler avec le langage Java. L'Extension Pack for Java regroupe les extensions de base les
plus populaires qui vous aideront à développer en Java sous VSCode.

La page WEB de l'Extension Pack for Java

https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-pack

Les extensions vous offriront entre autres :

• un support pour l'édition du code Java (auto complétion, navigation, refacoring, code
snippets...)
• un support pour l'exécution et le débogage du code Java
• Un support pour la gestion de projets Java (gestions de librairies et dépendances, des
classes et packages ...)
• ...

2. Création d'un projet Java avec VSCode

Notion de projet Java

Un projet Java est un ensemble de fichiers source Java et des informations associées (classpath,
comment construire et exécuter le projet, etc...), la manière dont ces fichiers sont organisés
dépend à la fois de la nature du projet (Application Java standard, Application web, Application
JEE...) et de l'outil de construction de projet (Build Tool) choisi. VSCode offre plusieurs
possibilités pour l'outil de construction de projets :

• Projets sans outils de construction autres que les outils du JDK.

• Apache Maven
• Spring boot
• ...

Dans cette introduction à Java sous VSCode nous ne nous intéresserons dans un premier temps
qu'aux projets sans outils de construction.

Etapes de création d'un projet

La figure ci-dessous vous montre les différentes étapes pour créer un nouveau projet
d'application Java

Etapes de création d'un projet Java sans outils de construction (build tool)

1. Sélectionnez l'explorateur (Explorer) de VSCode

2. Sélectionnez le bouton Create Java Project
3. Dans la liste de sélection du type de projet choisissez le premier item No build tools
4. Sélectionnez le répertoire où vous voulez stocker les fichiers de votre projet
5. Donnez un nom à votre projet, par exemple HelloJava

Dommage votre navigateur ne supporte pas les vidéos HTML5. Vidéo : Création d'un projet
Java

Structure du projet
VSCode crée sur votre disque dur, dans le dossier choisi à l'étape 4, un nouveau dossier dont
le nom est celui que vous avez fourni à l'étape 5 (HelloJava). La figure ci-dessous vous
montre la structure du projet ainsi créé.

La structure du projet HelloJava Dommage votre navigateur ne supporte pas les vidéos
HTML5. Vidéo : Exploration de la structure d'un projet Java

3. Compiler et exécuter le projet

Dans VSCode, la compilation s'effectue de manière automatique. Dès que vous ouvrez un
fichier dans l'éditeur et dès que vous le sauvegardez, celui-ci est compilé, et le byte code
correspondant (fichier .class) est rangé dans le répertoire bin.

La vidéo ci-dessous, illustre ce fonctionnement automatique de la compilation.

Dommage votre navigateur ne supporte pas les vidéos HTML5. Compilation automatique du
code Java

Pour exécuter l'application, là aussi c'est très simple. Deux possibilités vous sont offertes :

a. soit en cliquant sur le texte Run situé dans l'éditeur juste au dessus de la méthode main
b. soit en cliquant sur le bouton situé en haut à droite de l'éditeur.

Lancement de l'exécution du projet HelloJava

Une fois l'exécution lancée, VSCode ouvre automatiquement un terminal dans lequel il exécute
la commande java avec les options adéquates pour exécuter le code de la classe App.java. La
figure ci-dessous vous montre le déroulement de cette exécution.
Déroulement de l'exécution du projet HelloJava

4. Utilisation de l'éditeur
Vous allez maintenant modifier le code de la class App pour voir rapidement quelques unes des
possibilités de l'éditeur Java de VSCode.

Pour commencer, à la fin de la méthode main, rajoutez l'instruction

System.out.println("Bye Bye World !");

Lorsqu'il le peut, l'éditeur vous propose une complétion automatique du code. Par exemple
arrêtez la frappe après avoir tapé Sys, l'éditeur vous propose un certain nombre de complétion
possibles avec la documentation javadoc associée.

Complétion automatique du code dans l'éditeur

L'éditeur offre la completion de code pour toutes les classes et méthodes situées dans le
classpath de compilation du projet. La vidéo ci-dessous vous montre certaines des possibilités
offerte par l'autocomplétion

Dommage votre navigateur ne supporte pas les vidéos HTML5. Autocomplétion du code Java

L'éditeur n'attend pas toujours qu'une compilation ait été lancée pour vous signaler d'éventuelles
erreurs. Au fur et à mesure que vous tapez votre texte, la syntaxe java est vérifiée et en cas
d'erreur un ~ rouge est affiché sous le texte où l'erreur a été détectée. En positionnant le curseur
de la souris sur celui-ci vous aurez un message d'explication indiquant la nature de l'erreur. Pour
apprécier cette fonctionnalité supprimez le ; à la fin de l'instruction System.out.println("Bye
Bye World !").

Détection d'erreurs dans l'éditeur

La vidéo ci-dessous vous montre plus en détail comment les erreurs détectées sont matérialisées
dans l'éditeur de VSCode.

Dommage votre navigateur ne supporte pas les vidéos HTML5. Matérialisation des erreurs dans
le code Java

Modifiez maintenant le code de votre classe App afin que le programme lise un nombre entier
au clavier et affiche autant de fois les messages Hello World ! et Bye Bye World ! Votre code
doit être le suivant :

import java.util.Scanner;

public class App {

public static void main(String[] args) throws Exception {
Scanner sc = new Scanner(System.in);
System.out.print("nombre d'itérations : ");
int nb = sc.nextInt();
for (int i = 0; i < nb; i++) {
System.out.println("Hello, World!");
System.out.println("Bye Bye World ! ");
}
}
}

La classe Scanner est une classe du package java.util, pour pouvoir l'utiliser dans votre code
il est nécessaire d'effectuer un import au début du programme. Normalement lorsque vous avez
déclaré la variable sc cet import a été effectué automatiquement. Si vous supprimer cet import,
une erreur apparaît dans votre code. En plus de signaler l'erreur, l'éditeur peut vous proposer
des actions pour la corriger (fixer) automatiquement. Ceci est matérialisé par une qui apparaît
sur la ligne où est placé le curseur.

Suggestion de correction des erreurs dans le code Java

La vidéo ci-dessous vous montre plus en détail ces possibilités de correction du code.

Dommage votre navigateur ne supporte pas les vidéos HTML5. Source Action pour corriger les
erreurs

Interrompre l'exécution d'un programme

Fermez le projet HelloJava (item Close Folder du menu File)
Suggestion de correction des erreurs dans le code Java

puis créez dans votre dossier TPS/Java/TP03 un nouveau projet VisagesRond.

Recopiez dans le répertoire src de ce nouveau projet les sources des classes de l'application
AppliVisage vue lors du TP n° 1 :

• AppliVisage1.java
• VisageRond.java
• Dessin.java

Compilez et exécutez AppliVisage1. Le programme principal (méthode main) d'AppliVisage1

est constitué d'une boucle infinie qui à chaque itération effectue un déplacement élémentaire du
visage, efface la zone de dessin et réaffiche l'image. Lorsqu'il est lancé depuis une console, ce
programme peut être arrêté en tapant CTRL + C. Un autre manière d'arrêter l'exécution est
d'utiliser le bouton qui apparaît sur la droite de la console (terminal) ayant lancé le processus
d'exécution de l'application.
Lancement et interruption de l'application AppliVisage1

La vidéo ci-dessous montre la réalisation de cet exercice.

Dommage votre navigateur ne supporte pas les vidéos HTML5. Lancement puis interruption
de l'application AppliVisage1

6. Générer la documentation Javadoc d'un projet

Les extensions fournies par le Java Extension Pack ne proposent pas de fonctionnalité pour
générer la Javadoc à partir des commentaires dans le code source des classes. Il existe d'autres
extensions disponible sur le MarketPlace de VSCode, mais celles que j'ai testées se sont révélée
peu convaincantes (faible communauté d'utilisateurs, documentation succinte, bugs...), il vaut
donc mieux directement utiliser l'outil Javadoc depuis la ligne de commande comme vous le
montre la vidéo ci-dessous

Dommage votre navigateur ne supporte pas les vidéos HTML5. Générer la javadoc

7. Utiliser le debugger de VSCode

Fermez le projet VisageRond et créez un nouveau projet d'application Java,
MoyenneOlympique. Utilisez la classe MoyenneOlympique.java(fourni avec ce TP) qui
calcule la moyenne olympique d'une série de notes et recopiez la dans le répertoire src de ce
projet (vous pouvez au passage supprimer la classe App.java qui a été générée lors de la
construction du projet, elle ne vous sera pas utile).
Lancez l'exécution de ce programme. Il a été conçu pour calculer la moyenne d'une série de
notes en retirant la note la plus élevée et la note la plus faible. Trois notes au moins doivent être
saisies. Cependant bug s'est glissé dans ce programme, alors que la saisie de trois notes devrait
suffire, le programme impose un minimum de 4 notes.

Erreur d'exécution du programme Moyenne Olympique

Pour comprendre l'origine de cette erreur vous allez utiliser le debugger de Java intégré à
VSCode qui vous permettra de positionner des points d'arrêt, d'effectuer une exécution pas à
pas et d'observer l'état des variables.

1. Placez un point d'arrêt à la ligne 75 du programme (la boucle while du programme du

programme principal). Pour cela cliquez à gauche du numéro de la ligne concernée
dans la fenêtre d'édition.
Une fois ce point d'arrêt fixé il apparait sous la forme d'un cercle rouge au début de la
ligne. Pour supprimer ce point d'arrêt il suffit de cliquer sur ce cercle.

2. Lancez ensuite une exécution sous le contrôle du debugger. Pour cela deux possibilités
: a) cliquez sur Debug au dessus de la méthode main ou bien b) cliquez sur le bouton
 situé en haut à droite de l'éditeur. et sélectionnez

3. Dans la console de débogage, saisissez la première note. Après cette lecture

l'exécution s'interrompt sur le point d'arrêt fixé précédemment. Votre espace de travail
est alors organisé de la manière suivante.

4. L'exécution est interrompue à la ligne 75 (qui n'a pas encore été exécutée). Pour faire
avancer l'exécution pas à pas cliquez sur le bouton Step Over de la barre d'outils du
debugger.
Répétez cette opération plusieurs fois et observez l'état des variables du programme.
5. Lorsque vous arrivez à la ligne 84 (appel de lireUneNote dans la boucle while) de la
méthode main, faites avancez l'exécution en rentrant dans la méthode lireUneNote.
 Pour cela cliquez sur le bouton Step Into .

6. Continuez à avancer pas à pas (bouton Step Over) jusqu'à ce que vous ayez lu une
seconde note et que l'exécution soit arrêtée sur la ligne 53.

7. Placez un second point d'arrêt sur cette ligne, puis poursuivez l'exécution jusqu'au
prochain point d'arrêt (le premier point d'arrêt que vous aviez défini ligne 75). Pour
aller directement jusqu'à ce point d'arrêt cliquez sur le bouton Continue.
8. Poursuivez l'exécution sous le contrôle du debugger jusqu'à ce que vous ayez identifié
la cause de l'erreur. Interrompez alors l'exécution du debugger en cliquant sur le
bouton Stop.
9. Corrigez le bug, et vérifiez que le programme s'exécute correctement et peut être
arrêté une fois trois notes saisies.

7. La documentation en ligne de VSCode

Dans ce qui précède, nous avons vu le strict minimum pour l'utilisation de VSCode pour
l'écriture d'applications Java. Pour profiter aux mieux des très riches fonctionnalités de cet
environnement, nous vous conseillons de parcourir la documentation en ligne et en particulier
les tutoriaux suivants :

• Getting Started with Java in VS Code

• (https://code.visualstudio.com/docs/java/java-tutorial)
• Navigate and edit Java source code
• (https://code.visualstudio.com/docs/java/java-tutorial)
• Running and debugging Java
• (https://code.visualstudio.com/docs/java/java-debugging)
 TP4: Introduction aux objets : une classe simple les nombres
rationnels
Un nombre rationnel est un nombre qui peut être défini par un ratio n/d, où n, appelé
numérateur, est un entier relatif, et d, appelé dénominateur, est un entier relatif non nul. Nous
allons dans ce TP construire une classe représentant les nombres rationnels.

Avant tout chose organisez votre espace disque afin de pouvoir par la suite retrouver facilement
le travail effectué lors de cette séance de TP. Pour cela, dans le répertoire TPS/Java créé lors
du TP1, ajoutez un sous répertoire TP05 dans lequel vous rangerez le travail effectué au cours
ce TP.

Première version d’une classe Rational

Commençons doucement en créant une première version très simple d'une classe Rational qui
représente un nombre rationnel.

1. Créez une classe Rational, possédant deux attributs entiers num et denom

• . (Reportez vous au TP03 pour voir comment créer un projet Java et une classe avec l'IDE
VSCode).
• Écrivez un programme de test qui crée une fraction 3/2

2. , affiche son numérateur, et affiche son dénominateur (dans la console).

3. Compilez et exécutez ce programme pour vérifier que votre classe Rational fonctionne
correctement.

Représentation textuelle d’un rationnel

1. Modifiez votre classe Rational afin d’y ajouter une méthode toString() sans
paramètre, et renvoyant une chaîne de caractères (type String) représentant le nombre
rationnel (par exemple, cette méthode, appelée sur le rationnel 3/2

1. , devrait renvoyer la chaîne de caractères "3 / 2").

2. Modifiez votre programme de test pour utiliser la méthode toString() créée
précédemment. Compilez et exécutez.

Exceptions
1. Modifiez votre programme de test pour créer un autre rationnel de dénominateur égal à
0. Est-ce possible ? Si oui, en quoi est-ce un problème ?
2. Pour empêcher la création et la manipulation d’objets rationnels ayant pour
dénominateur 0. Vous ajouterez au constructeur de votre classe Rational un test qui au
cas où le dénominateur serait nul exécute l'instruction suivante :

throw new IllegalArgumentException("Dénominateur nul");

 Modifiez votre programme de test pour créer un rationnel avec un dénominateur nul,
que ce passe-t-il ? D'après vous quel est le rôle et l'effet de l'instruction précédente ?

Opérations arithmétiques
Pour rappel (au cas où...), la multiplication de deux rationnels est définie de la manière suivante:

nd×n′d′=nn′dd′
1. Ajoutez à votre classe Rational une méthode mult prenant en paramètre un autre
rationnel, et le multipliant au rationnel sur lequel elle est appliquée. La méthode ne
renvoie rien (type de retour void).

Cette opération modifie l’état de l’objet sur lequel la méthode est invoquée : a.mult(b)
revient à faire a←a∗b

. Il n’est pas possible en Java de redéfinir des opérateurs (comme en C++), sinon ce serait
équivalent à a∗=b

• Modifiez votre programme de test en créant un second rationnel (1/3 par exemple), en le
multipliant au premier, et en affichant le résultat. Compilez et exécutez.

• Mêmes questions pour l’addition. Pour rappel, l’addition de deux rationnels est définie de
la manière suivante :

nd +n′d′=nd′+n′ddd′

Fractions irréductibles
En plus d’interdire la création et la manipulation de rationnels dont le dénominateur est à 0,
nous souhaitons que tout rationnel soit toujours sous sa forme irréductible. Il s’agit d’un
invariant de classe : à tout instant, et ce dès sa création, un objet Rational est toujours sous
forme irréductible.

Pour rappel, un rationnel n/d est sous forme irréductible si et seulement si pgcd(n,d)=1,
avec :

fonction pgcd(a,b)
si b est égal à 0
renvoyer a
sinon
renvoyer pgcd(b, reste(a,b))

Par exemple, la forme irréductible du rationnel 8/12 est 2/3 avec :

1. Modifiez votre classe Rational en conséquence. Testez.

2. Ecrivez une fonction qui teste l'égalité de deux nombres rationnels. Testez.
 TP5 de Programmation Orientée Objet
Introduction à l'héritage et Tableaux
Objectifs : il s’agit de faire vos premiers pas avec l’Héritage ainsi que d’expérimenter avec
les tableaux en Java.

Animation d’une "chenille"

Sur le modèle de l’application AppliVisages vue lors du TP n°1, il s’agit de réaliser une
application permettant d’animer une ou plusieurs "chenilles" se déplaçant dans une fenêtre sur
l'écran, chaque chenille se déplaçant de manière aléatoire et "rebondissant" sur les bords de la
fenêtre.

1. Représentation d’une chenille

Une chenille est constituée d’une tête suivie d’une suite d’anneaux (figure 1).

- figure 1 : représentation d’une chenille composée de 7 anneaux -

• Un anneau est représenté par un cercle de rayon R ( on propose : R = 5).

• La tête de la chenille est représentée par un disque noir de rayon identique au rayon
des anneaux.
• Le corps de la chenille est constitué de N anneaux, numérotés de 0 à N-1 ; l'anneau n°
0 est celui qui suit la tête et l'anneau n° N-1 est celui de queue.
• Le centre de l'anneau n° i est situé sur la circonférence de l'anneau n° i-1 ( i = 1, 2, ... ,
N), le premier anneau (anneau n° 0) étant situé sur la circonférence de la tête.
• Le cap de la chenille indique la direction dans laquelle se déplace la tête de la chenille.
C'est l'angle entre l'axe Ox et le vecteur indiquant la direction de déplacement de la
tête.

2 - Animation d’une chenille

2.1 Création d’une chenille

A l'instant initial,
la chenille est
parallèle à l'axe
Ox, orientée vers
la droite, et située
au milieu de la
fenêtre de dessin
(figure 2).

le repère associé à
une fenêtre de
dessin a son
origine dans le
coin supérieur
gauche de la
fenêtre. Les
points-écran
(pixels) à
l’intérieur d’une
fenêtre sont à
coordonnées figure 2 : Position initiale d’une chenille dans une fenêtre de largeur xMax et hauteur
entières. La taille yMax.
d’une fenêtre
indique la taille de
la zône
d’affichage, elle
ne tient pas
compte du cadre
qui entoure celle-
ci.

2.2 Avancée d’une chenille

A chaque étape de l'animation le déplacement de

la chenille s'effectue de la manière suivante :

si la chenille est sur un bord de la fenêtre (c'est-à-dire si la

distance du centre de la tête
au bord de la fenêtre est inférieure ou égale au rayon
de la tête) alors
la chenille effectue une déviation de cap de +90°
sinon
la chenille effectue une déviation de cap d’un
angle tiré au hasard
dans l’intervalle [-30° +30°]
finsi

les anneaux de la chenille se décalent d'une position :

- l'anneau n° i prend la position de l'anneau n° i-1 (i =
N-1, N-2, ... ,1)
- l'anneau n° 0 prend la position de la tête
la tête se déplace d'une distance R selon la direction définie
par le nouveau cap

figure 3 : Déplacement d’une chenille (en italique les éléments de la chenille à l’instant t,
en normal les éléments de la chenille à l’instant t+1)

3 Modélisation JAVA d’une Chenille

Pour modéliser une chenille en langage JAVA on décide de définir trois classes d’objets :

• une classe Anneau qui décrit les objets représentant chaque anneau de la chenille.
• une classe Tête qui décrit l’objet représentant la tête de la chenille. La tête peut être
vue comme un cas particulier d’anneau. La classe Tête sera donc définie en héritant
de la classe Anneau (autrement dit la classe Tête sera une sous-classe de la classe
Anneau).
• une classe Chenille qui décrit un objet modélisant une chenille dans son ensemble
et donc qui utilisera les services des classes Tête et Anneau.

3.1 La classe Anneau

Un Anneau est un objet défini par trois attributs (les coordonnées x,y du centre du cercle le
représentant et le rayon r de ce cercle) et capable de se placer à une position donnée, de
s’afficher. La spécification du constructeur et des méthodes de la classe Anneau vous est
donnée ci-dessous.

/**
* crée un Anneau en fixant sa position initiale et son rayon
* @param xInit abscisse du centre de l’anneau
* @param yInit ordonnée du centre de l’anneau
* @param r rayon de l’anneau
*/
public Anneau(int xInit, int yInit, int r)
/**
* retourne abscisse du centre de l’anneau
* @return abscisse du centre de l’anneau
*/
public int getX()
/**
* retourne ordonnée du centre de l’anneau
* @return ordonnée du centre de l’anneau
*/
public int getY()
/** positionne le centre de l’anneau en un point donné
* @param px abscisse du point
* @param py ordonnée du point
*/
public void placerA(int px, int py)
/**
* affiche l’anneau en le matérialisant par un cercle noir
* @param g objet de classe Graphics qui prend en charge la gestion
* de l’affichage dans la fenêtre de dessin
*/
public void dessiner(Graphics g)

Pour dessiner un cercle on utilisera le méthode drawOvalde la classe

java.awt.Graphics , méthode définie comme suit :

public abstract void drawOval(int x, int y, int width, int height)

Draws the outline of an oval. The result is a circle or ellipse that fits within the rectangle
specified by the x, y, width, and height arguments. The oval covers an area that is width +
1 pixels wide and height + 1 pixels tall.

Parameters:
x - the x coordinate of the upper left corner of the oval to be drawn.
y - the y coordinate of the upper left corner of the oval to be drawn.
width - the width of the oval to be drawn.
height - the height of the oval to be drawn.

3.2 La classe Tête

La classe Tête est définie comme une sous-classe de la classe Anneau. En effet comme un
anneau, une tête est définie par trois attributs (les coordonnées de son centre et son rayon) et
est capable de se placer à une position donnée, de s’afficher et de s’effacer. Les différences
sont les suivantes :

La classe Tête enrichit la classe Anneau d’un nouvel attribut : cap un réel (double) qui
définit la direction de déplacement de la tête.

La position, le rayon et le cap initial d’une tête sont fixés à sa création (donnés en paramètre
du constructeur).

La méthode dessiner est redéfinie de manière ne plus afficher un cercle (noir ou blanc)
selon le cas mais un disque (cercle plein) (utiliser la méthode fillOval de
java.awt.Graphics en lieu et place de drawOval).

De plus trois nouvelles méthodes sont ajoutées :

• une méthode devierCap(double deltaC) qui permet de modifier le cap de la

tête en lui ajoutant la déviation définie par le paramètre deltaC.
• une méthode atteintBord(int xMax, int yMAX) qui retourne un booléen
dont la valeur est vrai (true) si le centre de la tête est à une distance <= R de l’un des
bords de la fenêtre de taille xMax, yMax et faux (false) sinon.
• une méthode deplacerSelonCap() qui modifie le centre de la tête en lui
appliquant un déplacement de longueur R dans la direction définie par le cap. Pour
 cela, on calcule la nouvelle position du centre de la tête à l’aide de la formule
suivante :

x’ = x + R * cos(cap) et y’ = y + R * sin(cap)

3.3 La classe Chenille

La classe Chenille définit quatre attributs pour une chenille (sa tête, la liste de ses anneaux
stockée dans un tableau, la taille en x et en y de la fenêtre dans laquelle la chenille est
dessinée). Elle possède un constructeur permettant à partir d’une taille de fenêtre donnée en
paramètre de créer une chenille en position initiale (horizontale avec le centre de la tête placé
au centre de la fenêtre). Elle possède également 2 méthodes publiques: une pour dessiner la
chenille, l’autre pour faire effectuer à la chenille un déplacement élémentaire selon
l’algorithme donné au § 2.2.

4. Travail à effectuer

Avant toute chose, créez un répertoire (td3 ou chenille, à votre choix) dans lequel vous
vous placerez pour réaliser cette application.

1. Ecrire le code des classes Anneau, Tete et Chenille.

2. Modifier l’application AppliVisage1 de manière à ce que au lieu d’animer un
VisageRond , celle-ci anime votre Chenille.
1. Pour cela recopiez dans votre répertoire de travail les classes
AppliVisage1.java et Dessin.java vues lors du Td n°1,
2. Modifiez les en conséquence (Chenille remplace VisageRond).
3. Une fois que votre application fonctionne avec une Chenille, modifiez-la de manière à
animer deux, voire trois, chenilles.

Pour ceux à qui il reste du temps ou qui veulent en faire plus :

a) Modifier l'application permettant d'animer plusieurs chenilles de manière à ce que le

nombre de chenille puisse être fixé comme argument lors du lancement du programme
(argument de la ligne de comandes).

indications :

• pour convertir l'argument fourni sur la ligne de commande on pourra utiliser la

méthode statique parseInt de la classe Integer (package java.lang).
int nbChen = Integer.parseInt(args[0]);
• utiliser un tableau pour stocker les références des Chenilles

b) Imaginez de nouveaux types de chenilles. Par exemple des chenilles colorées, des chenilles
mutantes dont le nombre d’anneaux varie au cours de leur existence (par exemple ajout d’un
anneau lorsque l’un des bords est atteint, sauf dans le cas où il s’agit du bord supérieur de la
fenêtre, dans ce dernier cas la chenille perd un anneau).
Ecrire les classes représentant ce (ces) nouveau(x) type(s) de chenille et modifiez
l’application de sorte à ce que plusieurs chenilles d’espèces différentes soient animées
simultanément.

c) Déposez dans la zone de dessin des " salades " matérialisées par des disques verts.
Programmez une nouvelle espèce de chenilles, les chenilles gourmandes, dont la taille
(diamètre des anneaux) croit chaque fois qu’elles " mangent " une salade (c’est à dire chaque
fois que la tête de la chenille passe sur une salade). Bien sûr, pour ne pas faire éclater les
chenilles on prendra soin de retirer les salades au fur et à mesure que les chenilles les
dévorent.

Modifiez les classes existantes et écrivez les nouvelles classes nécessaires pour cette
application.
 TP6 de Programmation Orientée Objet – JAVA
Objectifs : Il s'agit de se familiariser avec les notions d'héritage, de réutilisation et
d'abstraction et de polymorphisme et à leur réalisation dans le langage JAVA.

Exercice 1
Il s'agit d'écrire en JAVA une application de jeu. Ce jeu consiste à déplacer un curseur (à
l'aide de la souris, par exemple) et à détruire des cibles qui apparaissent dans une fenêtre sur
l'écran.

Le repère associé à une fenêtre a son origine dans le coin supérieur gauche, l'axe des y est
orienté vers le bas (repère indirect). La figure qui suit montre par exemple une fenêtre de jeu
de taille 800x600 pixels (points).

Dans cet exercice, on ne s'intéressera qu'à la programmation des cibles. On supposera donc
que la fenêtre de jeu est représentée par un objet de classe FenêtreDeJeu qui propose deux
méthodes :

• public int getLargeur() qui retourne la largeur (en nombre de pixels) de la

fenêtre.
• public int getHauteur() qui retourne la hauteur (en nombre de pixels) de la
fenêtre.

Un cible est définie par une position (couple de coordonnées entières) et une forme, qui peut
être soit un cercle soit un carré. Si la cible est circulaire sa position donne le centre du cercle
la matérialisant, si la cible est carrée sa position indique les coordonnées de son coin supérieur
gauche.
L'utilisateur peut déplacer le curseur de tir. Lorsque le curseur se trouve à l'intérieur d'une
cible (carré ou cercle) et que l'utilisateur enclenche le tir la cible est atteinte. Le comportement
d'une cible lorsqu'elle est atteinte varie selon la nature de la cible.

Pour représenter les différents types de cibles les classes suivantes sont définies :

La classe Cible

La classe Cible définit ce qui est commun à toutes les cibles :

Les informations (attributs ou variables d'instance) associées à une cible sont :

• la position du centre de la cible définie par un couple (x,y) de coordonnées entières.

• une référence fenetre de type FenêtreDeJeu , référence vers l'objet représentant la
fenêtre dans laquelle la cible est affichée.

La position initiale est fixée lors de la création d'une cible (les valeurs de l'abscisse et de
l'ordonnée de la position sont passées en paramètre du constructeur de la classe Cible ainsi
que la référence de l'objet FenêtreDeJeu dans lequel le jeu se déroule).

Les opérations (méthodes) définies pour une cible sont :

• public boolean contient(int x, int y)

qui permet de tester si un point (le curseur) est à l'intérieur de la cible. Cette méthode
prend en paramètres un couple x, y de coordonnées entières et retourne une valeur
booléenne (true si le point (x,y) est à l'intérieur de la cible, false sinon).

• deux méthodes public int getCx(), public int getCy()qui retournent

respectivement l'abscisse, l'ordonnée de la cible.
• public void choc()

c'est la méthode qui est appelée lorsque la cible est effectivement atteinte. Son action
dépend bien sur du type de la cible.
La classe CibleCirculaire

La classe CibleCirculaire définit comme son nom l'indique des cibles de forme circulaire.
Lorsqu'elles sont atteintes par un tir du joueur, les cibles circulaires ont le comportement
suivant (comportement implémenté dans la méthode choc()) :
la cible voit son rayon diminuer d'une unité (un pixel). Lorsque ce rayon devient nul, la cible
est repositionnée de façon aléatoire dans la fenêtre de jeu et le rayon reprend sa valeur initiale
(valeur qu'avait le rayon de la cible avant d'être atteinte pour la première fois et fixée lors à la
création de la cible).

La classe CibleCirculaireMobile

La classe CibleMobileCirculaire est une sous-classe de la classe CibleCirculaire. Cette

classe va permettre la gestion d'un nouveau type de cibles : les cibles mobiles. Ces cibles ont
un mouvement de translation horizontal et se déplacent d'un bord à l'autre de la fenêtre
(lorsque la cible rencontre un des bords de la fenêtre, elle "rebondit" et son déplacement se
fait alors dans le sens opposé).

La classe CibleCirculaireMobile enrichit la classe CibleCirculaire d'une nouvelle

variable d'instance :

• un entier dx, qui désigne de combien de pixels la cible doit être déplacée lors de
l'appel de la méthode deplacer (voir ci-dessous). Cette variable d'instance est fixée
lors de la création de la cible (donnée en paramètre du constructeur).

D'autre part, une nouvelle méthode est associée à ce type de cibles :

• public void deplacer()

lors de l'appel à cette méthode, la cible est déplacée de dx pixels suivant l'axe des
abscisses (on peut remarquer que si dx>0, la cible se déplace vers la droite et que si
dx<0, la cible se déplace vers la gauche). Lorsque la cible rencontre un des bords
verticaux de la fenêtre, elle rebondit et son déplacement se fait alors en sens inverse.
Enfin, les cibles circulaires mobiles ont un comportement particulier lorsqu'elles sont atteintes
par le tir du joueur (méthode choc()). En effet, non seulement leur rayon diminue d'une unité
(avec les mêmes conséquences que pour les cibles fixes de type Cible si le rayon devient
nul), mais en plus, leur sens de déplacement s'inverse (comme lorsqu'elles rencontrent un des
bords verticaux de la fenêtre).

Question 1) Donner une description synthétique des différentes classes nécessaires à la

représentation des cibles. Cette description sera fournie sous forme de diagramme de classes
en notation UML.

Question 2) Ecrire le code JAVA de la classe Cible. Définir ses variables d'instance
(attributs), écrire son constructeur et ses différentes méthodes.

Question 3) Ecrire le code JAVA de la classe CibleCirculaire. Définir ses variables

d'instance (attributs), écrire son constructeur et ses différentes méthodes.
(Lors d'un choc, pour calculer la nouvelle position de la cible on fera appel à la fonction
random() de la classe Math (Math.random() retourne un double tiré au hasard dans
l'intervalle [0..1]).

Question 4) Ecrire le code JAVA de la classe CibleCirculaireMobile. Définir ses variables

d'instance (attributs), écrire son constructeur et ses différentes méthodes.
Question 5) Dans le fragment de code suivant, indiquer pour chaque instruction si celle-ci est
valide ou non (c.a.d. si s'elle sera acceptée ou non par le compilateur JAVA) en justifiant
chacune de vos réponses.

CibleCirculaireMobile c1 = new CibleCirculaire(125,340,20,laFenetre);

Cible c2 = new CibleCirculaireMobile(100,100,10,-3,laFenetre);
if (c2.contient(105,107))
c2.choc();
c2.deplacer();

On supposera que laFenetre est une variable qui contient une référence valide vers un objet
de classe FenetreDeJeu.
Les paramètres 125,340,20 pour la CibleCirculaireMobile sont respectivement l'abscisse
et l'ordonnée de sa position initiale et son rayon initial.
Les paramètres 100,100,10,-3 pour la CibleCirculaireMobile sont respectivement
l'abscisse et l'ordonnée de sa position initiale, son rayon initial et la valeur de son déplacement
élémentaire.

Question 6) Le programme principal de l'application est donné par l'algorithme suivant :

Creer la Fenetre de jeu

Créer un EC ensemble de cibles dans cette fenêtre
(les cibles sont générées de manière alétoire)
tantque la partie n'est pas finie faire
dessiner les cibles

récuperer la position x,y du curseur du joueur

pour chaque cible dans EC
si la cible contient le curseur
appliquer à la cible le "traitement de choc"
si la cible est une cible mobile
deplacer la cible
fintantque

Ecrire les instructions Java correspondant aux parties de l'algorithme ci-dessus écrites en gras,
sachant que pour gérer l'ensemble de cibles on décide d'utiliser un objet de la classe
ArrayList définie dans java.util. Cette classe, dont voici un extrait de la
documentation, se comporte comme un tableau dynamique. Elle permet de permet de
construire dynamiquement une liste d'objets, chaque objet présent dans la liste pouvant être
accédé directement par un index (0 pour le premier élément de la liste, 1 pour le deuxième,
etc....). Contrairement aux tableaux il n'est pas nécessaire de spécifier la taille d'un ArrayList,
de plus celle-ci croit dynamiquement au fur et à mesure que la liste des éléments qu'il contient
augmente.

Constructor Summary
ArrayList()
Constructs an empty list.
...
ArrayList(int initialCapacity)
Constructs an empty list with the specified initial capacity.
Method Summary
void add(int index, Object element)
Inserts the specified element at the specified position in this list.
boolean add(Object o)
Appends the specified element to the end of this list.
... ...
Object get(int index)
Returns the element at the specified position in this list.
... ...
int size()
Returns the number of elements in this list.
... ...

Exercice 2 , Expérimentation sur machine :

Dans le TP précédent, vous avez été amenés à modifier la classe Dessin afin de pouvoir
afficher non plus des VisagesRond, mais des Chenilles. Maintenant que vous
connaissez le concept de classes abstraites et d'interfaces, comment procéderiez-vous pour
que l'application puisse animer simultanément des VisagesRond et des Chenilles ?
Donner un diagramme de classe représentant les différentes classes de votre application et
leurs relations.

Modifiez l'application d'animation afin d'afficher indifféremment dans la même fenêtre des
chenilles et des visages créés de manière aléatoire. Créez ensuite une nouvelle classe d'objets
animables en procédant de manière à ne pas avoir à modifier le code de la classe Dessin.