Skip to topic | Skip to bottom
Home
Minfo05
Minfo05.GlooTD1r1.5 - 27 Sep 2005 - 21:10 - PhilippeCollettopic end

Start of topic | Skip to actions

TD 1 : Prise en main de JBuilder

PhilippeCollet (d'après d'anciens TD réalisés avec MichelBuffa et GrinRichard)

Introduction

Dans le cadre de ce TD (et des suivants si tout va bien), vous allez utiliser un IDE (Integrated Development Environment) sous sous Linux, en l'occurence, la version Entreprise de JBuilder X.

Par défaut, vous utiliserez le JDK 1.4.2, encore le plus répandu pour des raisons de compatibilité.

Lancement et paramétrage de l'environnement

Suivez les instructions de votre enseignant pour initialiser votre licence JBuilder X et lancer l'environnement. Attention à ne pas lancer JBuilder2005, mais bien JBuilder X.

Familiarisation avec l'environnement...

Hello World !

Avec tous les IDE, il faut commencer par créer un "projet". Renseignez les champs nécessaires à la création du projet dans les 3 étapes. Observez bien l'architecture imposée par JBuilder. Cela n'est pas idiot du tout... Remarquez que dès le départ on vous propose d'utiliser un package. Tant mieux ! Ensuite, vous voila dans l'environnement...

  • A l'aide de "l'expert classe", créez une classe HelloWorld.java dans un package intitulé "tp1", avec une méthode main (Ah, tiens, testez-donc dans l'éditeur crtl-j "main") qui affiche un message "hello world !" (testez ctrl-j "out") , puis compilez-la et exécutez-la (il faudra spécifier au projet quelle est sa classe principale...).

  • Observez le processus et la console de résultat. Profitez en aussi pour étudier la fenêtre Project/Properties et ses différents onglets. Ils contiennent des options qui vous serviront sans doute plus tard : les paramètres passés au programme à l'exécution, les bibliothèques qui sont automatiquement dans le CLASSPATH à la compilation / à l'exécution, plein de trucs intéressants quand on y pense !

Création d'une petite application graphique

  • A l'aide du lanceur d'expert que vous trouverez dans "File/New", créez une fenêtre principale (cadre JFrame). Mettez-donc cette classe dans un sous-package "gui". Si le package principal est "tp1", la classe que vous créez doit être dans "tp1.gui". Ainsi on sépare proprement les sources de l'interface graphique des sources des autres classes.

  • Dans la partie droite de JBuilder, sous la fenêtre d'édition, cliquez sur l'onglet "design" pour accéder au constructeur d'interface graphique. Profitez-en pour regarder les autres onglets... Placez-y un bouton et un champ de texte. Bougez les, modifier leurs propriétés : couleur, police. N'hésitez pas à faire beaucoup de modifications, il faut que vous soyez à l'aise avec l'environnement. Utilisez aussi le navigateur d'objets à gauche et regardez les interactions entre la navigation et le source en partie droite, pas mal...

  • Créez une configuration d'exécution (Menu Run/Configurations) pour tester votre Frame. Ajoutez une méthode main dans la classe de votre Frame si elle n'y est pas déjà. Vous créérez et afficherez la fenêtre depuis le main.
Utilisez donc le menu "File/New" pour créer une nouvelle "application". Jouez avec les différentes options. Créez une nouvelle configuration d'exécution pour tester votre nouvelle fenêtre graphique (aide : la classe principale est "Application1" si vous n'avez pas changé les noms de classes).

  • Cliquez sur l'onglet "UML". Cliquez sur le nom de la classe, bouton de droite/Rename. Oui, vous pouvez déplacer des classes, renommer des classes, des packages, des attributs, des méthodes depuis la vue UML. Le code restera cohérent, pas trop mal, non ?

Utilisation des beans

Les onglets Swing, etc... vous donnent accès à des java beans (on verra ce que c'est que cette bête là) fournis en standard avec JBuilder. Essayez de les utiliser pour voir comment cela marche dans l'environnement. Normalement, vous avez déjà utilisé ces beans pour insérer le bouton et le champ de texte.

  • Placez un message par défaut dans le champ de texte.

  • Trouvez maintenant comment on peut rapidement associer un gestionnaire d'événements au bouton. Insérez le code pour que cela change le champ de texte. Compilez, exécutez.

  • Faites afficher des messages sur la sortie standard et regardez comment cela intervient sur la console.

Etendez ce petit programme de test selon votre goût. Le but est que vous vous sentiez à l'aise avec l'environnement. N'hésitez pas à prendre du temps aujourd'hui ! Vous en aurez beaucoup moins les prochaines fois... Jouez avec les différents beans, changez les Layout pour voir comment cela intervient dans le placement des beans... Faites des choses qui vous ont semblé difficiles à implémenter au niveau de l'interface dans vos précédents développements...

Simulateur de bébêtes

Analyse et compilation du projet

  • Creez un nouveau projet (File/NewProject) en utilisant les options par défaut.

  • Placez-vous dans le répertoire de base du projet, et désarchivez le contenu de bebeteStupide.zip. Ca doit créer un sous-répertoire src/tp1/bebetes qui contient 4 fichiers java. L'archive bebeteStupide.zip fournit un ensemble de classes pour simuler un troupeau d'animaux.

  • Vérifiez que JBuilder tient bien compte des sources.

  • L'application fournit une architecture pour faire des simulations de bébêtes : une bébête a une position, elle se déplace dans une certaine direction avec une vitesse donnée et elle peut voir devant elle avec un certain champ de vision. Elle est censée agir (se déplacer dans un premier) temps en fonction de son environnement (les bébêtes autour par exemple).

  • Le package contient quatre classes
    • La classe principale est TestBebetes : ce n'est qu'une frame graphique qui contient un ChampDeBebetes.
    • La classe ChampDeBebetes s'occupe de créer les bébêtes et agit comme le moteur de la simulation. Régulièrement (avec un thread), elle fait "agir" chaque bébête. Cette classe s'occupe aussi de dessiner les bébêtes avec les outils AWT/Swing de base (paint/repaint).
    • La classe BebeteAbstraite est une classe abstraite qui regroupe les attributs de toutes bebetes (position, vitesse, direction...) ainsi que de quoi la dessiner (couleur, methode graphique seDessine). La seule méthode abstraite est "agit" dans laquelle doit être définie le comportement.
    • La classe BebeteStupide ne fait que définir "agit" en incrémentant les coordonnées et en gérant le débordement du champ.

Vous remarquez que la bébête fournie est plutôt stupide (d'où son nom...). Compilez et exécutez cette application.

Utilisation de ant

  • Allez dans le menu "wizards" et faites générer un fichier ant (appelez le build-jb.xml).

  • Observez le résultat obtenu.

  • Hors de JBuilder (dans un shell), vérifiez la configuration de ant, faites les exportations nécessaires :
    1. export ANT_HOME=/opt/apache-ant-1.6.2
    2. export JAVA_HOME=/usr/local/java/jdk.1.5.0_02 (jdk courant)
    3. export PATH=${PATH}:${ANT_HOME}/bin

  • Testez le fichier ant généré dans JBuilder, puis directement dans un terminal (hors de JBuilder). Si cela ne se passe pas bien, observez bien le message d'erreur. Si vous avez des problèmes d'incompatibilités Java, résolvez-les et expliquez pourquoi cela fonctionne directement dans JBuilder.

  • Téléchargez l'archive antfiles.zip. Décompactez la à la racine du projet. Étudiez le fichier build.xml. Modifiez ce qu'il faut pour pouvoir compiler et exécuter votre projet (le projet est complet si vous arrivez a faire un "ant jar" et a exécuter directement "java -jar lejarproduit.jar" aide: inutile de toucher à build.xml ou à default.properties).

  • Intégrez le fichier build.xml a votre projet dans JBuilder et effectuez la compilation depuis JBuilder. Observez les résultats et comparez la facilité d'emploi et la portabilité des deux solutions.

Création d'une classe pour des bébêtes intelligentes

Créez une nouvelle classe BebeteEmergente qui simule le comportement suivant :

  • Essaye d'aller à la vitesse moyenne des bébêtes autour
  • Va dans la direction moyenne du troupeau environnant (les bébêtes autour)
  • Maintient une distance minimale avec celles qui sont autour

Vous pouvez construire le comportement de votre bébête au fur et à mesure en définissant la méthode agit(). Regardez bien les méthodes utilitaires fournies dans les classes BebeteAbstraite et ChampDeBebetes : la direction d'une bébête est gérée en radians (soit une valeur entre 0 et 2*PI) et vous avez pratiquement toutes les informations précalculées. N'oubliez pas de faire des modifications pour que le champ de bébêtes utilise vos bébêtes à la place des bébêtes stupides.

Aide :

  • pour qu'une bestiole avance dans une certaine direction, si x,y est sa position initiale et dir sa direction en radians, le nouveau x vaudra x + distance de déplacement en pixels * cos(dir), y vaudra y + distance de déplacement * sin(dir).
  • Par défaut, la liste des bébêtes qui sont dans le champs de vision correspond à toutes les bébêtes en face de la bébête courante. Pour obtenir de meilleurs résultats, modifiez la méthode qui calcule la liste des bébêtes pour ne renvoyer que celles qui sont en face et par exemple à moins de 20 pixels de distance. BebeteAbstraite propose des fonctions de calcul de distance.

Tranformation du modèle objet du simulateur

Essayez de donner la liste de tous les problèmes de conception présents dans le projet :

  • Que faire des fonctions utilitaires sur les calculs de distance et de direction ?
  • Que faire pour que la simulation même soit indépendante de la partie graphique ?
  • Que faire pour changer le comportement des bébêtes lors de l'exécution ?
  • ...

Remarque : il n'est pas demandé de corriger ces problèmes pour l'instant.

-- PhilippeCollet - 21 Sep 2005
to top


You are here: Minfo05 > GlooTD1

to top

Copyright © 1999-2017 by the contributing authors. All material on this collaboration platform is the property of the contributing authors.
Ideas, requests, problems regarding WIKIDeptinfo? Send feedback