Deug TI 2ème année - IUP1 Méca,
GC, GSI et MIAGE
TP de programmation n° 4
Notions de base de la programmation Objet
L'objectif de ce TP est de mettre en oeuvre les techniques et les concepts
élémentaires relatifs à la programmation orientée
objet. Le travail demandé consiste à construire une mini
application logicielle de dessin et de manipulation d'objets graphiques
vectoriels, en respectant les étapes méthodologiques suivantes
:
-
Lecture du "cahier des charges" et analyse détaillée des
besoins auxquels doit répondre l'application. Cette très
importante phase de travail doit aboutir à une spécification
la plus précise possible de ce que doit faire le programme
à réaliser. C'est notamment ici qu'il faudra déterminer
quelles sont les interactions qui auront lieu entre l'utilisateur et le
logiciel, en effectuant certains choix qu'il faudra ensuite respecter.
C'est aussi dans cette phase qu'il faudra choisir et définir les
"objets" significatifs pour l'utilisateur, à savoir ici les types
d'objets géométriques et les manipulations qui leur sont
applicables.
-
Conception du logiciel. Cette phase consiste à définir comment
vont être réalisées les fonctions du logiciel qui
ont été préalablement spécifiées dans
la phase 1. Il s'agit essentiellement, dans le cas de cette application,
de concevoir :
-
les classes qui permettront d'implanter dans l'application les objets définis
dans la phase 1 d'analyse,
-
les opérations permettant de saisir les commandes exprimées
par l'utilisateur au moyen du clavier du terminal,
-
les opérations permettant d'exécuter les commandes de l'utilisateur,
en modifiant en conséquence les objets graphiques affichés
sur l'écran.
-
Codage des classes Java. Les constructions syntaxiques et sémantiques
de Java déjà vues en TD seront ici utilisées pour
traduire en classes compilables et exécutables le schéma
de conception élaboré en phase 2.
Travail demandé
Cahier des charges
On se propose de réaliser une application de dessin et manipulation
d'objets graphiques simples. Le programme doit afficher des objets représentant
chacun un visage stylisé composé à partir de formes
géometriques élémentaires telles que segments, cercles,
etc... Le programme doit pouvoir ensuite animer ces visages (par exemple
deplacer, grossir, faire changer d'expression un visage...).
Dans sa première version, compte tenu du peu de temps disponible,
le logiciel se limitera à l'affichage et l'animation de deux visages
de même type (classe). Il devra toutefois pouvoir être facilement
étendu pour prendre en compte un nombre plus important de visages
de types différents. Ceci suppose donc une spécification
et une conception soignées des composants dont il sera constitué.
Contraintes de réalisation
Le tracé d'objets graphiques ne peut pas etre effectué directement
dans la fenetre principale de l'application. Cette dernière n'est
qu'un conteneur dans lequel sera inséré un objet intermédiaire
autorisant le tracé d'objets graphiques élémentaires.
Cet objet sera, dans le cadre de ce TP, un objet créé à
partir de la classe Dessin qui vous sera fournie:
class Dessin
{
...
public void ajouterObjet(FormeGeometrique objet)
...
}
L'objet de type Dessin sera créé puis inséré
dans la fenêtre de l'application de la façon suivante :
...
Frame fenetre = new Frame("Titre de l'application");
Dessin dessin = new Dessin();
fenetre.add(dessin);
...
Afin qu'ils soient effectivement tracés à l'écran,
les objets géométriques créés par l'application
devront être ensuite incorporés à cet objet de type
Dessin :
...
VisageRond unVisage = new VisageRond();
dessin.ajouterObjet(unVisage);
...
Chaque fois fois qu'un visage sera modifié, la mise à jour
de la fenêtre pour la prise en compte de cette modification sur l'écran
se fera en invoquant la méthode repaint(long delai)de l'objet
dessin. Cette méthode permet de réafficher l'image
au bout d'un delai de delai millisecondes. Par exemple :
unVisage.sourire(); // modification de l'expression
du visage
dessin.repaint(1000); // mise à jour de l`image sur
l'ecran au bout d'une seconde
-
Afin de permettre à l'objet dessin de prendre en charge
automatiquement l'affichage des visages, les classes représentant
les différents types de visages créés et manipulés
par le logiciel seront d'un type particulier : elle devront comporter dans
leur déclaration la clause obligatoire implements FormeGeometrique
et nécessairement definir une méthode public void dessiner(Graphics
g) dans laquelle seront donnés les ordres de tracé décrivant
un visage. L'explication et la justification de ceci seront données
par la suite lorsque les notions correspondantes auront été
abordées en TD. Ex :
class VisageRond implements FormeGeometrique
{
...
public void dessiner(Graphics g)
{
// code de la méthode dessiner
g.drawOval(...);
.......
}
...
}
L'origine des coordonnées dans la fenêtre d'affichage est
située en haut et à gauche de la fenêtre. Les abcisses
croissantes vont vers la droite, les ordonnées croissantes allant
vers le bas de la fenêtre.
Déroulement du TP
-
Commencez par spécifier de façon suffisamment précise
le comportement de votre application. Déterminez notamment les caractéristiques
du type de visages que vous allez traiter, et le jeu d'opérations
minimum qui permettront d'animer celui-ci.
-
Vous pourrez ensuite concevoir une classe correspondant au type de
visages que vous aurez retenu,
-
Lorsque votre conception sera suffisamment avancée, c'est à
dire lorsque vous aurez une idée claire de l'architecture
de votre application et de la definition de la classe definissant les visages,
alors vous pourrez passer à l'étape de codage et de mise
au point.
Créez tout d'abord un repertoire tp4 (mkdir tp4)
et placez vous à l'inteireur de celui-ci (cd tp4)
Exécutez ensuite la commande : source ~genoud/installerTP4
Cette commande a pour effet de copier dans votre répertoire courant
(tp4) les fichiers source VisagesAnimes.java
et VisageType1.java qui contiennent
respectivement les "squelettes" du programme principal et d'une classe
définissant un type de visage qui vous serviront de base pour l'application
à développer.
Editez ces fichiers en respectant les consignes qui vous sont suggérées
en commentaires.
-
Remarque :A toutes les étapes du TP, spécification, conception
et codage, faites le plus possible appel à la documentation
en ligne de Java. Cette documentation décrit les interfaces
de toutes les classes prédéfinies et fournies par Java. Vous
trouverez notamment la classe Graphics
dans le package
awt (Abstract Window Toolkit, ensemble de classes pour gérer
l'interface utilisateur des applications Java); c'est cette classe qui
fournit la quasi totalité des opérations graphiques permettant
d'effectuer des tracés à l'écran.
-
Une fois l'application fonctionnant correctement pour la manipulation de
deux visages d'un type donné, imaginez un (des) nouveau(x) types
(classes) de visages et modifiez votre application de manière a
pouvoir afficher et animer plusieurs visages de types différents.