ENIB Java
CPO Année 2018-2019
Labo n◦2
Entrées Sorties, Javadoc, Exploration des APIs
A l’issue de ce laboratoire vous devriez être capable de :
— utiliser javadoc pour générer la documentation de votre code ;
— utiliser les entrées sorties, les exceptions ;
— vous y retrouver dans la bibliothèque java ;
— écrire une application graphique très simple.
Aujourd’hui il vous sera demandé de travailler en autonomie à l’aide de la documentation de Java,
à la fois pour comprendre le code proposé et pour en définir de nouveau. https://docs.oracle.
com/en/java/javase/11/
Vous pouvez trouver la documentation en ligne des API ici :
https://docs.oracle.com/en/java/javase/11/docs/api/index.html
La documentation de l’outil de génération automatique de documentation est disponible ici :
https://docs.oracle.com/en/java/javase/11/javadoc/javadoc.html#GUID-7A344353-3BBF-45C4-8B28-15
Première partie Exceptions et entrées sorties, Flots
Exercice 1 (Entrées - Sorties). Soit le programme suivant, qu’on vous demande de comprendre :
import java.io.*;
public class Console {
public static void printString(String myStr) {
System.out.println(myStr);
}
public static String readString() throws IOException {
String myStr = null;
BufferedReader inputStream = new BufferedReader(new InputStreamReader(System.in));
myStr = inputStream.readLine();
return myStr;
}
public static void printInt(int myInt) {
System.out.println(myInt);
}
public static int readInt() throws IOException, NumberFormatException {
int n = Integer.parseInt(readString());
return n;
}
}
1. Ecrire dans une classe séparée un programme principal permettant de tester ces méthodes.
2. Ecrire les commentaires au format javadoc et générer la documentation de la classe. Utiliser
les tags prédéfinis @author @return, @param et @throws qui décrit l’exception levée par une
méthode.
3. Définir deux nouvelles classes d’exceptions, ReadStringException et ReadIntException qui
étendent la classe Exception, et modifiez les méthodes readString et readInt afin de les
utiliser. Le message de ces exceptions doit décrire la raison pour laquelle la méthode échoue.
1
Deuxième partie
Paint it Black
L’objectif de cet exercice est de commencer à se familiariser avec la réalisation d’interfaces gra-
phiques en Java, et d’utiliser un nouveau design-pattern appelé Observateur. Rassurez vous, il n’est
pas très difficile à comprendre. Le principe est le suivant : plusieurs objets veulent pouvoir être
prévenus à chaque fois qu’un autre objet est modifié. On dit alors que les premiers objets observent
le dernier. Ici, on va définir une une classe principale Battements, dont un des composants est un
timer qui se déclenche périodiquement. On va également définir plusieurs objets graphiques qui
veulent être prévenus de chaque déclenchement du timer pour effectuer des modifications de leur
affichage.
La principale difficulté est de s’y retrouver dans la documentation. Dès que vous serez familiarisés
ça ira mieux.
Exercice 2 (JFrame). package paintitblack;
import java.awt.BorderLayout;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JPanel;
public class Battements extends JFrame {
public Battements() {
super("Battements");
}
public void initializeBattements(){
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
JComponent newContentPane = new JPanel(new BorderLayout());
setContentPane(newContentPane);
pack();
setResizable(true);
}
public static void main(String[] args) {
Battements fenetre = new Battements();
fenetre.initializeBattements();
fenetre.setVisible(true);
}
}
Exécutez ce code. La première ligne du constructeur appelle la création d’une fenêtre (la superclasse
JFrame). La deuxième crée un Panel, qui nous servira a placer des composants graphiques (des
boutons, des zones de texte, des zones de dessin, d’autres panels...) dans les exercices suivants. Lors
de la création de ce panel, on a utilisé un Layout, qui défnit la manière dont les composants seront
disposés dans le Panel. Regardez dans la documentation la signification des autres instructions.
Dans la suite, on va ajouter des composants à cette application. Il serait plus propre de placer le
programme principal dans une autre classe, vous pouvez le faire.
Exercice 3. Ajout d’un Timer
Un timer permet de définir une méthode qui se déclenchera périodiquement. Vous utiliserez dans
ce TD la classe javax.swing.Timer. Ouvrez la documentation et lisez le descriptif de cette classe.
— Vous aurez besoin de définir également un objet de type TimerTask, essayez d’utiliser une
classe anonyme.
— Ajoutez un timer à la classe Battements qui se déclenchera régulièrement (par exemple
toutes les secondes)
2
Exercice 4. Ajout d’un texte sous forme de label : JLabel
1. Créez une classe NombreBattements qui étend la classe JLabel (est-il encore besoin de répéter
qu’il faut ouvrir la documentation de cette classe ?).
2. Cette classe a un attribut entier qui représente le nombre de battements. Il doit être initialisé
à 0 dans le constructeur. Le texte du JLabel est "Nombre de battements : 0".
3. Dans le constructeur de Battements, créez un objet NombreBattements (enregistrez le
comme attribut de la classe) et ajoutez le au panel principal newContentPane en le plaçant
au sud, en utilisant la méthode add du panel avec BorderLayout.SOUTH.newContentPane.
4. Testez votre programme.
Exercice 5. Premier Observateur
1. Définissez une interface Observateur qui déclare la méthode : public void notifie() ;
2. Modifiez votre classe NombreBattements pour qu’elle implémente cette interface. La mé-
thode notifie devra incrémenter le nombre des battements et réactualiser le texte (méthode
setText).
3. Modifiez la classe Battements. La méthode déclenchée par le timer doit appeler la méthode
notifie de l’objet NombreBattements. Testez votre programme.
Exercice 6. Un nouvel observateur
1. Créez une classe Beat qui étend la classe javax.swing.JPanel et qui implémente l’observateur.
2. Cette classe a un attribut de type java.awt.Color initialise dans le constructeur à Color.black.
3. Modifiez la classe Battements. Ajoutez ce composant au centre du panel principal. item Il
faut, pour qu’on puisse voir apparaître ce composant dans la fenêtre, spécifier quelle taille il
veut occuper. Redéfinissez pour cela la méthode Dimension getPreferredSize() (en consultant
bien évidemment la documentation...). Testez avant et après pour voir la différence (l’oubli
de cette méthode est une erreur courante).
4. Redéfinissez la méthode paint(Graphics g) du composant : elle doit peindre tout le composant
de la couleur de l’attribut. La méthode pour choisir une couleur se trouve dans la classe
Graphics, qui représente le contexte graphique du composant. La méthode pour colorier
un rectangle s’y trouve aussi. Pour être s^rr de remplir tout le composant, même s’il est
redimensionné, vous aurez besoin de ses méthodes int getWidth() et int getHeight(). Testez.
5. Modifiez votre classe de façon à ce qu’elle implémente l’interface Observateur. La méthode
notifie doit modifier la couleur en la faisant passer de noir à rouge puis de rouge à noir. Elle
doit aussi provoquer la repeinte du composant. Attention : Il ne faut pas appeler directement
la méthode paint() de la classe Graphics ! Utilisez la méthode repaint() !
6. Evidemment, il faut aussi modifier la classe Battements pour qu’elle notifie notre nouvel
observateur...
