Intro_jb6

Introduction à JBuilder
Borland ®
™
VERSION 6
JBuilder
Consultez le fichier DEPLOY.TXT situé dans le répertoire redist de JBuilder pour avoir la liste complète des fichiers
que vous pouvez distribuer en accord avec votre contrat de licence JBuilder.
Les applications mentionnées dans ce manuel sont brevetées par Borland Software Corporation ou en attente de
brevet. Ce document ne donne aucun droit sur ces brevets.
COPYRIGHT © 1997, 2001 Borland Software Corporation. Tous droits réservés. Tous les produits Borland sont des
marques commerciales ou des marques déposées de Borland Software Corporation aux Etats-Unis et dans les
autres pays. Les autres noms de produits sont des marques commerciales ou des marques déposées de leurs
fabricants respectifs.
Pour connaître les conditions et limites des fournisseurs tiers, lisez les Remarques version sur votre CD JBuilder.
JBE0060WW21000introjb 1E0R1001
0102030405-9 8 7 6 5 4 3 2 1
PDF
Table des matières
Chapitre 1 Onglets de visualisation des fichiers. . . 5-12
Elargissement du volet contenu . . . . . 5-13
Introduction 1-1 Volet message . . . . . . . . . . . . . . . . . 5-14
Conventions de la documentation . . . . . . . . 1-2
Débogueur . . . . . . . . . . . . . . . . . . . 5-15
Remarque pour les utilisateurs
Barres d’état . . . . . . . . . . . . . . . . . . 5-16
du Macintosh . . . . . . . . . . . . . . . . . 1-4
Icônes de l’AppBrowser . . . . . . . . . . . 5-16
Comment contacter le support développeur
Volet projet . . . . . . . . . . . . . . . . . 5-17
de Borland . . . . . . . . . . . . . . . . . . . . 1-5
Volet structure . . . . . . . . . . . . . . . 5-17
Ressources en ligne. . . . . . . . . . . . . . . 1-5
Volet message . . . . . . . . . . . . . . . 5-19
World Wide Web . . . . . . . . . . . . . . . . 1-5
Navigation et recherche
Groupes de discussion Borland . . . . . . . . 1-6
dans l’AppBrowser . . . . . . . . . . . . . 5-19
Groupes de discussion Usenet . . . . . . . . 1-6
Arborescences de recherche . . . . . . . 5-20
Rapports de bogues . . . . . . . . . . . . . . 1-6
Utilisation de l’éditeur . . . . . . . . . . . . . . 5-20
Chapitre 2 Affectation des touches de l’éditeur . . . . . 5-22
Personnalisation de l’affectation
Support du langage dans JBuilder 2-1 des touches . . . . . . . . . . . . . . . . 5-22
Utilisation du menu contextuel
Chapitre 3 de l’éditeur . . . . . . . . . . . . . . . . . . 5-23
Pour mieux connaître JBuilder 3-1 Division de la vue source . . . . . . . . . . . 5-24
La documentation de JBuilder . . . . . . . . . . 3-1 Recherche de texte dans l’éditeur . . . . . . 5-24
Ressources supplémentaires . . . . . . . . . . . 3-3 Recherche de la définition d’un symbole . . 5-25
Utilisation de l’aide en ligne de JBuilder . . . . 3-3 Recherche des références à un symbole . . . 5-25
Comment obtenir de l’aide . . . . . . . . . . 3-4 Refactoring d’un symbole . . . . . . . . . . 5-26
Raccourcis Javadoc dans l’éditeur . . . . . . 5-27
Chapitre 4 Utilisation de balises @todo
Pour mieux connaître Java 4-1 dans l’éditeur . . . . . . . . . . . . . . . 5-28
Glossaires en ligne . . . . . . . . . . . . . . . . . 4-1 Gestion de l’impression dans l’éditeur . . . 5-29
Manuels . . . . . . . . . . . . . . . . . . . . . . . 4-1 Codage rapide. . . . . . . . . . . . . . . . . . . 5-29
Audit de code . . . . . . . . . . . . . . . . . 5-29
Chapitre 5 Audit de membre . . . . . . . . . . . . . 5-31
L’environnement de JBuilder 5-1 Audit de classe . . . . . . . . . . . . . . . 5-31
Utilisation de l’AppBrowser . . . . . . . . . . . 5-2 Audit de paramètre . . . . . . . . . . . . 5-33
Menu principal . . . . . . . . . . . . . . . . . 5-3 Trouver la définition (Examen/forage) . 5-33
Barre d’outils . . . . . . . . . . . . . . . . . . 5-3 Evaluation des expressions
Volet projet . . . . . . . . . . . . . . . . . . . 5-5 dans des conseils . . . . . . . . . . . . . 5-33
Définition des propriétés d’un projet . . . 5-8 Audit d’expression . . . . . . . . . . . . 5-33
Propriétés de projet par défaut . . . . . . 5-8 Configuration de l’audit de code. . . . . 5-34
Volet structure . . . . . . . . . . . . . . . . . 5-9 Optimisation des importations . . . . . . . 5-34
Visualisation des informations Javadoc . 5-9 Modèles de code. . . . . . . . . . . . . . . . 5-36
Tri dans le volet structure . . . . . . . . . 5-9 Edition des modèles de code . . . . . . . 5-37
Navigation dans le code source . . . . . . 5-10 Personnalisation de l’éditeur . . . . . . . . . . 5-37
Affichage des messages d’erreur . . . . . 5-11 Options de l’éditeur . . . . . . . . . . . . . . 5-38
Volet contenu . . . . . . . . . . . . . . . . . . 5-11 Options d’affichage . . . . . . . . . . . . . . 5-41
Onglets des fichiers . . . . . . . . . . . . . 5-11 Options de couleur . . . . . . . . . . . . . . 5-42
i
Options d’audit de code . . . . . . . . . . . . 5-43 Ouverture d’un fichier à l’extérieur
Options générales. . . . . . . . . . . . . . 5-44 d’un projet . . . . . . . . . . . . . . . . . . 7-16
Options de l’audit de membre. . . . . . . 5-45 Modification des noms de projets
Options de l’audit de paramètre . . . . . 5-45 et de fichiers . . . . . . . . . . . . . . . . . 7-17
Bouton Options d’affichage . . . . . . . . 5-46 Travail sur plusieurs projets . . . . . . . . . . . 7-17
Options des modèles . . . . . . . . . . . . . . 5-48 Passage d’un projet à l’autre . . . . . . . . . 7-17
Options de la structure Java . . . . . . . . . . 5-50 Enregistrement de plusieurs projets. . . . . 7-18
Personnalisation de l’EDI de JBuilder . . . . . . 5-51
Options du navigateur. . . . . . . . . . . . . 5-51 Chapitre 8
Options Types de fichiers . . . . . . . . . . . 5-53 Gestion des chemins d’accès 8-1
Options Web . . . . . . . . . . . . . . . . . . 5-54 Utilisation des bibliothèques . . . . . . . . . . . 8-1
Options XML . . . . . . . . . . . . . . . . . . 5-55 Qu’est-ce qu’une bibliothèque ? . . . . . . . . 8-1
Options Exécuter/Déboguer . . . . . . . . . 5-56 Ajout et configuration des bibliothèques . . . 8-2
Options Audio . . . . . . . . . . . . . . . . . 5-56 Modification des bibliothèques . . . . . . . . 8-5
Options UML . . . . . . . . . . . . . . . . . . 5-58 Affichage des listes de bibliothèques . . . . . 8-5
Options du concepteur EJB . . . . . . . . . . 5-59 Définition des propriétés d’un projet . . . . . . . 8-6
Définition du JDK . . . . . . . . . . . . . . . . 8-7
Chapitre 6 Modification du JDK . . . . . . . . . . . . . . 8-8
Développement automatique Définition du JDK dans les éditions
du code 6-1 Professionnel et Entreprise . . . . . . . . 8-9
Utilisation des outils de conception visuelle . . 6-1 Configuration des JDK . . . . . . . . . . . . 8-11
Utilisation de la galerie d’objets . . . . . . . . . 6-3 Définition des chemins d’accès
Utilisation des experts aux bibliothèques nécessaires . . . . . . . 8-11
pour un démarrage rapide . . . . . . . . . . . 6-4 Paquets . . . . . . . . . . . . . . . . . . . . . . . 8-13
emplacement du fichier .java = chemin
Chapitre 7 du source + chemin du paquet . . . . . . . 8-14
Création et gestion des projets 7-1 emplacement du fichier .class = chemin
de sortie + chemin du paquet . . . . . . . 8-15
Création d’un nouveau projet . . . . . . . . . . 7-2
Utilisation des paquets dans JBuilder . . . . 8-15
Création d’un nouveau projet en utilisant
Prescriptions pour l’appellation
l’expert projet . . . . . . . . . . . . . . . . . 7-2
des paquets . . . . . . . . . . . . . . . . . . 8-16
Etape 1 : Sélection du nom
Construction des chemins d’accès
et du modèle du projet . . . . . . . . . . 7-2
par JBuilder . . . . . . . . . . . . . . . . . . . 8-16
Etape 2 : Définition des chemins
Chemin des sources . . . . . . . . . . . . . . 8-17
du projet . . . . . . . . . . . . . . . . . . 7-4
Chemin de sortie . . . . . . . . . . . . . . . 8-17
Etape 3 : Définition des propriétés
Chemin des classes . . . . . . . . . . . . . . 8-18
générales du projet . . . . . . . . . . . . 7-6
Chemin de recherche . . . . . . . . . . . . . 8-18
Importation d’un projet existant . . . . . . . . . 7-8
Chemin de la documentation . . . . . . . . 8-19
Etape 1 : Sélection d’un répertoire source
Chemin de sauvegarde . . . . . . . . . . . . 8-19
et d’un nom pour votre nouveau projet
Répertoire de travail . . . . . . . . . . . . . 8-19
JBuilder . . . . . . . . . . . . . . . . . . . . 7-9
Où sont mes fichiers ? . . . . . . . . . . . . . . 8-20
Affichage des fichiers d’un projet . . . . . . . . 7-10
Comment JBuilder trouve les fichiers pendant
Enregistrement des projets . . . . . . . . . . . . 7-11
l’examen du code source (“forage”) . . . . 8-20
Ouverture d’un projet existant . . . . . . . . . . 7-12
Comment JBuilder trouve les fichiers
Création d’un nouveau fichier source Java . . . 7-13
pendant la compilation . . . . . . . . . . . 8-20
Gestion des projets. . . . . . . . . . . . . . . . . 7-14
Comment JBuilder trouve les fichiers classe
Ajout à un projet . . . . . . . . . . . . . . . . 7-14
pendant l’exécution ou le débogage . . . . 8-21
Retrait d’un élément d’un projet . . . . . . . 7-16
Suppression d’éléments . . . . . . . . . . . . 7-16
ii
Chapitre 9 Chapitre 11
Comparaison des fichiers Tutoriel : Construction
et versions 9-1 d’une applet 11-1
Glossaire relatif à la gestion des versions . . . . 9-1 Présentation . . . . . . . . . . . . . . . . . . . . 11-2
Comparaison de deux fichiers . . . . . . . . . . 9-2 Etape 1 : Création du projet . . . . . . . . . . . 11-3
Utilisation de la vue historique. . . . . . . . . . 9-4 Etape 2 : Génération de vos fichiers source . . 11-7
Synchroniser le défilement. . . . . . . . . 9-5 Etape 3 : Compilation et exécution
Page Sommaire . . . . . . . . . . . . . . . . . 9-6 de votre applet. . . . . . . . . . . . . . . . . . 11-11
Page Diff. . . . . . . . . . . . . . . . . . . . . 9-6 Etape 4 : Personnalisation de l’interface
Page Info . . . . . . . . . . . . . . . . . . . . 9-7 utilisateur de votre applet . . . . . . . . . . .11-13
Etape 5 : Ajout de composants AWT
Chapitre 10 à votre applet . . . . . . . . . . . . . . . . . .11-18
Tutoriel : Construction Etape 6 : Modification de votre code source . .11-21
d’une application 10-1 Etape 7 : Déploiement de votre applet . . . . .11-25
Déploiement de votre applet
Etape 1 : Création du projet . . . . . . . . . . . . 10-2
à l’aide de l’outil jar . . . . . . . . . . . . .11-26
Etape 2 : Génération de vos fichiers source . . . 10-5
Déploiement de votre applet
Etape 3 : Compilation et exécution
à l’aide du Constructeur d’archives . . . .11-28
de votre application . . . . . . . . . . . . . . . 10-8
Etape 8 : Modification du fichier HTML . . . .11-31
Etape 4 : Personnalisation de l’interface
Etape 9 : Exécution depuis la ligne
utilisateur de votre application . . . . . . . . . 10-8
de commande de l’applet déployée . . . . . .11-33
Etape 5 : Ajout d’un composant
Test sur le web de votre applet déployée . . . .11-34
à votre application . . . . . . . . . . . . . . . 10-11
Code source de l’applet . . . . . . . . . . . . .11-35
Etape 6 : Modification de votre code source . 10-12
Code source de l’applet HTML
Etape 7 : Compilation et exécution
pour GoodEveningApplet.html . . . . . .11-35
de votre application . . . . . . . . . . . . . . 10-13
Code source de la classe de l’applet
Etape 8 : Exécution de votre application
pour GoodEveningApplet.java . . . . . .11-36
depuis la ligne de commande. . . . . . . . . 10-14
Etape 9 : Ajout d’un événement à un bouton . 10-15
Chapitre 12
Etape 10 : Fin de la conception
de votre interface utilisateur . . . . . . . . . 10-17 Tutoriel : Utilisation de la vue
Etape 11 : Préparation de l’application historique 12-1
pour son déploiement . . . . . . . . . . . . . 10-19 Etape 1 : Génération de plusieurs versions
Etape 12 : Exécution de l’application déployée d’un fichier. . . . . . . . . . . . . . . . . . . . 12-2
depuis la ligne de commande. . . . . . . . . 10-21 Etape 2 : Utilisation de la page Sommaire . . . 12-4
Code source de HelloWorld. . . . . . . . . . . 10-22 Etape 3 : Utilisation de la page Diff . . . . . . . 12-6
Code source de HelloWorldCadre.java . . 10-22 Etape 4 : Utilisation de la page Info . . . . . . . 12-8
Code source de HelloWorldClasse.java . . 10-25
Code source Index I-1
de HelloWorldCadre_AboutBox.java. . . 10-26
iii
iv
Chapitre
1
Introduction
Chapitre1
Introduction à JBuilder fournit des informations détaillées sur

l’environnement de développement intégré (EDI). Il explique également
les concepts de projet et de bibliothèque et comment JBuilder utilise les
chemins lors du travail avec les projets. Apprenez comment utiliser
l’éditeur, l’audit de code, les experts et les nombreuses autres
fonctionnalités de JBuilder pour créer votre code source plus rapidement.
Trouvez des informations sur le visualiseur d’aide de JBuilder et sachez
comment trouver les réponses aux questions que vous vous posez dans
toute la documentation de JBuilder. Plusieurs tutoriels d’introduction sont
également fournis pour vous aider à découvrir comment utiliser JBuilder.
Introduction à JBuilder contient les chapitres suivants :
• Chapitre 2, “Support du langage dans JBuilder”
Décrit la prise en charge par JBuilder des langages dédiés au
développement en XML ou en Java.
• Chapitre 3, “Pour mieux connaître JBuilder”
Décrit la documentation JBuilder par édition JBuilder utilisée et fournit
des liens vers des ressources supplémentaires.
• Chapitre 4, “Pour mieux connaître Java”
Fournit la liste des manuels et des glossaires sur le langage Java.
• Chapitre 5, “L’environnement de JBuilder”
Présente l’interface utilisateur de l’environnement de développement
intégré (EDI) et traite des rubriques suivante : le travail dans
l’AppBrowser, l’utilisation de l’éditeur, la personnalisation de JBuilder,
la mise en œuvre du codage rapide, et l’emploi des experts.
Introduction 1-1
Conventions de la documentation
• Chapitre 6, “Développement automatique du code”

Décrit comment utiliser les experts de JBuilder pour créer ou modifier
les fichiers, les paramètres et les préférences.
• Chapitre 7, “Création et gestion des projets”
Explique comment créer et gérer projets et fichiers dans JBuilder, et
comment utiliser l’AppBrowser pour accomplir ces tâches de gestion.
• Chapitre 8, “Gestion des chemins d’accès”
Présente les concepts fondamentaux dre JBuilder : bibliothèques,
propriétés des projets, et comment JBuilder construit les chemins
d’accès et trouve les fichiers pendant les différentes opérations comme
la compilation ou le débogage.
• Chapitre 9, “Comparaison des fichiers et versions”
Décrit les pages et les fonctionnalités disponibles sur l’onglet
Historique du volet contenu. Décrit les fonctionnalités disponibles dans
les différentes éditions de JBuilder et leur fonctionnement en présence
et en l’absence d’un système de contrôle de versions.
• Tutoriels :
• “Construction d’une application”
Explique comment créer une application simple, “Hello World”.
• “Construction d’une applet”
Explique comment créer une applet AWT.
• “Comment utiliser la vue historique”
Explique l’utilisation de la vue historique.
Pour plus d’informations sur JBuilder et ses nombreuses fonctionnalités,
visitez le site web de Borland consacré à JBuilder, à l’adresse
http://www.borland.fr/Produits/jbuilder.
La documentation Borland pour JBuilder utilise les caractères et symboles
décrits dans le tableau ci-dessous pour signaler du texte particulier.
Il y a des considérations spéciales concernant la plate-forme Macintosh.
Voir “Remarque pour les utilisateurs du Macintosh”, page 1-4, pour plus
d’informations
1-2 Introduction à JBuilder

.
Tableau 1.1 Conventions des caractères et des symboles
Caractère Signification
Police à pas fixe La police à pas fixe représente ce qui suit :
• le texte tel qu’il apparaît à l’écran
• tout ce que vous devez taper, comme dans “Entrez Hello World
dans le champ Titre de l’expert application.”
• les noms de fichiers
• les noms de chemins
• les noms de répertoires et de dossiers
• les commandes, comme SET PATH, CLASSPATH
• le code Java
• les types de données Java, comme boolean, int et long.
• les identificateurs Java, comme les noms des variables, classes,
interfaces, composants, propriétés, méthodes et événements
• les noms de paquets
• les noms de d’arguments
• les noms de champs
• les mots clés de Java, comme void et static
Gras Le gras est utilisé pour les outils java, bmj (Borland Make for
Java), bcj (Borland Compiler for Java) et les options de
compilation. Par exemple: javac, bmj, -classpath.
Italique L’italique est utilisé pour les termes nouveaux lors de leur
définition et les titres de manuels.
Touches Cette police indique une touche de votre clavier. Par exemple,
“Appuyez sur Echap pour quitter un menu.”
[] Les crochets dans des listings de syntaxe ou de texte renferment
des éléments facultatifs. Ne tapez pas les crochets.
<> Les crochets angulaires dans le texte ou dans la syntaxe indiquent
une chaîne variable ; entrez la chaîne appropriée à votre code. Ne
tapez pas ces crochets.
Les crochets angulaires sont également utilisés pour les balises
HTML.
Il sont en outre utilisés pour les répertoires de JBuilder et du JDK.
Par exemple, <jbuilder> est une marque de réservation pour la
version courante du répertoire de JBuilder, comme jbuilder6, et
<.jbuilder> représente le répertoire dans lequel sont stockés les
paramètres de JBuilder, comme .jbuilder6. De même, <jdk> est
une marque de réservation pour le répertoire en cours du JDK.
... Dans les exemples de code, les points de suspension indiquent du
code manquant. Sur un bouton, les points de suspension
indiquent que ce bouton ouvre un dialogue de sélection.
Introduction 1-3
JBuilder est disponible sur plusieurs plates-formes. Le tableau ci-dessous

décrit les conventions utilisées dans la documentation pour les
plates-formes et les répertoires.
Tableau 1.2 Conventions pour les plates-formes et les répertoires

Elément Signification
Chemins Tous les chemins dans la documentation sont signalés par
une barre oblique (/).
Pour la plate-forme Windows, utilisez une barre oblique
inverse (\).
Répertoire de base L’emplacement du répertoire de base varie d’une
plate-forme à l’autre et est indiqué par une marque de
réservation, <home>.
• Pour UNIX et Linux, le répertoire de base peut varier.
Par exemple, il peut être /user/<nomutilisateur> ou /home/
<nomutilisateur>
• Pour Windows 95/98, le répertoire de base est C:\Windows
• Pour Windows NT, le répertoire de base est C:\Winnt\
Profiles\<nomutilisateur>
• Pour Windows 2000, le répertoire de base est C:\
Documents and Settings\<nomutilisateur>
Répertoire <jbuilder> Le répertoire <jbuilder> contient l’installation de JBuilder, y
compris les programmes, la documentation, les
bibliothèques, le JDK, les exemples et autres fichiers. Ce
répertoire est nommé d’après la version courante de
JBuilder, par exemple jbuilder6.
Répertoire <.jbuilder> Le répertoire <.jbuilder>, dans lequel sont stockés les
paramètres JBuilder, se trouve dans le répertoire de base. Ce
répertoire est nommé d’après la version courante de
JBuilder, par exemple .jbuilder6.
Répertoire jbproject Le répertoire jbproject, qui contient les fichiers projet,
classe, source, de sauvegarde et d’autres fichiers, se trouve
dans le répertoire de base. JBuilder enregistre les fichiers
dans ce chemin par défaut.
Répertoire <jdk> Le répertoire <jdk> représente le kit de développement Java
en cours. Par exemple, jbuilder6/jdk1.3/ sera représenté
dans la documentation par <jbuilder>/<jdk>/.
Captures d’écran Les captures d’écran reflètent l’apparence Metal sur de
nombreuses plates-formes.
Remarque pour les utilisateurs du Macintosh

JBuilder a été conçu pour supporter le Macintosh OS X si étroitement qu’il
prend l’apparence d’une application native. La plate-forme Macintosh a
des conventions d’apparence et de style qui diffèrent de celles de
JBuilder ; quand cela se produit, JBuilder prend l’apparence du Mac. Cela
veut dire qu’il y a quelques différences entre la façon dont JBuilder se
présente sur le Mac et ce qui est décrit dans la documentation. Par
exemple, la documentation utilise le mot “répertoire” alors que sur le Mac,

Comment contacter le support développeur de Borland
on dit “dossier”. Pour plus d’informations sur les chemins, la terminologie

et les conventions de l’interface utilisateur de Macintosh OS X, consultez
la documentation livrée avec votre OS X.

Borland offre aux développeurs diverses options de support. Elles
comprennent des services gratuits sur Internet, où vous pouvez consulter
notre importante base d’informations et entrer en contact avec d’autres
utilisateurs de produits Borland. En outre, vous pouvez choisir parmi
plusieurs catégories de support, allant de l’installation des produits
Borland au support tarifé de niveau consultant, en passant par une
assistance complète.
Pour obtenir des informations sur les services Borland de support aux
développeurs, veuillez consulter notre site Web, à l’adresse
http://www.borland.fr/Support/.
Quand vous contacterez le support, préparez des informations complètes
sur votre environnement, la version du produit que vous utilisez et une
description détaillée du problème.
Pour avoir de l’aide sur les outils tiers, ou leur documentation, contactez
votre fournisseur.
Ressources en ligne
Vous pouvez obtenir des informations depuis les sources ci-après :
World Wide Web http://www.borland.fr/

FTP ftp.borland.com
Documents techniques accessibles par anonymous
ftp.
Listserv Pour vous abonner aux bulletins électroniques, utilisez
le formulaire en ligne :
http://www.borland.com/contact/listserv.html
ou, pour l’international,
http://www.borland.com/contact/intlist.html
World Wide Web

Consultez régulièrement www.borland.fr/jbuilder. L’équipe produit de
JBuilder y place notes techniques, analyses des produits concurrents,
réponses aux questions fréquemment posées, exemples d’applications,
Introduction 1-5
mises à jour du logiciel et informations sur les produits existants ou

nouveaux.
Vous pouvez vous connecter en particulier aux URL suivantes :
• http://www.borland.fr/Produits/jbuilder/ (mises à jour du logiciel et
autres fichiers)
• http://community.borland.com/ (contient notre magazine
d’informations web pour les développeurs)
Groupes de discussion Borland

Vous pouvez vous inscrire à JBuilder et participer à de nombreux groupes
de discussion dédiés à JBuilder.
Vous trouverez des groupes de discussion, animés par les utilisateurs,
pour JBuilder et d’autres produits Borland, à l’adresse
http://www.borland.fr/Newsgroups/
Groupes de discussion Usenet

Les groupes Usenet suivants sont dédiées à Java et concernent la
programmation :
• news:comp.lang.java.advocacy
• news:comp.lang.java.announce
• news:comp.lang.java.beans
• news:comp.lang.java.databases
• news:comp.lang.java.gui
• news:comp.lang.java.help
• news:comp.lang.java.machine
• news:comp.lang.java.programmer
• news:comp.lang.java.security
• news:comp.lang.java.softwaretools
Remarque Ces groupes de discussion sont maintenus par les utilisateurs et ne sont
pas des sites Borland officiels.
Rapports de bogues
Si vous pensez avoir trouvé un bogue dans le logiciel, merci de le signaler
dans la page du support développeur de JBuilder, à l’adresse
http://www.borland.fr/Support/jbuilder/. Sur ce site, vous pouvez
également demander une fonctionnalité ou consulter la liste des bogues
déjà signalés.

Quand vous signalez un bogue, indiquez toutes les étapes nécessaires à la

reproduction de ce bogue, ainsi que tout paramètre spécial de votre
environnement et les autres programmes utilisés avec JBuilder. Précisez
bien le comportement attendu et ce qui s’est réellement passé.
Si vous avez des commentaires (compliments, suggestions ou questions)
concernant la documentation de JBuilder, vous pouvez envoyer un e-mail
à jpgpubs@borland.com. Uniquement pour la documentation. Les
questions de support doivent être adressées au support développeur.
JBuilder est fait par des développeurs pour des développeurs. Nous
apprécions vraiment vos remarques, car elles nous aident à améliorer
notre produit.
Introduction 1-7
Chapitre
Support du langage
Chapitre2
2
dans JBuilder
JBuilder assure le support de l’intégralité des langages pour le
développement en XML ou en Java.
Les fonctionnalités XML de JBuilder se répartissent entre les catégories
suivantes :
• Présentation, transformation et validation des documents XML
• Liaison des données et manipulation par programme des documents
XML
• Interface avec les données de l’entreprise stockées dans des bases de
données
Pour plus d’informations sur XML, voir le Guide du développeur
d’applications XML. Les fonctionnalités XML dépendent de l’édition de
JBuilder.
Le support JBuilder du langage Java comprend :
• JavaBeans pour la réutilisation des composants
• Composants JFC/Swing pour le développement des interfaces
utilisateur Java
Le support JBuilder Professionnel comprend de plus :
• JDBC
• Servlets
• JDK (Java Development Kit) multiples
JBuilder démarre le registre RMI et peut compiler en utilisant RMIC.
Support du langage dans JBuilder 2-1

Support du langage dans JBuilder
JBuilder vous permet de construire des applications et des applets pour

différentes versions du JDK (JDK1.1x et plus). Tout programme
existant, entièrement conforme à Java 2, peut être ajouté, travaillé et
exécuté dans l’environnement JBuilder. Sélectionnez Projet|Propriétés
du projet et l’onglet Chemins pour modifier la version JDK pour
laquelle vous compilerez.
Pour plus d’informations, voir http://www.javasoft.com.
JBuilder Entreprise ajoute le support des éléments de langage suivants :
• Enterprise JavaBeans (EJB) pour l’architecture des composants côté
serveur
• CORBA
• Pages JavaServer (JSP) pour les applications basées sur le web
Pour plus d’informations sur les JavaBeans, voir “Création de JavaBeans
avec BeansExpress” dans Construction d’applications avec JBuilder.
Pour plus d’informations sur les Enterprise JavaBeans, voir le Guide du
développeur Enterprise JavaBeans.

Chapitre
Pour mieux connaître JBuilder

Chapitre3
3
La documentation de JBuilder
Tableau 3.1 La documentation est disponible sous les formats suivants
Document Description Imprimé PDF Aide HTML
Toutes éditions :
Introduction à JBuilder Indique les nouveautés propres à cette version X X X X
de JBuilder et présente l’environnement de
développement. Explique également les
fondamentaux de JBuilder : projets,
bibliothèques, et comment JBuilder utilise les
chemins d’accès des projets pendant les
opérations comme la recherche, la
compilation, l’exécution ou le débogage.
Inclut des informations et un tutoriel sur la
gestion des versions. Fournit plusieurs
tutoriels pas-à-pas sur la création de vos
premières application et applet dans JBuilder.
Construction d’applications Explique comment créer des JavaBeans, X X X X
avec JBuilder compiler, déboguer, déployer et
internationaliser les programmes dans
JBuilder. Explique les fonctionnalités de
JBuilder concernant Javadoc, la visualisation
du code, le refactoring du code et le test des
unités. Inclut également des informations sur
les outils en ligne de commande, les messages
d’erreur, et comment faire migrer les
applications créés avec d’autres outils de
développement en Java.
Pour mieux connaître JBuilder 3-1

La documentation de JBuilder
Tableau 3.1 La documentation est disponible sous les formats suivants (suite)
Conception d’interfaces Explique comment concevoir des interfaces X X X X
utilisateur avec JBuilder utilisateur et utiliser les gestionnaires de
disposition. Inclut des tutoriels pas-à-pas
permettant de créer des interfaces utilisateur
avec les outils de conception de offerts par
JBuilder.
Développement Opentools Offre des informations conceptuelles sur X X X
pour JBuilder l’architecture de certains sous-systèmes de
JBuilder et son API d’outils ouverts pour que
vous construisiez vos propres extensions.
Référence OpenTools Fournit la documentation de référence de X X
(en anglais) l’API OpenTools de JBuilder.
Introduction à Java Présente le langage de programmation, les X X X X
bibliothèques de classes et les différentes
éditions de Java.
1
Documentation JDK 1.3 Documentation de référence de l’API du JDK X
(en anglais) (Java Development Kit) de Sun
Vous pouvez accéder à cette documentation
par l’un des moyens suivants :
• Choisissez Aide|Référence Java.
• Choisissez l’onglet Doc dans le volet
Contenu lorsque vous visualisez un fichier
du JDK.
Java Language Specification Contient la version 2.0 de la spécification du X *
langage Java.
Aide en ligne contextuelle Affiche des informations concernant l’élément X
de l’interface utilisateur de JBuilder en cours.
JBuilder Professionnel et JBuilder Entreprise :
Guide du développeur Traite des technologies utilisées par JBuilder X X X X
d’applications web pour le développement web.
Guide du développeur Traite des technologies utilisées par JBuilder X X X X
d’applications XML pour le développement XML.
Guide du développeur Traite de l’architecture de bases de données X X X X
d’applications bases de données DataExpress de JBuilder. Explique les
relations entre les principaux composants et
classes de données DataExpress, et montre
comment les utiliser pour créer vos
applications de bases de données.
Guide du développeur Explique comment utiliser efficacement les X X X
JDataStore fonctionnalités JDataStore. JDataStore est une
base de données entièrement Java,
ultra-performante et de faible encombrement.
Référence de la bibliothèque Présente des informations détaillées sur tous X X
de composants DataExpress les composants, classes, propriétés, méthodes
et événements orientés données à forte valeur
ajoutée de borland.com (documentation en
ligne seulement).

Ressources supplémentaires
Tableau 3.1 La documentation est disponible sous les formats suivants (suite)
JBuilder Entreprise :
Guide du développeur Explique comment développer et déboguer X X X X
Enterprise JavaBeans des applications Enterprise JavaBeans.
Guide du développeur Explique comment développer et déboguer X X X X
d’applications distribuées des applications Java et Web distribuées en
utilisant CORBA et RMI.
Développement en équipe Traite du contrôle de versions et explique X X X X
en utilisant JBuilder comment utiliser les interfaces de JBuilder
avec les trois principaux systèmes de contrôle
de versions ainsi que les propres outils de
gestion de versions de JBuilder.
1. Cette documentation est également disponible sur le site web JavaSoft, à l’adresse
http://developer.java.sun.com/developer/infodocs/index.shtml.
Ressources supplémentaires
Pour plus d’informations sur JBuilder et sur Java :
• Visitez le site web de JBuilder à l’adresse http://www.borland.fr/
Produits/jbuilder/ et le site Web Borland Community à l’adresse
http://community.borland.com/.
• Pour avoir la liste des manuels et glossaires sur Java, consultez le
Chapitre 4, “Pour mieux connaître Java”.
Utilisation de l’aide en ligne de JBuilder

JBuilder affiche les rubriques d’aide en ligne dans le visualiseur d’aide.
Les rubriques peuvent aussi être affichées dans l’AppBrowser ou dans un
navigateur web.
Pour mieux connaître JBuilder 3-3

Utilisation de l’aide en ligne de JBuilder
Comment obtenir de l’aide

Vous pouvez obtenir de l’aide dans JBuilder par les moyens suivants :
• A partir de l’EDI :
• Visualiseur d’aide : choisissez Aide|Rubriques d’aide, dans le menu
principal de JBuilder, pour ouvrir le visualiseur d’aide.
• Aide contextuelle : cliquez sur le bouton Aide d’une boîte de
dialogue, ou appuyez sur F1 dans un volet, un menu ou une boîte de
dialogue disposant d’un bouton Aide.
• Référence sur les classes : Choisissez Chercher|Parcourir les classes,
entrez le nom d’une classe et cliquez sur l’onglet Doc.
• Vous pouvez voir des informations de référence sur les classes à partir
de l’AppBrowser par deux autres moyens :
• Double-cliquez sur le nom d’une classe dans le volet structure, puis
sélectionnez l’onglet Doc.
• Cliquez avec le bouton droit sur le nom d’une classe dans le volet
source, choisissez Trouver la définition, puis sélectionnez l’onglet
Doc.
• A partir de l’inspecteur, choisissez une propriété ou un événement et
appuyez sur F1.
Pour plus d’informations, voir “Utilisation de l’aide en ligne de JBuilder”
dans le chapitre “Pour mieux connaître JBuilder” de l’Introduction à
JBuilder en ligne.

Chapitre
Pour mieux connaître Java

Chapitre4
4
Les documents sur le langage Java abondent. Cette liste n’a rien
d’exhaustif et reflète en partie les bibliothèques et les signets des
développeurs en JBuilder.
Glossaires en ligne
Voici les glossaires Java en ligne de Sun Microsystem :
• Glossaire Java sur HTML de Sun Microsystem :
http://java.sun.com/docs/glossary.nonjava.html#top
• Glossaire Java sur Java de Sun Microsystem :
http://java.sun.com/docs/glossary.html
Manuels
Voici la liste des manuels qui peuvent compléter votre initiation à la
programmation en Java. La première moitié de la liste est classée par
ordre de difficulté croissante. La seconde traite des sujets spéciaux tels que
la programmation pour réseau ou les JavaBeans.
Manuels Auteurs Public

Java for the World Wide Web: Dori Smith sans expérience de la
Visual Quickstart Guide programmation
(Peachpit Press)
Java: First Contact Roger Garside sans expérience de la
(Course Technology) et John Mariani programmation
Pour mieux connaître Java 4-1

Manuels
Manuels Auteurs Public

A Little Java, A Few Patterns Mattias Felleisen débutant à
(MIT Press) et Daniel P. expérimenté1
Friedmens
Beginning Java 2 Ivor Horton débutant
(Wrox Press)
Learning Java Patrick Niemeyer débutant
(O’Reilly) et Jonathan
Knudsen
Core Java 2, Volume 1: Cay S. Horstmann moyen à expérimenté
Fundamentals et Gary Cornell
(Prentice Hall)
Just Java 2 Peter van der moyen à expérimenté
(Prentice Hall) Linden
Thinking in Java Bruce Eckel moyen à expérimenté
(Prentice Hall)
Effective Java Programming Josh Bloch moyen à expérimenté
Language Guide
(Addison Wesley Longman, Inc.)
The Java Programming Language Ken Arnold, un peu plus que
(Addison-Wesley) James Gosling, moyen à expérimenté
et David Holmes
The Complete Java 2 Certification Simon Roberts, et expérimenté
Study Guide al.
(Sybex, Inc.)
Data Structures and Algorithms in Mitchell Waite expérimenté
Java et Robert Lafore
(Waite Group Press)
1. Assez théorique. Convient pour assimiler les concepts : ne convient pas pour apprendre
“comment-le-faire”.
Manuels Auteurs Sujet

Java in a Nutshell David Flanagan référence rapide
(O’Reilly) et Daniel P. Friedmens
Java Class Libraries Reference Patrick Chan, classes Java
(Addison Wesley) Rosanna Lee,
et Doug Kramer
Java Developer Almanac Patrick Chan référence rapide
(Addison Wesley Longman, Inc.) sur les classes
Java
Graphic Java 2: Mastering the JFC, David M. Geary Swing
Volume 2: Swing
(Prentice Hall)
UML Distilled: A Brief Guide to the Martin Fowler and UML
Standard Object Modeling Kendall Scott
Language
(Addison Wesley Longman)

Manuels
Manuels Auteurs Sujet

Refactoring: Improving the Design Martin Fowler refactoring
of Existing Code
(Addison Wesley)
Developing JavaBeans Robert Englander JavaBeans
(O’Reilly)
Enterprise JavaBeans Richard Monson-Haefel JavaBeans et
(O’Reilly) réseau
Java 2 Networking Justin Couch programmation
(McGraw Hill) pour réseau
The Java Virtual Machine Tim Lindholm programmation
Specifications et Frank Yellin pour réseau
(Addison-Wesley)
Java Programming with CORBA Andreas Vogel programmation
(John Wiley and Sons, Inc.) et Keith Duddy pour réseau
JDBC Database Access with Java: a Graham Hamilton, JDBC
Tutorial and Annotated Reference Maydene Fisher,
(Addison-Wesley) et Rick Cattell
Inside Servlets: Server-Side Dustin R. Callaway servlets
Programming for the Java Platform
(Addison-Wesley)
Java: Servlet Programming Jason Hunter servlets
(O’Reilly) et William Crawford
Pour mieux connaître Java 4-3

Chapitre
L’environnement de JBuilder
Chapitre5
5
Ce chapitre présente l’environnement de développement intégré (EDI) de
JBuilder. Pour faire une visite d’introduction à JBuilder, ouvrez le projet
Welcome. Choisissez Aide|Projet Welcome dans le menu principal de
JBuilder.
Dans le projet Welcome, vous pouvez choisir de voir le fichier “Release
Notes” en cliquant sur le lien Remarques version. Ou vous pouvez voir le
fichier “Release Notes” à tout moment en choisissant Aide|Remarques
version.
Ce chapitre traite des sujets suivants :
• “Utilisation de l’AppBrowser”, page 5-2
Explique l’EDI de JBuilder et les divers composants de l’AppBrowser.
• “Utilisation de l’éditeur”, page 5-20
Décrit en détails les différentes fonctionnalités de l’éditeur.
• “Codage rapide”, page 5-29
Explique les nombreux raccourcis consacrés au codage dans JBuilder et
accessibles dans l’éditeur, par exemple Audit de code, Trouver la
définition, Optimiser les imports et Modèles de code.
• “Personnalisation de l’éditeur”, page 5-37
Fournit des informations sur la personnalisation et l’utilisation des
fonctionnalités de l’éditeur. Explique comment personnaliser
l’affichage, l’affectation des touches, la mise en couleurs des éléments
syntaxiques, l’audit de code, les modèles de code et les autres aspects
de l’éditeur.
L’environnement de JBuilder 5-1

Utilisation de l’AppBrowser
• “Personnalisation de l’EDI de JBuilder”, page 5-51

Décrit comment personnaliser l’EDI de JBuilder. Explique comment
personnaliser l’AppBrowser, ajouter des types de fichiers pour qu’ils
soient reconnus par JBuilder, définir des options pour l’exécution et le
débogage, configurer les options audio, paramétrer les options web,
XML, UML et les concepteurs EJB pour l’EDI.
JBuilder utilise une seule fenêtre pour effectuer la majorité des fonctions
de développement : modification, conception visuelle, navigation,
recherche, compilation, débogage et autres opérations. Cette fenêtre
s’appelle l’AppBrowser et contient plusieurs volets proposant ces
fonctions de développement. Les volets à onglets disponibles dans le volet
contenu dépendent du type du fichier sélectionné dans le volet projet.
Figure 5.1 La fenêtre de l’AppBrowser

Vous pouvez ouvrir plusieurs AppBrowsers en sélectionnant Fenêtre|

Nouveau navigateur et passer de l’un à l’autre en sélectionnant
l’AppBrowser désiré dans le menus Fenêtre. Avec JBuilder Professionnel
et JBuilder Entreprise, vous pouvez aussi cliquer avec le bouton droit sur
un fichier dans le volet projet et choisir Ouvrir dans un nouveau
navigateur. Chaque instance de l’AppBrowser affiche les mêmes projets
ouverts ; cependant, vous pouvez ouvrir différents fichiers dans le volet
contenu de chacun. Toutes les instances de l’AppBrowser sont
synchronisées, de sorte que si un même fichier est ouvert dans deux
instances, les modifications apportés à ce fichier dans une instance de
l’AppBrowser sont reportées dans l’autre AppBrowser.
Menu principal
Le menu principal se trouve en haut de l’AppBrowser. Pour avoir
l’explication de chaque menu, consultez “Menus de JBuilder” dans l’aide
en ligne.
Barre d’outils
La barre d’outils principale se trouve en haut de l’AppBrowser, sous la
barre de menus. Elle est composée de barres d’outils plus petites
regroupées par fonctionnalités : Fichier, Edition, Chercher, Construire,
Exécuter, Déboguer, Navigation et Aide. Vous pouvez modifier
l’affichage de ces barres d’outils en cochant ou non les sélections
disponibles dans le menu Voir|Barres d’outils.
La barre d’outils fournit des boutons de raccourci pour accéder aux

commandes de menu suivantes :
Tableau 5.1 Boutons de la barre d’outils

Icône Menu équivalent Description
Fichier|Nouveau Ouvre la galerie d’objets qui met de nombreux
experts à votre disposition.
Fichier|Ouvrir Ouvre un projet, un fichier ou un paquet.
Fichier|Réouvrir Ouvre à nouveau un projet, un fichier ou un paquet.

Vous le sélectionnez dans une liste historique.
Fichier|Fermer Ferme le fichier en cours.

Tableau 5.1 Boutons de la barre d’outils (suite)

Fichier|Enregistrer Enregistre le fichier en cours.
le fichier
Fichier|Tout Enregistre tous les projets et tous les fichiers ouverts,
enregistrer en conservant leurs noms existants.
Fichier|Imprimer Imprime le fichier ou texte sélectionné.
Edition|Défaire Dans l’éditeur, réinsère tous les caractères que vous

avez supprimés, supprime tous ceux que vous avez
insérés, remplace tous les caractères que vous avez
écrasés ou ramène votre curseur à son emplacement
précédent. Dans les concepteurs, annule des actions.
Plusieurs niveaux d’annulation sont disponibles.
Edition|Refaire Annule les effets d’une action Défaire. Plusieurs
niveaux de répétition sont disponibles.
Edition|Copier Copie dans le Presse-papiers le texte sélectionné dans
l’éditeur ou l’objet sélectionné dans le concepteur
d’interface utilisateur.
Edition|Coller Colle à l’emplacement du curseur le contenu du
Presse-papiers.
Edition|Couper Coupe et place dans le Presse-papiers le texte
sélectionné dans l’éditeur ou l’objet sélectionné dans
le concepteur d’interface utilisateur.
Chercher| Recherche du texte dans le fichier actif.
Chercher
Chercher| Recherche l’occurrence suivante d’une chaîne dans le
Occurrence fichier actif.
suivante
Chercher| Remplace, dans le fichier actif, le texte spécifié par un
Remplacer autre texte spécifié.
Chercher| Charge la classe spécifiée dans l’AppBrowser. La
Parcourir les classe doit figurer sur le chemin d’importation du
classes fichier actif.
Projet|Construire Compile tous les fichiers .java dans le nœud
sélectionné, qui possèdent des fichiers .class périmés
ou inexistants. Compile aussi tous les fichiers
importés dont dépend le nœud, qui possèdent des
fichiers .class périmés ou inexistants.
Projet| Compile tous les fichiers .java dans le projet
Reconstruire sélectionné, que leurs fichiers .class soient périmés
ou non. Compile aussi les fichiers importés dont
dépend le projet, que leurs fichiers .class soient
périmés ou non.
Voir|Messages Active ou désactive le volet message.

Tableau 5.1 Boutons de la barre d’outils (suite)

Exécuter|Exécuter Exécute votre application à partir des paramètres de
le projet démarrage spécifiés dans la page Exécution de la
boîte de dialogue Propriétés du projet. La commande
Exécuter le projet compile également le projet si
l’option Compiler avant l’exécution est sélectionnée
dans la page Exécution.
Exécuter| Exécute votre programme dans le débogueur à partir
Déboguer le projet des paramètres de démarrage spécifiés dans la page
Débogage de la boîte de dialogue Propriétés du
projet. La commande Déboguer le projet compile
également le projet si l’option Compiler avant le
débogage est sélectionnée dans la page Exécution.
Configurations Cliquez sur la flèche bas à droite des boutons
d’exécution et de Exécuter et Déboguer pour accéder à la liste des
débogage configurations d’exécution ou de débogage.
Fonctionnalité de JBuilder Professionnel et de
JBuilder Entreprise.
Chercher| Revient à la classe ou à la page de démarrage dans la
Historique liste historique. Cliquez sur la flèche vers le bas à
droite du bouton pour accéder à la liste historique.
Chercher|En Active la classe ou la page précédente de la liste
arrière d’historique.
Chercher|En avant Active la classe ou la page suivante dans la liste
d’historique.
Aide|Rubriques Va dans le système d’aide en ligne.
d’aide
Volet projet
Pour développer des programmes dans l’environnement de JBuilder,
vous devez d’abord créer un projet. Un projet JBuilder organise les fichiers
que vous utilisez et gère les propriétés que vous définissez. JBuilder
stocke les projets avec l’extension .jpx ou .jpr.
Le volet projet montre le contenu du projet actif dans l’AppBrowser. Il est
constitué des éléments suivants :
• Une petite barre d’outils de quatre boutons :
• Ajouter des fichiers/paquets : ouvre la boîte de dialogue Ajouter des
fichiers ou paquets au projet.
• Retirer du projet : retire les fichiers sélectionnés du projet.
• Fermer le projet : ferme le projet actif.
• Rafraîchir : rafraîchit le projet et la recherche automatique de
paquets source (Projet|Propriétés du projet|Général).
• La liste déroulante de tous les projets ouverts.

• L’arborescence de tous les fichiers composant le projet actif.

• Le menu contextuel accessible à l’aide du bouton droit.
Pour créer un projet, choisissez Fichier|Nouveau projet dans le menu

principal, ou bien choisissez Fichier|Nouveau et l’icône Projet dans la
page Projet de la galerie d’objets. Pour démarrer plus rapidement,
continuez à utiliser les experts de la galerie d’objets pour créer une
application et des classes supplémentaires.
Si vous voulez ajouter à votre projet des fichiers ou des classes existants,
cliquez sur le bouton Ajouter des fichiers/paquets, dans la barre d’outils
du volet projet, et naviguez pour sélectionner un fichier ou un paquet.
Pour créer un nouveau fichier source Java, choisissez Fichier|Nouvelle
classe afin d’ouvrir l’expert Classe. La classe que vous créez est placée
dans le projet en cours. Si vous utilisez l’expert application, accessible
dans la page Nouveau de la galerie d’objets, la nouvelle application est
ajoutée au projet en cours. Pour ajouter un fichier vide à votre projet,
sélectionnez le bouton Ajouter des fichiers/paquets et entrez un nom et
une extension dans le champ Nom de fichier de la boîte de dialogue
Ajouter des fichiers ou paquets au projet.
Vous pouvez naviguer librement dans l’arborescence du projet, cliquer et
faire une sélection multiple de fichiers, ou cliquer avec le bouton droit et
sélectionner des éléments dans un menu contextuel, sans même ouvrir de
fichier. Les options du menu contextuel dépendent du type de fichier
sélectionné. Double-cliquez ou sélectionnez des fichiers et appuyez sur
Entrée, pour les ouvrir et les afficher dans le volet contenu de
l’AppBrowser.

Figure 5.2 Menu contextuel du volet projet
Vous pouvez ouvrir autant de projets que vous voulez dans le volet projet.
Un seul est actif à un instant donné. Le projet actif apparaît comme
élément sélectionné dans la liste déroulante du volet projet.
Vous pouvez chercher un fichier ou un paquet particulier dans le volet
projet en plaçant la focalisation sur l’arborescence du projet et en
commençant à taper son nom. Pour plus d’informations, voir
“Arborescences de recherche”, page 5-20.
Pour plus d’informations sur les projets, voir Chapitre 7, “Création et
gestion des projets”.

Définition des propriétés d’un projet

Utilisez la boîte de dialogue Propriétés du projet pour définir les
propriétés du projet actif. Pour l’ouvrir, choisissez Projet|Propriétés du
projet.
Important Il est important de comprendre comment JBuilder utilise les chemins

d’accès et les bibliothèques avant de travailler sur un projet. Pour plus
d’informations, voir “Utilisation des bibliothèques”, page 8-1,
“Construction des chemins d’accès par JBuilder”, page 8-16, et “Où sont
mes fichiers ?”, page 8-20.
Pour plus d’informations sur l’utilisation de la boîte de dialogue
Propriétés du projet, voir “Définition des propriétés d’un projet”,
page 5-8, ou cliquez sur Aide dans la boîte de dialogue.
Propriétés de projet par défaut

Les propriétés de projet par défaut sont stockées dans un projet nommé
Default.jpx ou Default.jpr et se trouvant dans le sous-répertoire
<.jbuilder> de votre répertoire home. Ce fichier est utilisé comme modèle
chaque fois qu’un projet est créé. Pour changer les propriétés de projet par
défaut, choisissez Projet|Propriétés du projet par défaut dans le menu
principal.

Volet structure
Le volet structure montre la structure du fichier sélectionné dans le volet
contenu. Cette structure s’affiche sous la forme d’une arborescence
montrant tous les membres et champs du fichier. Le volet structure peut
aussi inclure un dossier Erreurs, contenant les erreurs de syntaxe, et un
dossier Imports, contenant la liste des paquets importés.
Vous pouvez chercher rapidement un élément dans un fichier, en plaçant
la focalisation sur l’arborescence du volet structure et en commençant à
taper le nom de cet élément. Pour plus d’informations, voir
“Arborescences de recherche”, page 5-20.
Fonctionnalités Visualisation des informations Javadoc

de JBuilder Professionnel Les balises @todo des commentaires Javadoc apparaissent également dans
et de JBuilder Entreprise. le volet structure dans un dossier appelé A faire. Voir “Utilisation de
balises @todo dans l’éditeur”, page 5-28, pour plus d’informations. Les
conflits Javadoc sont affichés dans le dossier Conflits Javadoc. Voir
“Conflits dans les commentaires Javadoc” dans l’aide en ligne pour plus
d’informations.
Tri dans le volet structure

Vous pouvez changer l’ordre d’affichage du volet structure ainsi que le
délai d’analyse dans la boîte de dialogue Propriétés de la vue structure.
Cliquez avec le bouton droit dans le volet structure et choisissez
Propriétés pour ouvrir cette boîte de dialogue et modifier les options.
Figure 5.3 Propriétés de la vue structure
Ces options sont également disponibles sur la page Structure Java de la

boîte de dialogue Options de l’éditeur (Outils|Options de l’éditeur).

Pour obtenir une description complète des options disponibles, voir

“Options de la structure Java”, page 5-50.
Navigation dans le code source

Outre qu’il affiche la structure de la classe, le volet structure est le moyen
rapide de naviguer vers une classe, une méthode ou un membre du code
source. Quand vous sélectionnez un élément dans le volet structure, le
volet contenu défile jusqu’à la ligne où est défini cet élément et la met en
évidence.
Vous pouvez aussi utiliser le volet structure pour examiner (forer) les
classes ancêtre et les interfaces. Pour voir le fichier .java d’une classe
ancêtre, une interface ou le type d’une variable figurant dans le volet

structure, double-cliquez dessus (ou sélectionnez l’élément et appuyez

sur Entrée). JBuilder montre le fichier dans les volets structure et contenu.
Pour rechercher un paquet, sélectionnez Chercher|Parcourir les classes
ou double-cliquez sur le paquet dans le volet structure et sélectionnez une
classe dans la boîte de dialogue pour l’ouvrir dans le volet contenu. Pour
revenir à votre projet, cliquez sur le bouton Début de la barre d’outils
principale.
Affichage des messages d’erreur

Les messages d’erreur apparaissent dans un dossier Erreurs du volet
structure à mesure que les erreurs surviennent pendant le codage. Pour
visualiser ces messages, développez le dossier et sélectionnez un message
d’erreur. La ligne de code appropriée est sélectionnée dans le code source.
Pour une explication plus détaillée des messages d’erreur, recherchez “A
propos des messages d’erreur et d’avertissement” dans Construction
d’applications avec JBuilder.
Volet contenu
Le volet contenu affiche tous les fichiers ouverts dans un projet sous forme
d’un ensemble d’onglets. Pour ouvrir un fichier dans le volet contenu,
double-cliquez dessus dans le volet contenu ou sélectionnez-le et appuyez
sur Entrée. Le nom de chaque fichier ouvert figure sur un onglet en haut du
fichier, dans le volet contenu. Quand vous cliquez sur un onglet, le fichier
correspondant devient le fichier en cours.
Le volet contenu permet également d’accéder à diverses vues et
opérations sur les fichiers, par le biais des onglets de visualisation situés
en bas de chaque fenêtre fichier.
Onglets des fichiers

Les onglets des fichiers contiennent les noms des fichiers ouverts dans un
projet sélectionné, dans le volet contenu. Seuls les onglets des fichiers
ouverts dans le projet actif sont visibles. Vous pouvez personnaliser les
libellés des onglets de plusieurs façons : orientation, type de libellé et

insertions. Sélectionnez Outils|Options de l’EDI|Navigateur pour définir

ces options. Voir “Options du navigateur”, page 5-51.
Onglets de visualisation des fichiers

Les onglets apparaissant dans le bas du volet contenu dépendent du type
du fichier que vous avez ouvert. Seuls les onglets appropriés au fichier
ouvert apparaissent en bas de sa fenêtre. Chaque onglet fournit une vue
différente du fichier ouvert. Par exemple, un fichier .java supportant la
conception visuelle possèdera plusieurs onglets : Source, Conception,
Bean, UML, Doc et Historique. Les onglets disponibles dépendent aussi de
l’édition de JBuilder utilisée.
Tableau 5.2 Onglets de visualisation des fichiers

Nom de l’onglet Description
Source L’onglet Source affiche le code source du fichier ouvert dans
l’éditeur.
Conception L’onglet Conception affiche plusieurs concepteurs pour le
fichier ouvert. Le concepteur permet de créer visuellement les
fichiers qui héritent de java.awt.Container. Il s’ouvre dans le
concepteur d’interface utilisateur par défaut, qui vous permet
de voir comment le code s’affiche dans l’interface utilisateur, de
manipuler des dispositions, de créer des composants, d’utiliser
les outils bidirectionnels et de modifier les propriétés de
disposition. Plusieurs autres concepteurs sont également
disponibles en fonction de l’édition de JBuilder : concepteur de
menu et concepteur de colonne. D’autres composants, tels que
des éléments d’interface utilisateur déroulants ou d’autres
composants JavaBean (non interface utilisateur), peuvent aussi
être modifiés dans le concepteur en utilisant l’inspecteur et la
palette des composants.
Bean L’onglet Bean expose les concepteurs de propriétés,
d’événements, de BeanInfo et d’éditeurs de propriété
BeansExpress. Utilisez-les pour ajouter des propriétés et des
événements à votre bean, choisir les propriétés à exposer et
créer des éditeurs de propriétés personnalisés. L’onglet Bean est
en lecture seule dans JBuilder Personnel.
UML L’onglet UML affiche un diagramme UML correspondant à une
classe ou à un paquet. Fonctionnalité de JBuilder Entreprise.
Doc L’onglet Doc montre la documentation relative à la référence
API de la classe ouverte dans le volet contenu.
Historique L’onglet Historique affiche les informations vous aidant à gérer
les révisions de fichiers. Il affiche le code source du fichier actif
ainsi qu’une liste de révision des précédentes versions du
fichier. Les fonctionnalités du volet Historique varient selon
l’édition de JBuilder.

Tableau 5.2 Onglets de visualisation des fichiers (suite)

Nom de l’onglet Description
Vue L’onglet Vue affiche le fichier HTML, XML ou image ouvert
dans un navigateur ou dans un visualiseur d’image, dans le
volet contenu. Pour voir les fichiers XML, l’option Activer la
vue du navigateur doit être sélectionnée sur la page XML de la
boîte de dialogue Options de l’EDI (Outils|Options de l’EDI|
XML). La visualisation des fichiers XML est une fonctionnalité
de JBuilder Professionnel et de JBuilder Entreprise.
Vue Web L’onglet Vue Web affiche la sortie à partir de votre fichier Web
en cours d’exécution (JSP, servlet, SHTML et HTML). Pour les
JSP, l’onglet Vue Web affiche la sortie à partir du JSP en cours
d’exécution. Pour les servlet, cet onglet affiche la sortie à partir
du servlet en cours d’exécution dans du HTML analysé.
Fonctionnalité de JBuilder Professionnel et de JBuilder
Entreprise.
Source Vue Web L’onglet Source Vue Web affiche le HTML brut dans le volet
contenu. Fonctionnalité de JBuilder Professionnel et de JBuilder
Entreprise.
Editeur DD Affiche un éditeur pour le fichier web.xml, descripteur de
WebApp déploiement d’une WebApp. Fonctionnalité de JBuilder
Professionnel et de JBuilder Entreprise.
Vue de la L’onglet Vue de la transformation affiche une vue navigateur
transformation du document XML transformé après l’application d’une feuille
de style XSL. Fonctionnalité de JBuilder Professionnel et de
Source de la vue L’onglet Source de la vue de transformation affiche le code
de transformation source du document XML transformé. Fonctionnalité de
JBuilder Professionnel et de JBuilder Entreprise.
Concepteur EJB L’onglet Concepteur EJB affiche le concepteur EJB, que vous
utiliserez pour créer des composants EJB 2.0. Fonctionnalité de
Source DD EJB L’onglet Source DD EJB affiche le code source des descripteurs
de déploiement que JBuilder crée pour vous pendant que vous
construisez vos enterprise beans. Fonctionnalité de JBuilder
Entreprise.
Editeur DD EJB L’onglet Editeur DD EJB affiche l’éditeur de descripteur de
déploiement. Vous utiliserez l’éditeur de descripteur de
déploiement pour modifier les descripteurs de déploiement des
EJB. Fonctionnalité de JBuilder Entreprise.
Elargissement du volet contenu

Vous pouvez redimensionner le volet contenu d’une des façons
suivantes :
• Faites glisser la barre de division entre le volet projet et le volet contenu
jusqu’à obtenir la taille voulue.
• Choisissez Voir|Volet en plein écran, dans le menu principal, ou
appuyez sur Ctrl+Alt+Z si vous utilisez l’affectation de touches CUA,

pour développer complètement le volet contenu (en cachant les volets

projet et structure).
Reportez-vous au menu Voir dans l’aide en ligne pour les autres
configurations des volets.
Volet message
Un volet message à onglets apparaît en bas de l’AppBrowser et affiche de
façon hiérarchique les messages des divers processus, comme :
• Compilation
• Exécution
• Débogage
• Recherche
• Refactoring du code
• Test des unités
• Contrôle de versions
JBuilder génère en bas du volet message un nouvel onglet pour chaque

nouveau processus. Ces onglets vous permettent d’interagir avec le
processus qui s’exécute. Une icône sur l’onglet indique qu’un processus
est actif et que les entrées et sorties console sont possibles via la zone de
texte du volet message.
Certains processus proposent des boutons présentés sur l’onglet dans une
barre d’outils qui vous permettent d’arrêter ou de redémarrer le processus
en cours. Le bouton de redémarrage associé à un processus réutilise la
configuration en effet au moment de la création de l’onglet, ignorant toute
modification ultérieure que vous auriez effectuée. En utilisant cette
fonctionnalité, vous pouvez définir différentes configurations à tester de
façon répétitive.
Vous pouvez exécuter deux ou plusieurs processus simultanément sur un
même projet ou sur différents projets. Un onglet de projet distinct est créé
pour chaque nouveau processus démarré à l’aide des boutons Exécuter et
Déboguer de la barre d’outils principale.
Pour démarrer un nouveau processus d’exécution ou de débogage,
assurez-vous que le projet à exécuter ou débogueur est le projet actif dans
le volet projet, ou que le fichier à déboguer est le fichier en cours dans le
volet contenu. Utilisez ensuite les boutons de la barre d’outils principale
pour démarrer le processus.

Un onglet Compilateur apparaît pendant la compilation s’il y a des

erreurs ou des avertissements.
Au cours de certains processus, tels que l’exécution, le débogage, le
contrôle de versions et le refactoring, le volet message contient une barre
d’état indiquant la progression ou le résultat du processus courant.
Pour montrer ou cacher le volet message, choisissez la bascule Voir|
Messages ou le bouton Messages de la barre d’outils. Vous pouvez aussi
cacher le volet message en cliquant avec le bouton droit sur l’onglet d’un
message et en choisissant Cacher la vue message, ou en appuyant sur
Ctrl+Alt+M si vous utilisez l’affectation de touches CUA. Pour supprimer
tout ou partie des onglets du volet, cliquez avec le bouton droit sur
l’onglet d’un message et sélectionnez Retirer l’onglet <nom> ou Retirer
tous les onglets.
Vous pouvez également effectuer une copie à partir du volet message.
Cliquez avec le bouton droit dans le volet message puis sélectionnez Tout
copier, ou sélectionnez le texte à copier puis la commande Copier le
contenu sélectionné.
Débogueur
Le débogage est le processus qui consiste à localiser et à corriger les
erreurs de vos programmes. Le volet message contient l’interface
utilisateur du débogueur.
Le débogueur comprend :
• Des onglets verticaux, qui représentent les vues du débogueur. Les
vues concernent la session de débogage actuellement sélectionnée.
• Des onglets horizontaux, qui représentent les sessions de débogage.
Chaque onglet représente une nouvelle session.
• La barre d’outils du débogueur, appliquée à la session de débogage
actuellement sélectionnée.
• Une barre d’état à côté de la barre d’outils, qui indique l’état des
processus de débogage.
Si le débogueur n’apparaît pas lorsque vous choisissez Exécuter|
Déboguer, définissez un point d’arrêt sur une instruction exécutable en

cliquant dans la marge gauche grise de l’éditeur et choisissez à nouveau

Exécuter|Déboguer.
La barre d’outils, en bas du débogueur, offre un accès rapide aux boutons
Réinitialiser, Reprendre et Suspendre, ainsi qu’aux boutons Pas à pas
intelligent, Pas à pas, Pas à pas approfondi, Sortir, Ajouter un point
d’arrêt, Ajouter un point de suivi et Afficher le cadre en cours.
Pour plus d’informations sur le débogage, voir “Débogage des
programmes Java” dans Construction d’applications avec JBuilder.
Barres d’état
Il existe trois barres d’état dans l’AppBrowser.
• La barre d’état principale
• La barre d’état des fichiers
• La barre d’état des messages
La barre d’état principale s’affiche en bas de la fenêtre de l’AppBrowser et
met à jour les informations sur les processus et leurs résultats.
La barre d’état des fichiers apparaît en bas de chaque fenêtre de fichier

ouverte dans le volet contenu. Elle affiche des informations propres au
fichier en cours, comme le nom du fichier, l’emplacement du curseur
(numéro de ligne et colonne), le mode d’insertion dans un fichier texte ou
la taille d’un fichier image.
La barre d’état de message apparaît en bas du volet message au cours de

processus tels que l’exécution, le débogage et le contrôle de version.
Icônes de l’AppBrowser
JBuilder utilise des icônes dans les différentes volets pour représenter les
objets. Vous trouverez dans les tableaux ci-après la signification de ces
icônes.

Volet projet
La volet projet contient les icônes suivantes :
Tableau 5.3 Icônes du volet projet

Icône Description Icône Description
Fichier projet Fichier XML
Paquet découvert par le Fichier XSL (feuille de style)

ressourceur automatique
Paquet ajouté au projet Fichier XSD (schéma)
Nœud d’archive Fichier DTD (Document Type

Definition)
Nœud de documentation Fichier Map
Fichier Java WebApp
Fichier Web ou fichier de Nœud Descripteurs de

documentation Javadoc déploiement d’une WebApp
Fichier image Répertoire racine d’une WebApp
Fichier JSP Fichier SHTML
Fichier de type inconnu Fichier JNLP d’une application

ou d’une applet Java Web Start
Dossier
Volet structure
Les icônes du volet structure changent en fonction de la vue. Par exemple,
lorsque vous êtes dans l’éditeur, la volet structure affiche la structure du
fichier source. Si vous passez au concepteur, le volet structure affiche une
arborescence.
Tableau 5.4 Icônes du volet structure : code source

Icône Classe Icône Méthode Icône Champ
Classe publique Méthode publique Champ public
Classe privée Méthode privée Champ privé
Classe paquet Méthode paquet Champ paquet
Classe protégée Méthode protégée Champ protégé
Classe publique Méthode publique Champ public

statique statique statique
Classe privée Méthode privée Champ privé
Classe paquet Méthode paquet Champ paquet

Tableau 5.4 Icônes du volet structure : code source (suite)

Icône Classe Icône Méthode Icône Champ
Classe protégée Méthode protégée Champ protégé
Classe héritée
Icône Description Icône Description Icône HTML/XML

Constructeur Interface Elément
Interface Attribut
implémentée
Icône Description Icône Description Icône Description
Paquet importé Dossier A Faire Objet
Paquet en cours Commentaire A Objet Null

Faire
Dossier Erreurs Dossier Conflits Primitive
Javadoc
Erreur Conflit Javadoc Tableau
Message Paramètre
d’information
Avertissement Local
Tableau 5.5 Icônes du volet structure : Editeur de descripteur de déploiement WebApp

Icône WebApp Icône WebApp Icône WebApp
Descripteur Page Propriétés Contrainte
de déploiement du descripteur de sécurité
WebApp de déploiement WebApp
WebApp
Servlet WepApp Collection de
ressources web
Tableau 5.6 Icônes du volet structure : Arborescence des composants du concepteur

d’interface utilisateur
Icône Description
Composant en conception
Gestionnaire de disposition du conteneur situé immédiatement

au-dessus dans l’arborescence
Composant JavaBean
Dossier regroupant dans l’arborescence des composants semblables

(Interface utilisateur, Menu, Accès aux données, Description)

Volet message
Les icônes du volet message varient avec le processus en train de
s’exécuter. Les messages apparaissent lors de l’exécution de processus tels
que la recherche, la compilation, l’exécution, le débogage et les autres
opérations.
Tableau 5.7 Icônes du volet message

Icône Description
Message d’erreur
Résultats de recherche
Pour les autres icônes du volet message, consultez les chapitres suivants.
Voir aussi
• “Débogage des programmes Java” dans Construction d’applications avec
JBuilder
• “Test des unités” dans Construction d’applications avec JBuilder
• “Refactoring” dans Construction d’applications avec JBuilder
• Chapitre 9, “Comparaison des fichiers et versions”
• Développement en équipe en utilisant JBuilder
Navigation et recherche dans l’AppBrowser

Utilisez les raccourcis clavier suivants pour naviguer dans l’AppBrowser.
Tableau 5.8 Raccourcis clavier de navigation

Raccourcis clavier Action
Ctrl+Tab Va au volet suivant de l’AppBrowser, dans l’ordre de
rotation. L’ordre de rotation est : volet projet, volet contenu,
onglet des messages, zone de texte du volet message et volet
structure.
Maj+Ctrl+Tab Va au volet précédent, dans l’inverse de l’ordre de rotation,
de l’AppBrowser.
Touches fléchées Déplace le curseur de sélection dans une arborescence vers le
Haut/Bas haut et vers le bas.
Touches fléchées Volets projet et structure — développe et replie les branches
Gauche/Droit du nœud du niveau supérieur.
Entrée Volet projet — ouvre le fichier source sélectionné. Equivalent
à un double-clic.
Volet structure — examine (fore) la superclasse ou l’interface
de la classe sélectionnée. Equivalent à un double-clic.

Utilisation de l’éditeur
Arborescences de recherche
Pour faire une recherche dans le volet projet, structure et message, amenez
la focalisation sur le volet et commencez la saisie. Une boîte de conseil
s’affiche dans laquelle vous pouvez définir un filtre de recherche. Par
défaut, la première entrée correspondante est sélectionnée. Vous
sélectionnez les entrées suivantes et précédentes à l’aide des touches Flèche
haut et Flèche bas. Appuyez sur Echap pour annuler le mode recherche. La
recherche ne s’effectue pas dans les nœuds repliés de l’arborescence.
Pour faire une recherche dans les nœuds repliés, utilisez le caractère Point
(.) ou les touches Control + point (Ctrl+.) précédés du nom du nœud. Le
nœud est développé et la recherche est limité aux enfants. Par exemple,
comme illustré ci-dessous, le fait d’entrer texteditframe.jb dans le volet
structure sélectionne le premier composant jButton dans la branche
TextEditFrame.
Normalement, les entrées commençant par le texte spécifié sont

sélectionnées. Utilisez des caractères génériques pour changer ce
comportement :
• Un astérisque correspond à n’importe quelle chaîne de caractères.
• Un point d’interrogation correspond à tout caractère unique.
Pour accéder à l’éditeur de JBuilder, ouvrez un fichier texte et cliquez sur
l’onglet Source du volet contenu. Pour ouvrir un fichier dans le volet
contenu, double-cliquez dessus dans le volet contenu (volet supérieur
gauche), ou sélectionnez-le et appuyez sur Entrée. Notez que la barre d’état
de fichier en bas de l’éditeur indique le nom du fichier, l’emplacement du

curseur (numéro de ligne et colonne), le mode d’insertion d’un fichier

texte ou la taille d’un fichier image.
L’éditeur offre de nombreuses fonctionnalités de productivité, telles que

la correspondance d’accolades, la sélection de la syntaxe, les raccourcis
clavier, l’affectation personnalisée de ses touches, l’audit de code, les
modèles de code, la recherche et l’impression, ainsi que la possibilité de le
personnaliser entièrement. Nombre de ces fonctionnalités peuvent être
définies dans la boîte de dialogue Options de l’éditeur (Outils|Options de
l’éditeur).
De nombreuses fonctionnalités sont disponibles dans le menu contextuel
de l’éditeur : Elles varient avec l’édition de JBuilder utilisée, les
paramètres de votre projet et selon que le curseur est ou non placé dans
l’éditeur lorsque vous invoquez le menu. Le curseur étant positionné dans
l’éditeur, cliquez avec le bouton droit pour invoquer le menu contextuel
de l’éditeur.
Voir aussi
• “Astuces” (Aide|Astuces)
• “Codage rapide”, page 5-29
• “Options de couleur”, page 5-42
• “Emulation d’éditeurs par affectation des touches” (Aide|Affectations
du clavier) pour la correspondance d’accolades et les autres raccourcis
• “Gestion de l’impression dans l’éditeur”, page 5-29

Affectation des touches de l’éditeur

Les raccourcis clavier accélèrent et facilitent certaines tâches. Les
différents éditeurs font correspondre des combinaisons de touches
différentes à la même opération. Cela rend le transition d’un éditeur à
l’autre au mieux gênant et au pire dangereux.
Pour prendre en compte les habitudes et les besoins des différents
programmeurs, JBuilder propose plusieurs émulations pour l’éditeur.
Choisissez celui qui rendra votre travail le plus confortable. Les
affectations des touches sont décrites aussi bien dans JBuilder que dans le
système d’aide :
• Brief
• CUA
• Emacs
• Macintosh
• Macintosh CodeWarrior
• Visual Studio
L’affectation de touches par défaut est CUA.
1 Pour choisir un autre schéma d’affectation des touches, soit
• Sélectionnez Outils|Options de l’EDI et choisissez la page
Navigateur, soit
• Sélectionnez Outils|Options de l’EDI et choisissez la page Editeur.
2 Ensuite, cliquez sur la champ Affectation clavier.
3 Sélectionnez l’émulation d’éditeur souhaitée dans le menu déroulant.
4 Cliquez sur OK.
La nouvelle émulation est immédiatement active.
Personnalisation de l’affectation des touches

Dans JBuilder Personnel, l’éditeur d’affectation de touches est en lecture
seule ; les affectations des touches ne peuvent être modifiées. Dans
JBuilder Professionnel et JBuilder Entreprise, vous pouvez modifier
l’affectation des touches. Vous pouvez aussi écrire votre propre clavier en
utilisant l’API OpenTools.
Pour accéder à l’éditeur d’affectation de touches,
1 Soit
• Sélectionnez Outils|Options de l’EDI et choisissez la page
Navigateur, soit
• Sélectionnez Outils|Options de l’éditeur et choisissez la page
Editeur.

2 Cliquez sur le bouton Personnaliser, à côté du champ Affectation

clavier.
3 Sélectionnez la commande dont vous souhaitez modifier ou supprimer
la frappe de touches, ou à laquelle vous voulez ajouter une frappe de
touches.
4 Cliquez sur le bouton correspondant à l’action souhaitée : Modifier,
Retirer ou Ajouter.
Figure 5.4 Editeur d’affectation de touches par défaut (CUA)
Voir aussi
• L’aide en ligne dans l’éditeur d’affectation de touches
Utilisation du menu contextuel de l’éditeur

L’éditeur possède un menu contextuel permettant d’accéder rapidement
aux commandes les plus courantes. Cliquez avec le bouton droit dans
l’éditeur pour activer le menu. Les commandes du menu contextuel
varient selon l’édition de JBuilder. Consultez la documentation suivante
pour avoir des informations sur ces commandes :
• Diviser verticalement/Diviser horizontalement : “Division de la vue
source”, page 5-24
• Trouver la définition : “Recherche de la définition d’un symbole”,
page 5-25
• Trouver les références : “Recherche des références à un symbole”,
page 5-25
• Optimiser les imports : “Optimisation des importations”, page 5-34
• Renommer : “Refactoring d’un symbole”, page 5-26

• Déplacer : “Refactoring d’un symbole”, page 5-26

• Basculer le point d’arrêt/Activer le point d’arrêt/Propriétés du point
d’arrêt : “Débogueur”, page 5-15
• Options de l’éditeur : boîte de dialogue Options de l’éditeur (Outils|
Options de l’éditeur)
Division de la vue source

L’éditeur vous permet de diviser la vue source d’un fichier en deux ou
plusieurs volets verticaux ou horizontaux. Cette possibilité s’applique à
chaque fichier individuellement et non à tous les fichiers ouverts dans le
volet contenu. Vous pouvez avoir une configuration différente pour
chacun des fichiers ouverts.
Pour diviser la vue, cliquez avec le bouton droit et choisissez Diviser
verticalement ou Diviser horizontalement. Notez de nombreuses autres
options de menu sont également disponibles à partir de ce menu
contextuel. Pour transformer une vue divisée en un seul volet, cliquez
avec le bouton droit dans chaque volet et choisissez Fermer la vue.
Recherche de texte dans l’éditeur

L’éditeur offre de nombreuses façons de rechercher et remplacer du texte
spécifique dans un fichier. Les commandes de recherche se trouvent dans
le menu Chercher. Vous pouvez également modifier les options de
recherche sur la page Editeur de la boîte de dialogue Options de l’éditeur
(Outils|Options de l’éditeur|Editeur).
Tableau 5.9 Commandes de recherche de texte

Tâche Commande
Rechercher du texte Chercher|Chercher
Rechercher du texte dans tous les fichiers Chercher|Chercher dans le chemin
des chemins sélectionnés
Rechercher du texte et le remplacer par Chercher|Remplacer
une nouvelle chaîne
Rechercher encore le même texte Chercher|Occurrence suivante
Rechercher du texte de façon incrémentale, Chercher|Recherche incrémentale
à mesure que vous tapez la chaîne
Aller à un numéro de ligne spécifique Chercher|Aller à la ligne
Parcourir une classe, une interface Chercher|Parcourir les classes
ou un paquet
Naviguer jusqu’à un élément spécifique Chercher|Historique
dans la liste historique
Naviguer jusqu’à l’élément précédent Chercher|En arrière
de la liste historique

Tableau 5.9 Commandes de recherche de texte (suite)

Tâche Commande
Naviguer jusqu’à l’élément suivant Chercher|En avant
de la liste historique
Définir des signets et y revenir Combinaisons de touches, présentées
dans le fichier de correspondance des
touches (Aide|Affectations du
clavier)
Voir aussi
• Aide|Affectations du clavier pour les raccourcis clavier par éditeur
Recherche de la définition d’un symbole

La commande Trouver la définition, accessible dans le menu contextuel de
l’éditeur, vous permet de naviguer entre l’utilisation d’un symbole et sa
définition. Pour utiliser Trouver la définition,
1 Positionnez le curseur dans l’éditeur sur le symbole dont vous voulez
voir la définition.
2 Cliquez avec le bouton droit et choisissez Trouver la définition.
Le fichier source où est défini le symbole est ouvert dans l’éditeur, le
curseur positionné sur la définition du symbole.
Important Pour localiser la définition d’un symbole, vous devez avoir compilé votre
projet. La classe qui inclut la définition doit être dans le chemin
d’importation.
Voir aussi
• “Recherche de la définition d’un symbole” dans “Refactoring des
symboles du code” de Construction d’applications avec JBuilder.
Recherche des références à un symbole

Fonctionnalité La commande Trouver les références, elle aussi accessible dans le menu
de JBuilder Professionnel contextuel de l’éditeur, vous permet de voir tous les fichiers source
et de JBuilder Entreprise. utilisant un symbole particulier. Pour utiliser Trouver les références,
1 Positionnez le curseur dans l’éditeur sur le symbole dont vous voulez
voir toutes les références.
2 Cliquez avec le bouton droit et choisissez Trouver les références.
Les références trouvées sont triées par catégorie et affichées dans la
page Résultats de recherche du volet message.

Pour trouver le ou les fichiers source où existe la référence, développez le

nœud d’une catégorie et parcourez l’arborescence hiérarchique.
Double-cliquez sur une référence : cela ouvre le fichier source et
positionne le curseur directement sur la référence dans ce fichier.
Important Pour localiser les références à un symbole, vous devez avoir compilé votre
projet. Pour plus d’informations, voir “Paramétrage pour la recherche des
références et le refactoring” dans “Refactoring des symboles du code” de
Construction d’applications avec JBuilder.
Voir aussi
• “Recherche des références à un symbole” dans “Refactoring des
symboles du code” de Construction d’applications avec JBuilder.
Refactoring d’un symbole

Fonctionnalité Depuis l’éditeur, vous pouvez effectuer le refactoring du nom d’une
de JBuilder Professionnel classe, d’une méthode, d’un champ ou d’une variable locale. Vous pouvez
et de JBuilder Entreprise. effectuer le refactoring de l’emplacement d’une classe.
Pour le refactoring d’un nom,
1 Positionnez le curseur dans l’éditeur sur le symbole que vous voulez
renommer.
2 Choisissez Renommer :
• Si vous renommez une classe, la boîte de dialogue Renommer la
classe apparaît, où vous saisirez le nouveau nom de la classe.
• Si vous renommez une méthode, la boîte de dialogue Renommer la
méthode apparaît, où vous saisirez le nouveau nom de la méthode.
Vous pouvez soumettre les ancêtres au refactoring ou créer une
méthode forwarding.
• Si vous renommez un champ, la boîte de dialogue Renommer le
champ apparaît, où vous saisirez le nouveau nom du champ.
• Si vous renommez une variable locale, la boîte de dialogue
Renommer la variable apparaît, où vous saisirez le nouveau nom de
la variable.
3 Cliquez sur OK pour fermer la boîte de dialogue et terminer le
refactoring.
Remarque JBuilder vérifie automatiquement que le fichier source peut être écrit, que
le nouveau nom est valide et qu’il n’est pas déjà utilisé. JBuilder achèvera
le refactoring d’un nom seulement si ces trois critères sont remplis.

Pour déplacer une classe dans un autre paquet,

1 Positionnez le curseur dans l’éditeur sur la définition de la classe que
vous voulez déplacer.
2 Choisissez Déplacer. La boîte de dialogue Déplacement de la classe
apparaît.
3 Entrez le paquet dans lequel vous voulez placer la classe dans le champ
Paquet.
4 Cliquez sur OK pour fermer la boîte de dialogue et terminer le
refactoring de déplacement.
Important Pour que le refactoring réussisse, vous devez avoir compilé votre projet
avec ses références aux bibliothèques. Pour plus d’informations, voir
“Paramétrage pour la recherche des références et le refactoring” dans
“Refactoring des symboles du code” de Construction d’applications avec
JBuilder.
Pour plus d’informations, voir les rubriques suivantes dans Construction
• “Refactoring des symboles du code”
• “Refactoring du nom d’une classe”
• “Refactoring de l’emplacement d’une classe”
• “Refactoring du nom d’une méthode”
• “Refactoring du nom d’un champ”
• “Refactoring du nom d’une variable locale”
Raccourcis Javadoc dans l’éditeur

Fonctionnalité Javadoc est un utilitaire de Sun Microsystems qui génère les fichiers de
de JBuilder Professionnel documentation HTML à partir des commentaires que vous avez saisis
et de JBuilder Entreprise. dans les fichiers source API. Ces commentaires doivent être formatés en
respectant les standards Javadoc. Utilisez l’expert Javadoc de JBuilder
(Experts|Expert Javadoc) pour définir les propriétés concernant la
génération de la sortie Javadoc. Ensuite, lorsque vous construisez votre
projet, la sortie Javadoc est générée automatiquement.
Pour faciliter le codage des commentaires Javadoc, l’éditeur de JBuilder
contient un modèle de commentaire Javadoc, que vous activerez en tapant
/**. Le modèle ajoute automatiquement le symbole de fin des
commentaires Javadoc, */. Si le curseur est positionné immédiatement
avant la signature d’une classe, d’une interface ou d’une méthode, le
modèle se développe afin d’inclure les balises Javadoc appropriées.
Pour ajouter rapidement un bloc de commentaire Javadoc,
• Positionnez le curseur au niveau d’indentation souhaité avant la
signature d’une classe, d’une interface ou d’une méthode.

• Tapez /**.
• Appuyez sur Entrée.
L’éditeur ajoute automatiquement le symbole de fin des commentaires
Javadoc et positionne le curseur sur la second ligne du commentaire. Si
nécessaire, il ajoute les balises appropriées.
Par exemple, entrer /** au début d’un fichier source génère le bloc de
commentaire suivant :
/**
* Titre : 
* Description : 
* Copyright : Copyright (c) 2001
* Société : 
* @author
* @version 1.0
*/
Entrer /** pour la signature de la méthode suivante :
public void addValues(Double valueOneDouble, Double valueTwoDouble)
crée le commentaire Javadoc suivant :
/**
*
* @param valueOneDouble
* @param valueTwoDouble
*/
Pour plus d’informations sur JBuilder et Javadoc, voir “Création de
Javadoc à partir des fichiers source API” dans Construction d’applications
avec JBuilder.
Utilisation de balises @todo dans l’éditeur

Les balises @todo Javadoc permettent d’insérer des annotations rappelant
ce qui doit être fait dans telle partie du code. Ces balises sont placées à
l’intérieur de commentaires Javadoc.
Fonctionnalité Ces balises @todo apparaissent dans le volet structure de JBuilder dans le
de JBuilder Professionnel dossier A faire.
et de JBuilder Entreprise.
Les modèles de code de JBuilder facilitent l’ajout des balises @todo à votre
code.
1 Tapez todo au niveau d’indentation souhaité dans l’éditeur.
2 Tapez Ctrl+J pour développer le modèle dans votre code.
/** @todo <curseur placé ici> */
Certains experts de JBuilder génèrent des annotations sous la formes de
balises @todo afin que du code soit ajouté au code stub qu’ils génèrent.

Codage rapide
Gestion de l’impression dans l’éditeur

Vous pouvez utiliser la commande Fichier|Imprimer pour imprimer
votre code source directement à partir de l’éditeur.
La commande Fichier|Mise en page affiche la boîte de dialogue Mise en
page, qui vous permet de définir des options de mise en page :
• Mise en page : Les options de la page Mise en page vous permettent de
choisir l’orientation, la disposition et la fonte des pages, et de
configurer la numérotation et les sauts de ligne.
• Avancée : Les options de la page Avancée vous permettent de définir
les marges et d’imprimer les en-têtes de page. Utilisez les variables
suivantes pour contrôler ce qui est imprimé dans l’en-tête de la page.
Tableau 5.10 Variables des en-têtes de page

Variable Description
%f Nom de fichier et chemin
%g Nom de fichier uniquement
%p Numéro de page
%n Nombre total de pages
%t Heure
%d date (version longue)
%s date (version courte)
%u Nom d’utilisateur
Codage rapide
JBuilder vous fait bénéficier de l’audit de code pour faciliter le
remplissage du code et propose des modèles de code pour l’insertion
rapide des éléments de code fréquemment utilisés dans l’éditeur.
Audit de code
L’audit de code offre une fonction d’achèvement de code, des listes de
paramètres et une évaluation des expressions par conseils pour les fichiers
JAVA et pour les segments de code des fichiers JSP files. L’audit de code
de JBuilder affiche dans l’éditeur des fenêtres déroulantes contextuelles
montrant ce qui suit :
• Membres données et méthodes accessibles dans le contexte en cours
(Audit de membre).
• Les classes accessibles via le chemin des classes en cours (Audit de
classe).

Codage rapide
• Paramètres attendus par la méthode que vous codez (Audit de

paramètre).
• L’examen (forage) du code source de la variable, méthode ou classe
courante dans l’éditeur (Trouver la définition).
Fonctionnalité • Les valeurs de variables affichées dans le débogueur (Evaluation des
de JBuilder Professionnel expressions par conseil).
Fonctionnalité • Le contenu de l’expression sélectionnée dans le débogueur (Audit
de JBuilder Professionnel d’expression).
Important Le projet doit être compilé avant que les classes importées soient
disponibles pour l’audit de code.
Figure 5.5 Fenêtre déroulante de l’audit de code
Pour accéder à l’audit de code, utilisez les touches de raccourci suivantes.

Tableau 5.11 Touches de raccourcis de l’audit de code
Fenêtre Frappe de
déroulante touches Actions
Audit de membre Ctrl+H Affiche les méthodes et les membres dans la
portée en cours.
Audit de Ctrl+Maj+H Affiche les paramètres de méthode.
paramètre
Trouver la Ctrl+Entrée Examine.
définition
Audit de classe Ctrl+Alt+Espace Affiche l’audit de classe où vous pouvez
Ctrl+Alt+H rechercher les classes à insérer dans votre code.
Modèles de code Ctrl+J Affiche les modèles de code.

Codage rapide
Remarque Pour le Macintosh, utilisez la touche Meta à la place de la touche Ctrl.

Les touches peuvent varier avec l’affectation de touches sélectionnée. Pour
voir la liste des frappes de touches correspondant à un clavier,
reportez-vous à la boîte de dialogue Editeur d’affectation de touches. Pour
ouvrir l’éditeur d’affectation de touches, choisissez Outils|Options de
l’éditeur, choisissez l’affectation clavier souhaitée et cliquez sur le bouton
Personnaliser dans la page Editeur. Dans JBuilder Professionnel et
JBuilder Entreprise, l’affectation des touches peut être modifiée.
Astuce Si l’audit de code échoue, recherchez des erreurs de type instructions
d’importation manquantes ou accolades manquantes.
Utilisez les touches fléchées pour déplacer la sélection vers le haut ou vers
le bas. Pour accepter une sélection dans l’audit de code, appuyez sur Entrée
ou sur tout caractère non-alphanumérique, comme ( (parenthèse
ouvrante), ) (parenthèse fermante), + (signe plus), - (signe moins), ou la
barre d’espace.
Voir aussi
• Voir Aide|Affectations du clavier
Audit de membre
L’audit de membre offre la liste déroulante de tous les appels de méthodes
appropriés à un préfixe de référence donné, en fonction des paramètres
que vous avez choisis pour l’audit de code. La liste déroulante s’affiche
automatiquement quand vous tapez un point (.) dans un contexte correct.
Vous pouvez également appeler manuellement cette liste en tapant
Ctrl+Espace ou Ctrl+H.
Vous pouvez aussi entrer le nom d’une classe pour voir les noms des
méthodes, propriétés et événements valides. La fonctionnalité
d’achèvement du code peut également être utilisée pour compléter les
instructions d’affectation. La fonctionnalité d’achèvement du code de
l’audit de code peut aussi être automatique. Si le reste d’une instruction
est unique, l’audit de code la termine automatiquement sans afficher la
liste des membres.
La liste des membres est basée sur les importations du projet en cours. Les
méthodes désapprouvées sont barrées. La liste est filtrée selon les règles
d’accessibilité du langage Java.
Audit de classe
L’audit de classe invoque la boîte de dialogue Audit de classe, qui peut
servir à insérer des classes dans votre code. Pour afficher la boîte de
dialogue, appuyez sur Ctrl+Alt+Espace ou sur Ctrl+Alt+H dans l’éditeur.

Codage rapide
Commencez à saisir le nom de la classe à insérer dans votre code dans le

champ Chercher. Pendant que vous tapez, JBuilder recherche de manière
dynamique dans le chemin d’accès aux classes en cours et affiche une liste
des correspondances possibles qui se modifie au fur et à mesure que vous
saisissez des caractères. Appuyez sur Entrée ou utilisez un double-clic pour
insérer la classe sélectionnée et appuyez sur Ctrl+Enter pour insérer le
paquet. Vous pouvez aussi utiliser les touches fléchées pour naviguer
dans la liste. Pour trouver des classes dans une bibliothèque, la
bibliothèque doit faire partie de votre projet. Quand vous ajoutez une
classe à l’aide de l’audit de classe, l’instruction import s’ajoute
automatiquement à votre code en tant que dernière instruction
d’importation. Pour réorganiser et optimiser vos instructions import,
utilisez Optimiser les imports dans l’éditeur. Voir “Optimisation des
importations”, page 5-34.
Important Si vous avez ajouté un fichier source ou une bibliothèque à votre projet,
vous devez recompiler le projet et choisir le bouton Rafraîchir dans le
volet projet avant que l’audit de classe reconnaisse vos ajouts. Utilisez
Projet|Construire le projet ou Projet|Reconstruire le projet pour le
recompiler.
Voir aussi
• “Ajout et configuration des bibliothèques”, page 8-2
• “Chemin des classes”, page 8-18
Options d’insertion
Fonctionnalité L’audit de classe propose plusieurs options d’insertion pour contrôler la
de JBuilder Professionnel façon dont sont insérés le nom de la classe et l’instruction d’importation
et de JBuilder Entreprise. dans votre code. Les exemples suivants utilisent la classe BorderLayout
dans le paquet java.awt.
• Insérer un nom de classe court avec l’import explicite
Insère le nom abrégé de la classe et une instruction import qui inclut le
nom complet du paquet et de la classe. Par exemple,
• Nom de classe inséré : BorderLayout
• Instruction import insérée : import java.awt.BorderLayout;
• Insérer un nom de classe court avec l’import de paquet
Insère le nom abrégé de la classe et l’instruction import du paquet. Par
exemple,
• Nom de classe inséré : BorderLayout
• Instruction import insérée : import java.awt.*;

Codage rapide
• Insérer un nom de classe complet

Insère le nom complet de la classe (paquet + nom de classe) sans
instruction import. Par exemple,
• Nom de classe inséré : java.awt.BorderLayout
• Instruction import insérée : aucune
Voir aussi
• “Optimisation des importations”, page 5-34
Audit de paramètre
Quand vous codez l’appel à une méthode, vous pouvez afficher la liste
des paramètres de cette méthode. Pour afficher la liste des paramètres,
tapez le nom de la méthode et appuyez sur Ctrl+Maj+Espace, Ctrl+Maj+H, ou la
parenthèse ouvrante ((). Tous les paramètres possibles sont affichés, y
compris les paramètres surchargés.
Si le code source de la méthode est disponible, les noms des paramètres
sont affichés. Au fur et à mesure que vous remplissez les paramètres de la
méthode, le paramètre courant apparaît en évidences dans la liste de
paramètres.
Trouver la définition (Examen/forage)

Trouver la définition vous amène rapidement au code source de la
variable, méthode ou classe en cours dans l’éditeur, s’il existe. S’il n’est
pas disponibles, il vous amène à la source stub. Pour appeler cette
fonctionnalité, placez le curseur sur le symbole en question dans votre
code source et appuyez sur Ctrl+Entrée. Voir Aide|Affectations du clavier
pour une liste complète des affectations de touches par clavier.
Evaluation des expressions dans des conseils

Fonctionnalité Quand vous déboguez un programme, vous pouvez placer le curseur de
de JBuilder Professionnel la souris sur une variable dans l’éditeur pour afficher sa valeur. Celle-ci
et de JBuilder Entreprise. s’affiche dans un petit panneau déroulant qui ressemble à un conseil.
Audit d’expression
Fonctionnalité Suspendez le débogueur et placez le curseur à l’intérieur d’une expression
de JBuilder Professionnel pour avoir accès à l’audit d’expression. L’audit d’expression est une petite
et de JBuilder Entreprise. fenêtre déroulante qui affiche, sous une forme arborescente, le contenu de
l’expression sélectionnée.
Voir aussi
• “Options Exécuter/Déboguer”, page 5-56

Codage rapide
Configuration de l’audit de code

Pour configurer l’audit de code, cliquez avec le bouton droit sur le volet
source, sélectionnez Options de l’éditeur et cliquez sur la page Audit de
code ou choisissez Outils|Options de l’éditeur|Audit de code. Pour plus
d’informations, voir “Audit de code”, page 5-29.
JBuilder fournit plusieurs modèles de code prédéfinis. Sélectionnez
Outils|Options de l’éditeur|Modèles pour afficher les modèles
disponibles.
Optimisation des importations

Fonctionnalité Utilisez la commande Optimiser les imports dans le menu contextuel de
de JBuilder Professionnel l’éditeur pour récrire et réorganiser vos instructions d’importation en
et de JBuilder Entreprise. accord avec les paramètres personnalisés figurant dans les Propriétés du
projet. La commande Optimiser les imports supprime également les
instructions import qui ne sont plus utilisées par votre code. Vous pouvez
personnaliser l’ordre des importations dans la page Style import de la
boîte de dialogue Propriétés du projet (Projet|Propriétés du projet).
Définition des propriétés d’importation

Utilisez la page Style import de la boîte de dialogue Propriétés du projet
pour personnaliser la façon d’importer les paquets. Pour cela,
1 Soit
• Cliquez avec le bouton droit sur le fichier projet (.jpx ou .jpr) dans le
volet projet et choisissez Propriétés, soit
• Sélectionnez Projet|Propriétés du projet.
2 Sélectionnez l’onglet Style import.

Codage rapide
Figure 5.6 La page Style import de la boîte de dialogue Propriétés du projet
• Lorsque vous cochez l’option Toujours importer les classes, Optimiser

les imports n’ajoute jamais d’instruction d’importation de paquet à
votre code. Il importera directement les classes individuelles. Si vous
cochez cette case, l’option Seuil d’import du paquet perd sa pertinence.
• Le Seuil d’import du paquet définit le nombre de classes du même
paquet devant être utilisées avant que les instructions d’importation
des classes soient transformées en une instruction d’importation du
paquet.
Jusqu’à cette limite, chaque classe est importée avec une instruction
d’importation séparée. Lorsque la limite est dépassée, c’est l’ensemble
du paquet qui est importé. Par exemple, si ce champ contient le
nombre 3 et si vous utilisez au moins 4 classes d’un paquet, la totalité
de ce paquet sera importée.
• Cliquez sur le bouton Ajouter un paquet pour sélectionner et ajouter un
autre paquet à la liste des importations.
• Pour insérer un saut de ligne supplémentaire entre deux instructions
import ou entre deux groupes d’instructions import, sélectionnez le
paquet sous lequel vous voulez insérer le saut de ligne et cliquez sur le
bouton Ajouter une ligne vierge.
• Pour modifier l’instruction d’importation d’un paquet, sélectionnez-la
et cliquez sur le bouton Modifier.
• Pour retirer une instruction import de la liste, sélectionnez-la et cliquez
sur Retirer.

Codage rapide
• Pour déplacer une instruction import ou une ligne vierge,

sélectionnez-la et cliquez sur Vers le haut ou Vers le bas.
Remarque Les commentaires de la section import du code sont conservés.
Astuce Si vous voulez personnaliser l’ordre des instructions pour tous les
nouveaux projets, choisissez Projet|Propriétés du projet par défaut et
effectuez vos modifications dans la page Style import de la boîte de
dialogue Propriétés du projet par défaut.
Utilisation de Optimiser les imports

Pour optimiser les importations,
1 Choisissez Projet|Construire le projet pour compiler votre projet.
2 Cliquez avec le bouton droit dans l’éditeur et choisissez la commande
Optimiser les imports.
Astuce Choisissez Edition|Défaire pour annuler les effets de Optimiser les
imports.
Pour plus d’informations, choisissez le bouton Aide dans la page Style
import de la boîte de dialogue Propriétés du projet (Projet|Propriétés du
projet).
Modèles de code
L’ajout, l’édition et la Les modèles de code sont des snippets d’éléments de code fréquemment
suppression de modèles utilisés que vous pouvez insérer dans votre code pour éviter de les saisir
sont des fonctionnalités de façon répétitive. Vous pouvez utiliser les modèles de code dans
de JBuilder Professionnel l’éditeur pour accélérer le processus de codage.
Les modèles de code Pour utiliser un modèle de code, sélectionnez une des méthodes
sont accessibles en suivantes :
lecture seule dans • Tapez le nom du modèle de code, par exemple classp, là où vous voulez
JBuilder Personnel. qu’il apparaisse dans votre code et appuyez sur Ctrl+J. Voir Outils|
Options de l’éditeur|Modèles pour connaître les noms des modèles.
• Positionnez le curseur là où le code doit apparaître puis appuyez sur
Ctrl+J pour afficher la liste des modèles de code. Opérez votre choix
dans la liste à l’aide des flèches de direction puis appuyez sur Entrée.
L’éditeur étend automatiquement le modèle.
Astuce Une fois le modèle développé, vous pouvez utiliser l’audit de code pour
être assisté dans l’écriture du code. Voir “Codage rapide”, page 5-29.
La mise en forme des modèles de code prédéfinis de JBuilder dépend de
vos préférences de projet. Ces options se définissent dans les endroits
suivants :
• Option Accolades : Projet|Propriétés du projet|page Style de code
• Option Indentation de bloc : Outils|Options de l’éditeur|page Editeur

Personnalisation de l’éditeur
Edition des modèles de code

Fonctionnalité Vous pouvez modifier les modèles par défaut de JBuilder, en créer de
de JBuilder Professionnel nouveaux ou supprimer ceux dont vous n’avez pas besoin. Pour modifier
et de JBuilder Entreprise. cette liste, cliquez avec le bouton droit dans l’éditeur, sélectionnez Options
de l’éditeur et cliquez sur l’onglet Modèles.
Pour créer un nouveau modèle de code,
1 Choisissez Outils|Options de l’éditeur et cliquez sur l’onglet Modèles.
2 Appuyez sur le bouton Ajouter de la page Modèles.
3 Entrez le nom et la description du nouveau modèle de code, puis
appuyez sur OK.
4 Tapez le code du nouveau modèle dans la zone de texte Code.
5 Ajoutez ou modifiez d’autre modèle, puis appuyez sur OK quand vous
avez fini pour fermer la boîte de dialogue Options de l’éditeur.
Pour modifier un modèle de code existant,
1 Choisissez Outils|Options de l’éditeur et cliquez sur l’onglet Modèles.
2 Utilisez la souris ou les flèches Haut/Bas pour sélectionner dans la liste le
modèle de code à modifier.
3 Appuyez sur le bouton Modifier de la page Modèles pour changer le
nom ou la description du modèle sélectionné.
4 Entrez le nom et la description du nouveau modèle de code, puis
appuyez sur OK.
5 Tapez dans la zone d’édition de texte Code pour modifier l’exemple de
code.
6 Ajoutez ou modifiez d’autre modèle, puis appuyez sur OK quand vous
avez fini pour fermer la boîte de dialogue Options de l’éditeur.
Important Lorsque vous créez ou modifiez des modèles, JBuilder ne les formate pas
selon les préférences. Vous devez définir manuellement les accolades et
les indentations.
Pour plus d’informations, voir “Options des modèles”, page 5-48.
Utilisez la boîte de dialogue Options de l’éditeur pour personnaliser
l’environnement d’édition de JBuilder. Pour ouvrir cette boîte de
dialogue, choisissez Outils|Options de l’éditeur à partir du menu
principal ou cliquez avec le bouton droit dans le volet source et
sélectionnez Options de l’éditeur.

La boîte de dialogue Options de l’éditeur contient les pages suivantes :

• Options de l’éditeur
• Options d’affichage
• Options de couleur
• Options d’audit de code
• Options des modèles
• Options de la structure Java
Remarque Pour rétablir les paramètres en vigueur lors de l’activation de la boîte de
dialogue, cliquez sur le bouton Réinitialiser sur la page appropriée.
Voir aussi
• “Personnalisation de l’EDI de JBuilder”, page 5-51
Options de l’éditeur
Utilisez la page Editeur de la boîte de dialogue Options de l’éditeur pour
personnaliser le comportement de l’éditeur.
Les options de la page Editeur comprennent :

• Affectation clavier
Définit l’affectation des touches de l’éditeur. L’affectation de touches
par défaut est CUA. Pour la liste complète des définitions de touches,
voir “Affectations du clavier” dans le menu Aide.

• Personnaliser
Affiche la boîte de dialogue Editeur d’affectation de touches associée à
l’éditeur sélectionné qui vous permet de personnaliser l’affectation des
touches sélectionnée. L’éditeur d’affectation de touches est en lecture
seule dans JBuilder Personnel.
• Indentation de bloc
Spécifie le nombre de caractères entre les différents niveaux
d’indentation du texte. C’est le décalage de la tabulation effectif dans
tous les cas sauf pour les véritables caractères de tabulation. La valeur
spécifiée est utilisée pour indenter les blocs marqués et lorsque
l’utilisateur appuie sur la touche Tab. La valeur par défaut est 2 ; la
limite supérieure est 20.
• Taille de tabulation
Définit le nombre de caractères entre les taquets de tabulation pour les
véritables caractères de tabulation. Cette option n’est utilisée que pour
afficher le texte contenant déjà des caractères de tabulation. Appuyer
sur la touche Tab peut créer une indentation de taille différente. Voir
Indentation de bloc ci-dessus. La valeur par défaut est 8.
• Niveau de sauvegarde
Définit le nombre de sauvegardes de fichier. Le nombre maximum de
sauvegardes est de 30.
• Options de touches intelligentes
Détermine la façon dont fonctionnent les touches intelligentes dans
l’éditeur. Cliquez sur l’icône de développement pour développer la
liste.
• Touche Début intelligente : Lorsque cette option est sélectionnée, la
touche Origine positionne le curseur à gauche, avant le premier
caractère non blanc de la ligne. Si le curseur se trouve déjà à cette
position, il est placé au tout début de la ligne. Par défaut, cette option
est désactivée.
• Touche Fin intelligente : Lorsque cette option est sélectionnée, la
touche Fin positionne le curseur à droite, après le dernier caractère
non blanc de la ligne. Si le curseur se trouve déjà à cette position, il
est placé à la fin de la ligne. Par défaut, cette option est désactivée.
• Tabulation intelligente : Indente pour aligner le curseur avec le côté
gauche des mots de la première ligne non vide précédant la ligne en
cours. Recherche les premiers caractères différents d’un espace sur
les lignes qui commencent par des espaces. Si aucun caractère de
cette sorte n’est trouvé, Tab place le curseur sur la position
d’indendation de bloc suivante. Par défaut, cette option est
désactivée.

• Options d’indentation
Détermine le fonctionnement de l’indentation dans l’éditeur. Cliquez
sur l’icône de développement pour développer la liste.
• Indentation intelligente positionne le curseur sous le premier
caractère non blanc de la précédente ligne non blanche, quand vous
appuyez sur Entrée. Par défaut, cette option est active.
• Indenter après l’accolade indente automatiquement la ligne suivante
quand vous entrez une accolade. L’indentation intelligente doit être
activée pour que Indenter après l’accolade puisse fonctionner.. Par
défaut, cette option est désactivée.
• Utiliser le caractère tabulation, lors de l’indentation d’une ligne,
remplace automatiquement les caractères espace par des caractères
de tabulation. Par exemple, si Indentation de bloc vaut 2 et Taille de
tabulation vaut 8, appuyer quatre fois sur la touche Tabulation en
début de ligne aura comme résultat l’insertion d’un seul caractère de
tabulation. Les caractères de tabulation ne sont jamais insérés après
des caractères non espace, même si cette option est activée. Par
défaut, cette option est désactivée.
• Aligner l’accolade fermante aligne l’accolade fermante sur l’accolade
ouvrante. Par défaut, cette option est désactivée.
• Options d’affichage
Cliquez sur l’icône de développement. Curseur clignotant fait clignoter
le curseur. Par défaut, cette option est active.
• Options de sauvegarde
Détermine le mode de sauvegarde des fichiers. Cliquez sur l’icône de
développement pour développer la liste.
• Enlever les espaces à la fin supprime tous les espaces de remplissage
du fichier lors de l’enregistrement. Par défaut, cette option est active.
• Modifier les tabulations de début en espaces remplace tous les
caractères de tabulation de début par des espaces. Par défaut, cette
option est désactivée.
• Modifier les espaces de début en tabulations remplace les espaces de
début par des tabulations. Par défaut, cette option est désactivée.
• Options de recherche
Détermine le mode de recherche dans les fichiers. Cliquez sur l’icône de
développement pour développer la liste.
• Afficher le dialogue lorsque la recherche échoue affiche une boîte de
dialogue Recherche infructueuse lorsque la recherche échoue. Si
cette option n’est pas sélectionnée, le dialogue est supprimé et le

message s’affiche sur la barre d’état. Par défaut, cette option est
active.
• Cherche le mot sous le curseur place automatiquement le mot le plus
proche du curseur dans le champ Texte à chercher de la boîte de
dialogue Chercher / Remplacer du texte. Par défaut, cette option est
désactivée.
Options d’affichage
Utilisez la page Affichage de la boîte de dialogue Options de l’éditeur
pour sélectionner les options d’affichage et de fonte du volet contenu. Le
chargement des fontes disponibles risque de durer. La boîte Exemple
affiche un exemple de la fonte actuellement utilisée par l’éditeur.
La page Affichage contrôle :

• Marge droite visible
Affiche une ligne grise fine, verticale, représentant la marge droite dans
l’éditeur. Par défaut, cette option est active.
• Marge droite
Définit la marge droite de l’éditeur. La valeur par défaut est de 80
caractères. L’intervalle autorisé s’étend de 1 à 1024 et des valeurs
prédéfinies sont accessibles dans le menu déroulant. Si l’option Marge
droite visible est sélectionnée, une ligne verticale grise est affichée pour
matérialiser la marge.

• Famille de fonte
Sélectionne une fonte parmi les fontes écran installées sur votre
système et présentées dans la liste Famille de fonte. L’éditeur affiche et
utilise uniquement les polices écrans à espacement fixe. Le texte
d’exemple s’affiche dans la boîte Exemple. DialogInput est la valeur par
défaut.
• Taille de fonte
Sélectionne une taille de fonte parmi les tailles prédéfinies associées à la
police sélectionnée dans la boîte liste Famille de fonte. Le texte
d’exemple s’affiche dans la boîte Exemple. La valeur par défaut est 12,
l’intervalle accepté va de 6 à 30.
• Exemple
Affiche un exemple de la fonte et de la taille sélectionnées pour être
utilisées dans l’éditeur.
Options de couleur
Utilisez la page Couleur de la boîte de dialogue Options de l’éditeur pour
spécifier comment les différents éléments de votre code apparaissent dans
l’éditeur. Vous pouvez spécifier une couleur de texte et une couleur de
fond pour n’importe quel élément présenté dans la liste Elément d’écran.
L’éditeur supporte la mise en valeur syntaxique pour les fichiers Java,
HTML, JSP, C, C++, SQL, XML, XSL, XSD, XSP, DTD et IDL.
L’exemple de code, en bas de la boîte de dialogue, montre comment vos
choix se traduisent dans l’éditeur.

Les options de la page Couleur définissent ce qui suit :

• Modèle de couleurs de l’éditeur
Configure rapidement l’affichage dans l’éditeur en utilisant des
combinaisons de couleurs prédéfinies.
• Elément d’écran
Spécifie la mise en évidence d’un élément particulier. Vous pouvez
effectuer votre choix dans la liste Elément d’écran ou cliquer sur un
élément de code dans la boîte exemple.
• Attributs
Spécifie les attributs de format de l’élément de code sélectionné dans la
liste Elément d’écran.
• Texte
Définit la couleur du texte pour l’élément de code sélectionné. Pour
définir la couleur, choisissez une couleur dans la palette Texte. La
couleur sélectionnée est affichée au-dessus de la palette Texte. Pour
créer une couleur personnalisée, cliquez avec le bouton droit sur la
palette située à droite de la palette standard. Choisissez Par défaut pour
restaurer la couleur système par défaut du texte pour l’élément de code
sélectionné.
• Fond
Définit la couleur du fond pour l’élément de code sélectionné. Pour
définir la couleur, choisissez une couleur dans la palette. La couleur
sélectionnée est affichée au-dessus de la palette Fond. Pour créer une
couleur personnalisée, cliquez avec le bouton droit sur la palette située
à droite de la palette standard. Choisissez Par défaut pour restaurer la
couleur système par défaut du fond pour l’élément de code sélectionné.
• Exemple de code
Affiche les paramètres sélectionnés dans un snippet de code.
Options d’audit de code

Utilisez la page Audit de code de la boîte de dialogue Options de l’éditeur
pour configurer l’audit de code. La page Audit de code est là où vous :
• Activez l’affichage automatique de la liste des membres ou des
paramètres.
• Définissez la durée de la pause avant que la fenêtre d’achèvement du
code ou la liste des paramètres s’affiche.
• Définissez les options avancées.

Pour ouvrir la page Audit de code, choisissez Outils|Options de l’éditeur,

puis cliquez sur l’onglet Audit de code. Vous pouvez également cliquer
avec le bouton droit dans l’éditeur et sélectionnez Options de l’éditeur.
Si les options Affichage automatique de cette page sont sélectionnées, les

fenêtres surgissantes s’affichent dès que vous entrez au clavier les
caractères d’activation requis (détaillés ci-après) et attendez le délai
spécifié dans la glissière Délai.
Si aucune option Affichage automatique de cette page n’est sélectionnée,
l’audit de code est disponible à la demande par des touches de raccourcis.
Les frappes de touche peuvent varier d’un éditeur à l’autre. Pour vérifier
ou définir l’affectation des touches de votre éditeur, choisissez Outils|
Options de l’éditeur|Editeur et choisissez un éditeur dans la liste
déroulante Affectation clavier. Puis, choisissez le bouton Personnaliser
pour configurer ou consulter les raccourcis clavier utilisés par l’audit de
code dans la boîte de dialogue Editeur d’affectation de touches. L’éditeur
d’affectation de touches est en lecture seule dans JBuilder Personnel. Voir
Aide|Affectations du clavier pour une liste complète des affectations de
touches.
Options générales
• Afficher les messages d’erreur
Si cette option est activée et que l’affichage de l’audit de membre ou
l’audit de paramètre ne peut pas apparaître à cause d’erreurs de
compilation, l’audit de code développe le nœud d’erreur dans le volet
structure pour afficher les erreurs. En outre, dans certains cas, lorsque
des informations supplémentaires sont disponibles, la barre d’état
principale affiche un message court, tel que “Impossible de déterminer
le type d’expression”. Par défaut, cette option est désactivée.

Options de l’audit de membre

Ces options contrôlent la manière dont Audit de code affiche Audit de
membre, la liste des méthodes et données membres accessibles pour le
contexte actuel.
• Compléter automatiquement à l’invocation
Lorsque vous appelez l’audit de membre, s’il n’existe qu’une seule
correspondance possible dans la liste, elle est automatiquement
acceptée et entrée dans le code. La liste surgissante n’apparaîtra pas.
Vous n’avez pas besoin d’appuyer sur Entrée pour valider la sélection.
Pour désactiver cette fonction, supprimez la coche de la case Compléter
automatiquement à l’invocation. Par défaut, cette option est active.
• Compléter automatiquement en tapant
Lorsque cette option est sélectionnée, le code est complété
automatiquement à votre place jusqu’à ce qu’une correspondance soit
trouvée. Cette fonction est désactivée par défaut. Si l’option Affichage
automatique de l’audit de membre est désactivée, cette option l’est
également.
• Inclure les classes
Affiche les noms des classes dans la fenêtre Audit de membre. Par
défaut, cette option est active.
• Inclure les membres désapprouvés
Détermine si les méthodes désapprouvées apparaissent dans la liste.
Par défaut, cette option est active.
• Afficher le contexte de classe
Affiche le nom de la classe en haut de la fenêtre surgissante. Par défaut,
cette option est active.
Options de l’audit de paramètre

Ces options contrôlent la façon dont l’audit de code affiche l’audit de
paramètre, c’est-à-dire la liste des paramètres attendus par la méthode en
train d’être codée.
• Inclure les méthodes désapprouvées
Détermine si les méthodes désapprouvées apparaissent dans la fenêtre
de l’audit de paramètre. Par défaut, cette option est active.
• Afficher le contexte de classe
Affiche le nom de la classe en haut de la fenêtre surgissante. Par défaut,
cette option est active.

Bouton Options d’affichage

Les options d’affichage contrôlent des options de l’audit de code comme
la couleur, la fonte et la taille de la fonte. Pour personnaliser l’affichage de
l’audit de code, appuyez sur le bouton Options d’affichage de la page
Options de l’éditeur|Audit de code afin d’ouvrir la boîte de dialogue
Options d’affichage Audit de code.
Page Audit de membre

La page Audit de membre configure la façon dont l’audit de code affiche la
liste des méthodes et des données membres accessibles selon le contexte.
La page Audit de membre dispose des options suivantes :

• Afficher les types d’entrée comme des icônes
Affiche le type de la donnée membre accessible sous forme d’une icône.
Par défaut, cette option est active.
• Barrer les caractères des membres désapprouvés
Barre les données membres ou les méthodes qui ont été désapprouvées.
Remarquez que les membres désapprouvés n’apparaissent que si la
case Inclure les membres désapprouvés a été cochée dans la page
Outils|Options de l’éditeur|Audit de code. Par défaut, cette option est
active.
• Utiliser une fonte et des couleurs personnalisées
Vous permet de définir une fonte et des couleurs personnalisées pour
l’affichage. Par défaut, cette option est désactivée.
La fonte dans laquelle afficher les entrées de la fenêtre Audit de
membre.

• Taille de fonte
La taille du texte en points.
• Texte
La couleur du texte.
• Fond
La couleur du fond.
• Texte sélectionné
La couleur du texte de l’entrée sélectionnée dans la fenêtre Audit de
membre.
• Fond sélectionné
La couleur du fond de l’entrée sélectionnée dans la fenêtre Audit de
membre.
• Exemple
Affiche les paramètres sélectionnés dans une liste.
Page Audit de paramètre

La page Audit de paramètre configure la façon dont l’audit de code
affiche la liste des paramètres attendus par la méthode en cours.
La page Audit de paramètre dispose des options suivantes :
• Barrer les caractères des méthodes désapprouvées
Barre les méthodes de données qui ont été désapprouvées. Remarquez
que les méthodes désapprouvées n’apparaissent que si la case Inclure
les méthodes désapprouvées a été cochée dans la page Outils|Options
de l’éditeur|Audit de code. Par défaut, cette option est active.
• Utiliser une fonte et des couleurs personnalisées
Vous permet de définir une fonte et des couleurs personnalisées pour
l’affichage. Par défaut, cette option est désactivée.
La fonte dans laquelle afficher les entrées de la liste des paramètres.
• Taille de fonte
La taille du texte en points.
• Texte
La couleur du texte.
• Fond
La couleur du fond.

• Exemple
Affiche les paramètres sélectionnés dans une liste.
Options des modèles

L’ajout, la modification Utilisez la page Options de l’éditeur|Modèles pour créer et modifier des
et la suppression modèles pour les éléments de code fréquemment utilisés.
de modèles est
une fonctionnalité
de JBuilder Professionnel
Les modèles de code
sont accessibles en
lecture seule dans
JBuilder Personnel.
• Modèles
Les modèles de code existants. Choisissez un modèle pour voir son
développement dans la boîte Code, en bas de la boîte de dialogue.
• Code
Le code contenu dans le modèle.
Utilisez le caractère pipe (|) pour indiquer la position du curseur une
fois que le modèle est développé. Utilisez ‘\|’ pour entrer littéralement
le caractère pipe.
Dans l’exemple de modèle de code suivant, le curseur se déplace entre
les parenthèses quand le modèle est développé :
if (|) {
}
else {

• Ajouter
L’ajout de modèles est Affiche la boîte de dialogue Ajout d’un modèle de code dans laquelle
une fonctionnalité de vous entrez le nom et la description du nouveau modèle de code.
JBuilder Professionnel et
de JBuilder Entreprise.
Quand vous ajoutez un nouveau modèle, il s’insère dans la liste
Les modèles de code Modèles, dans l’ordre alphabétique. Cliquez sur OK pour revenir à la
sont accessibles en page Modèles. Tapez le code du modèle dans la zone d’édition de texte
lecture seule dans Code, puis cliquez sur OK.
JBuilder Personnel.
Important Lorsque vous créez ou modifiez des modèles, JBuilder ne les formate
pas selon les préférences. Vous devez définir manuellement les
accolades et les indentations.
• Modifier
La modification de Affiche la boîte de dialogue Modification du modèle de code dans
modèles est une laquelle vous pouvez modifier le nom et la description du modèle de
fonctionnalité de JBuilder code sélectionné. Pour l’utiliser,
Professionnel et de
JBuilder Entreprise. Les 1 Sélectionnez un modèle puis cliquez sur le bouton Modifier afin
modèles de code sont d’accéder à la boîte de dialogue Modification du modèle de code.
accessibles en lecture 2 Modifier le nom du modèle et sa description.
seule dans JBuilder
Personnel. 3 Cliquez sur OK pour revenir à la page Modèles.
4 Modifiez le code du modèle dans la zone d’édition de texte Code de
la page Modèles.
5 Cliquez sur OK pour fermer la boîte de dialogue Options de
l’éditeur.
Important Lorsque vous créez ou modifiez des modèles, JBuilder ne les formate
pas selon les préférences. Vous devez définir manuellement les
accolades et les indentations.
La suppression de • Supprimer
modèles est une
Supprime le modèle sélectionné.
fonctionnalité de JBuilder
Professionnel et de
JBuilder Entreprise. Les
modèles de code sont
accessibles en lecture
seule dans JBuilder
Personnel.

Options de la structure Java

Vous pouvez contrôler l’organisation de vos fichiers dans le volet
structure en sélectionnant la page Structure Java dans la boîte de dialogue
Options de l’éditeur. Vous pouvez également cliquer avec le bouton droit
dans le volet structure et sélectionner Propriétés.
• Délai d’analyse
Utilisez la glissière Délai d’analyse pour spécifier la fréquence avec
laquelle JBuilder analyse le code et enregistre une modification dans le
volet structure. Si vous travaillez sur des fichiers volumineux, nous
vous conseillons d’augmenter le délai d’analyse. La valeur par défaut
est 750 ms.
• Ordre de structure
Ces options de menu ne s’excluent pas mutuellement et vous pouvez
en choisir n’importe quelle combinaison. Si aucune option n’est
sélectionnée, les éléments de structure figurent dans le volet structure
dans le même ordre que dans le code source. Choisissez une, toutes ou
aucune de ces options :
• Grouper par visibilité : Regroupe les éléments de structure selon leur
visibilité. Les éléments publics sont les premiers, suivis des éléments
protégés, puis des éléments privés. Par défaut, cette option est
active.
• Séparer les classes / méthodes / champs : Les classes apparaissent
d’abord dans le volet structure, suivies des méthodes, elles-mêmes
suivies par les champs du fichier source Java. Par défaut, cette option
est active.
• Trier par ordre alphabétique : Trie les éléments de structure dans
l’ordre alphabétique. Par défaut, cette option est active.

Personnalisation de l’EDI de JBuilder

Utilisez la boîte de dialogue Options de l’EDI pour personnaliser l’EDI de
JBuilder (environnement de développement intégré). Pour ouvrir cette
boîte de dialogue, choisissez Outils|Options de l’EDI dans le menu
principal.
La boîte de dialogue Options de l’EDI contient les pages suivantes, en
fonction de l’édition de JBuilder que vous utilisez :
• Options du navigateur
• Options Types de fichiers
• Options Web
• Options XML
• Options Exécuter/Déboguer
• Options Audio
• Options UML
• Options du concepteur EJB
Remarque Pour revenir aux options en vigueur lors de l’activation de la boîte de
dialogue, cliquez sur le bouton Réinitialiser.
Pour des informations sur la modification de l’environnement d’édition,
voir “Personnalisation de l’éditeur”, page 5-37.
Options du navigateur
Utilisez la page Navigateur de la boîte de dialogue Options de l’EDI pour
configurer l’AppBrowser de JBuilder. Pour ouvrir la page Navigateur,
choisissez Outils|Options de l’EDI puis cliquez sur l’onglet Navigateur.

La page Navigateur de la boîte de dialogue Options de l’EDI contrôle ce

qui suit :
• Apparence
Définit l’apparence de l’EDI de JBuilder.
• Affectation clavier
Définit les définitions de touches pour l’éditeur et les menus de l’EDI.
Pour la liste complète des définitions de touches, voir “Emulation
d’éditeurs par affectations des touches” dans le menu Aide.
• Personnaliser
Affiche la boîte de dialogue Editeur d’affectation de touches dans
laquelle vous pouvez personnaliser vos affectations de touches pour
l’affectation sélectionnée. L’éditeur d’affectation de touches est en
lecture seule dans JBuilder Personnel.
• Onglets du volet contenu
Vous pouvez modifier l’orientation, le type de libellé et l’insertion des
onglets dans le volet contenu. Opérez votre choix parmi les options
suivantes :
• Orientation
• Horizontale : place les onglets horizontalement en haut du volet
contenu
• Verticale : place les onglets verticalement à droite du volet
contenu
• Type de libellé
• Icône et nom de fichier court
• Nom : nom de fichier avec extension
• Nom de fichier court : nom de fichier sans extension
• Icône seule
• Insertions
La sélection Insertions contrôle l’endroit où sont ajoutés les
nouveaux onglets dans le volet contenu. La valeur par défaut de
l’insertion des onglets est Trier par ordre alphabétique. Faites votre
choix parmi les options suivantes.
• Trier par ordre alphabétique : positionne les onglets dans l’ordre
alphabétique.
• Trier par ordre d’affichage : positionne les onglets dans le même
ordre que dans le volet projet. Par exemple, les onglets des nœuds
de paquets et les autres nœuds de faible poids sont classés au
début du contrôle à onglets.

• Insérer au début : insère tout nouveau fichier en tant que premier

onglet.
• Insérer à gauche de l’onglet pour le nœud actif : insère tout
nouveau fichier à gauche de l’onglet en cours de sélection.
• Insérer à droite de l’onglet pour le nœud actif : insère tout
nouveau fichier à droite de l’onglet en cours de sélection.
• Insérer à la fin : insère tout nouveau fichier en tant que dernier
onglet.
• Couleur du texte d’erreur
Définit la couleur des messages ou des conditions d’erreur du
compilateur qui ne sont pas des avertissements, et la couleur sur
l’onglet Méthodes dans BeansExpress. Choisissez la flèche déroulante
pour ouvrir la palette. Choisissez une des couleurs standard, ou cliquez
avec le bouton droit sur la palette vide située à droite des couleurs
standard pour créer une couleur personnalisée.
Options Types de fichiers

Utilisez la page Types de fichiers de la boîte de dialogue Options de l’EDI
pour personnaliser les types de fichiers reconnus par l’éditeur de JBuilder.
Pour ouvrir la page Types de fichiers, choisissez Outils|Options de l’EDI,
puis cliquez sur l’onglet Types de fichiers.
La page Types de fichiers contrôle ce qui suit :

• Types de fichiers reconnus
Liste de types de fichiers reconnus par l’éditeur de JBuilder. Lorsque
l’éditeur de JBuilder reconnaît un type de fichier, il l’ouvre.

• Extensions associées
Extensions de fichier associées au type de fichier sélectionné dans la
liste Types de fichiers reconnus.
• Ajouter
Affiche la boîte de dialogue de saisie qui vous permet d’ajouter une
extension de fichier à la liste Extensions associées correspondant au
type de fichier sélectionné. Notez que cela ne permet pas d’ajouter de
type de fichier à la liste Types de fichiers reconnus.
• Retirer
Retire de la liste le type de fichiers sélectionné.
Options Web
Fonctionnalité La page Web de la boîte de Propriétés de l’EDI définit les options Web.
de JBuilder Professionnel Pour afficher cette boîte de dialogue, choisissez Outils|Options de l’EDI
et de JBuilder Entreprise. puis cliquez sur l’onglet Web.
Ces options Web comprennent :

• Copier l’URL de lancement de l’exécution/débogage Web vers le
Presse-papiers
Copie l’URL utilisée pour lancer l’application web dans le
Presse-papiers. Cela vous permettra d’aller facilement à la même URL
dans un navigateur externe.
• Lancer un processus distinct et utiliser la vue Web
Affiche automatiquement votre servlet ou votre JSP dans la page Vue
Web du volet contenu et dans le navigateur web externe.

• Utiliser la vue Web pour les processus d’exécution si possible

Affiche automatiquement votre servlet ou JSP dans la page Vue Web
du volet contenu. Si un serveur web est déjà exécuté, JBuilder utilisera
le même processus sur le port existant. Il s’agit de l’option par défaut.
• Ne pas utiliser la vue Web ; toujours lancer un processus séparé
Lance toujours votre application web dans un navigateur web externe.
Options XML
Fonctionnalité La page XML de la boîte de dialogue Propriétés de l’EDI définit les
de JBuilder Professionnel options générales et les options de suivi des documents XML. Pour
et de JBuilder Entreprise. afficher cette boîte de dialogue, choisissez Outils|Options de l’EDI puis
cliquez sur l’onglet XML.
Ces options XML comprennent :

• Activer la vue du navigateur
Lorsque cette option est définie, vous pouvez voir le document XML
dans l’onglet Vue du volet contenu.
• Appliquer la feuille de style par défaut
Applique la feuille de style XSLT par défaut de JBuilder, une vue
arborescente, au document XML.
• Options de traçage de la transformation
Les options de suivi de la transformation vous permettent de voir la
séquence des transformations d’un document. Choisissez entre
Sélections, Modèles, Création, Eléments. Ces suivis s’affichent dans le

volet message sous forme d’une vue arborescente. Choisissez un suivi

pour mettre en évidence la ligne du source correspondante et
double-cliquez pour placer la focalisation du curseur dans l’éditeur.
Options Exécuter/Déboguer
Utilisez la page Exécuter/Déboguer de la boîte de dialogue Options de
l’EDI pour personnaliser les intervalles de mise à jour à l’exécution et au
débogage. Pour ouvrir la page Exécuter/Déboguer, choisissez Outils|
Options de l’EDI, puis cliquez sur l’onglet Exécuter/Déboguer.
La page Exécuter/Déboguer contrôle ce qui suit :

• Intervalles de mise à jour à l’exécution
Définit la durée des mises à jour à l’exécution sur la console.
• Intervalles de mise à jour du débogueur
Définit la durée des mises à jour au débogage sur la console.
Voir aussi
• “Personnalisation du débogueur” dans Construction d’applications avec
JBuilder.
Options Audio
La page Audio contrôle le feedback audio des divers événements de
JBuilder ; le feedback audio est actif par défaut. JBuilder fournit un thème
audio stocké dans le répertoire lib/audio/ de JBuilder. Vous pouvez

ajouter vos propres fichiers audio et les attachez à des événements

spécifiques. Pour ouvrir la page Audio, choisissez Outils|Options de
l’EDI puis cliquez sur l’onglet Audio.
Personnalisez le son en définissant ces options dans la boîte de dialogue

Options de l’EDI :
• Volume audio
Désactive ou active le son et règle le volume.
• Thème
Affiche une liste déroulante des thèmes audio. Choisissez le thème
audio par défaut de JBuilder ou sélectionnez un thème personnalisé.
• Evénements audio
Désactive ou active le son pour des événements particuliers.
• Jouer
Joue l’événement audio sélectionné.
Pour ajouter des fichiers audio personnalisés à JBuilder,
1 Créez un fichier audio .wav 16 bits pour chaque événement.
2 Nommez chaque fichier d’après l’événement qu’il lui est associé :
• erreurs_build.wav
• succès_build.wav
• avertissements_build.wav
• exception.wav
• échec_recherche.wav
• recherche_dans_chemin.wav

• processus_stoppé.wav
• stop_point_arrêt.wav
3 Archivez les fichiers dans une archive ZIP, compressée ou non.
4 Nommez le fichier d’archive en utilisant l’extension .audiopak.
5 Enregistrez l’archive dans le répertoire lib/audio/ de l’installation de
JBuilder.
6 Redémarrez JBuilder s’il est alors en cours d’exécution pour faire
apparaître le nouveau thème dans la liste déroulante.
Remarque Les fichiers .wav doivent utiliser l’échantillonnage 16 bits.
Options UML
Fonctionnalité Utilisez la page UML de la boîte de dialogue Options de l’EDI pour
de JBuilder Entreprise. configurer l’affichage des diagrammes UML dans le navigateur UML de
JBuilder. Vous pouvez contrôler des options comme le tri, la fonte et sa
taille, ou la couleur du texte, des flèches et du fond. Pour ouvrir la page
UML, choisissez Outils|Options de l’EDI puis cliquez sur l’onglet UML.
• Utiliser les icônes visibles

Affiche les icônes de l’AppBrowser de JBuilder dans le diagramme
UML. Ce sont les icônes qui sont affichées dans le volet structure
lorsqu’un fichier source est ouvert dans l’éditeur. Pour connaître les
définitions des icônes de JBuilder, voir Chapitre 5, “L’environnement
de JBuilder”. Lorsque cette option est désactivée, ce sont les icônes de
visibilité UML standard qui sont utilisées. Voir “Icônes de visibilité” de
la rubrique “Visualisation du code avec UML” dans Construction

• Grouper par visibilité

Dans le diagramme UML, les éléments sont regroupés du plus visible
au moins visible. De ce fait, les éléments public sont suivis des éléments
protected, eux-mêmes suivis des éléments private.
• Trier par ordre alphabétique
Les éléments, tels que les noms des classes, des champs et des
méthodes, sont classés dans l’ordre alphabétique dans le diagramme
UML.
• Afficher les propriétés séparément
Affiche séparément dans le diagramme UML toutes variables de classe
possédant des getters et/ou des setters.
Sélectionnez un type de fonte pour le diagramme UML parmi les fontes
écran installées sur votre système et présentées dans la liste. L’éditeur
affiche et utilise uniquement des fontes à espacement fixe, comme
Courier.
• Taille de fonte
Sélectionnez une taille de fonte pour le diagramme UML parmi les
tailles prédéfinies associées à la fonte sélectionnée dans la boîte liste
Famille de fonte.
Choisissez un élément UML dans la liste Elément d’écran et
sélectionnez une nouvelle couleur pour modifier la couleur affichée par
défaut dans le visualiseur UML. Sélectionnez une couleur standard ou
personnalisée à droite de la liste Elément.
• Couleur
Affiche la couleur, standard ou personnalisée, qui a été sélectionnée.
Sélectionnez une couleur dans la palette, ou choisissez le bouton
Couleur personnalisée puis choisissez ou créez une couleur
personnalisée.
Options du concepteur EJB

Fonctionnalité Utilisez la page Concepteur EJB de la boîte de dialogue Options de l’EDI
de JBuilder Entreprise. pour configurer l’affichage général du concepteur EJB. Vous pouvez
contrôler des options comme la fonte et sa taille, ou la couleur du texte,
des bordures et du fond. Pour ouvrir la page Concepteur EJB, choisissez
Outils|Options de l’EDI puis cliquez sur l’onglet Concepteur EJB.

Sélectionnez un type de fonte pour le concepteur EJB parmi les fontes
écran installées sur votre système et présentées dans la liste. L’éditeur
affiche et utilise uniquement des fontes à espacement fixe, comme
Courier.
• Taille de fonte
Sélectionnez une taille de fonte pour le concepteur EJB parmi les tailles
prédéfinies associées à la fonte sélectionnée dans la boîte liste Famille
de fonte.
Choisissez un élément EJB dans la liste Elément d’écran et sélectionnez
une nouvelle couleur pour modifier la couleur affichée par défaut dans
le concepteur EJB. Sélectionnez une couleur standard ou personnalisée
à droite de la liste Elément.
• Couleur
Affiche la couleur, standard ou personnalisée, qui a été sélectionnée.
Sélectionnez une couleur dans la palette, ou choisissez le bouton
Couleur personnalisée puis choisissez ou créez une couleur
personnalisée.

Chapitre
Développement automatique
Chapitre6
6
du code
JBuilder offre divers outils destinés à augmenter la rapidité du
développement de votre code : les outils de conception visuelle pour créer
rapidement vos interfaces utilisateur et des experts pour générer le code
automatiquement. Les outils de conception visuelle comprennent un
concepteur d’interface utilisateur, un concepteur de menu et un
concepteur de colonne ; ces outils sont accessibles dans la page
Conception du volet contenu. De nombreux experts sont disponibles à
partir de la galerie d’objets (Fichier|Nouveau) et du menu Experts.
Utilisation des outils de conception visuelle

Les outils de conception visuelle de JBuilder se composent d’une palette
de composants, d’un inspecteur, de plusieurs concepteurs et d’une
arborescence des composants. Pour accéder aux outils de conception, vous
devez ouvrir un fichier source dans le volet contenu, puis cliquer sur
l’onglet Conception. Le concepteur permet de créer visuellement les
fichiers qui héritent de java.awt.Container.
Développement automatique du code 6-1

Utilisation des outils de conception visuelle
Figure 6.1 JBuilder en vue conception
Trois concepteurs partagent la surface de conception sur la page

Conception du volet contenu : le concepteur d’interface utilisateur, le
concepteur de menu et le concepteur de colonne.
Le concepteur d’interface utilisateur est utilisé dans l’assemblage des
composants visuels de l’interface utilisateur. La première fois que vous
cliquez sur l’onglet Conception après avoir ouvert un fichier dans le volet
contenu, JBuilder affiche le concepteur d’interface utilisateur par défaut.
Les composants de l’interface utilisateur apparaissent dans le dossier
Interface utilisateur de l’arborescence des composants.
Le concepteur de menu permet de créer des menus. Les composants de
menu apparaissent dans le dossier Menu de l’arborescence des composants.
Le concepteur Le concepteur de colonne vous permet d’exploiter visuellement des
de colonne est composants ensemble de données. Les composants ensemble de données
une fonctionnalité apparaissent dans le dossier Accès aux données de l’arborescence des
de JBuilder Professionnel composants.

Utilisation de la galerie d’objets
Voir aussi
• “Construction d’une interface utilisateur” dans Conception d’interfaces
utilisateur avec JBuilder
• “Gestion de la palette des composants” dans Conception d’interfaces
utilisateur avec JBuilder
• “Conception des menus” dans Conception d’interfaces utilisateur avec
JBuilder
• “Tutoriel : Création d’une colonne calculée dans le concepteur” dans le
Guide du développeur d’applications bases de données
• “Restructuration du StorageDataSet d’un JDataStore” dans le Guide du
développeur JDataStore
Utilisation de la galerie d’objets

La galerie d’objets vous donne accès aux experts que vous pouvez utiliser
pour créer le squelette d’instances de nombreux objets.
Pour utiliser un expert de la galerie d’objets, choisissez Fichier|Nouveau

pour ouvrir cette dernière. Sélectionnez l’icône d’un expert, puis cliquez
sur OK. JBuilder ouvre l’expert associé et crée le squelette du code dans
un fichier .java qu’il ajoute à votre projet.
Les experts qui sont estompés dans la galerie d’objets sont désactivés.
Certains experts ne deviennent accessibles qu’après la création ou
l’ouverture d’un projet ou d’un type spécifique de fichier. Egalement, les
experts peuvent être désactivés s’ils ne sont pas disponibles dans telle
édition de JBuilder. Les experts varient d’une édition de JBuilder à l’autre.
Important Certains experts, comme les experts des pages CORBA et Entreprise,
nécessitent un recensement ou une configuration spéciale avant de
pouvoir être activés.

Utilisation des experts pour un démarrage rapide

Les experts de JBuilder permettent d’économiser du temps car ils écrivent
une partie du code à votre place. Vous pouvez y accéder à partir de
plusieurs menus :
• Le menu Fichier|Nouveau, qui ouvre la galerie d’objets
• Menu Experts
• Menu Outils
Les experts disponibles dans la galerie d’objets servent à créer de
nouveaux objets, alors que les autres experts sont utilisés pour travailler
sur des objets existants.
Les tableaux suivants décrivent chacun des experts de JBuilder. Pour plus
d’informations sur un expert particulier, ouvrez-le et cliquez sur le bouton
Aide ou appuyez sur F1.
Tableau 6.1 Galerie d’objets/Page Nouveau (Fichier|Nouveau)

Expert Edition 1 Description
Application Toutes Crée le squelette d’une nouvelle application Java
contenant un cadre (frame).
Applet Toutes Un type d’application Java spécialisé pouvant être
téléchargé par un navigateur client et exécuté sur la
machine client. Dans JBuilder Professionnel et
JBuilder Entreprise, l’expert Applet se trouve sur la
page Web.
Constructeur P, E Crée un fichier archive .jar ou .zip de tous les fichiers
d’archives du projet spécifiés et de leurs dépendances.
Expert Javadoc P, E Crée la sortie Javadoc à partir des commentaires
contenus dans vos fichiers source API.
Classe Toutes Crée une nouvelle classe dans votre projet.
Interface P, E Crée une nouvelle interface.
JavaBean P, E Crée un JavaBean prêt à être personnalisé avec
BeansExpress.
Dialogue P, E Crée une nouvelle classe dialogue dans votre projet.
Cadre P, E Crée une nouvelle classe cadre dans votre projet.
Panneau P, E Crée une nouvelle classe panneau dans votre projet.
Module de P, E Crée un nouveau module de données, fichier dans
données lequel vous placez les composants non visuels de
connexion aux données.
Application P, E Crée une application 2-niveaux depuis un module
Module de de données (crée à la fois le client et le serveur d’une
données application de base de données sans CORBA).
1. Clé : Edition de JBuilder

Toutes = Toutes les éditions de JBuilder
P = JBuilder Professionnel
E = JBuilder Entreprise

Tableau 6.2 Galerie d’objets/Page Projet (Fichier|Nouveau)

Expert Edition 1 Description
Projet Toutes Crée un nouveau projet.
Importer un P, E Importe un projet existant.
projet
Extraire le projet E Configure la connexion du projet à CVS et copie un
de CVS module du référentiel dans votre espace de travail.
Extraire le projet E Définit la connexion du projet à Visual SourceSafe et
de VSS copie un projet de la base de données dans votre
espace de travail.
Extraire le projet E Définit les propriétés du projet en relation avec
de ClearCase ClearCase et monte un VOB en utilisant la vue de
votre choix.

Tableau 6.3 Galerie d’objets/Page Web (Fichier|Nouveau)

Expert Edition1 Description
Applet Toutes Un type d’application Java spécialisé pouvant être
téléchargé par un navigateur client et exécuté sur la
machine client. Dans JBuilder Personnel, l’expert
Applet se trouve sur la page Nouveau.
Application Web P, E Crée une nouvelle WebApp. Une WebApp décrit la
structure d’une application web. C’est
essentiellement une arborescence de répertoires
renfermant le contenu web utilisé dans votre
application. Elle correspond à un ServletContext.
Servlet P, E Crée un fichier Java étendant
javax.servlet.http.HttpServlet.
Page JavaServer P, E L’expert JSP génère le squelette d’une JSP (page
JavaServer).
Lanceur de P, E Génère un fichier JNLP et une page d’accueil HTML
démarrage Web pour votre application.


Tableau 6.4 Galerie d’objets/Page XML (Fichier|Nouveau)

Application Web P, E Crée une application web Cocoon.
Cocoon
Liaison de E Génère une classe Java à partir d’un DTD ou d’un
données document XSD.
DTD vers XML P, E Crée un document XML à partir d’un DTD.
XML vers DTD P, E Crée un DTD à partir d’un document XML.
XML-DBMS E Génère des fichiers Map et SQL à partir d’un DTD.
Gestionnaire SAX E Crée un modèle d’implémentation d’un analyseur
SAX qui inclue les méthodes d’analyse des
documents XML.

Tableau 6.5 Galerie d’objets/Page CORBA (Fichier|Nouveau)

Exemple IDL E Crée un fichier IDL simple dans votre projet.
Interface Client E Crée un client CORBA Java qui accède à l’interface
CORBA du serveur CORBA spécifié.
Interface serveur E Crée un objet interface serveur CORBA à partir d’un
CORBA fichier IDL.
Client CORBA E Crée une application client CORBA HTML à partir
HTML d’un fichier IDL.
Application E Crée une application serveur CORBA à partir d’un
Serveur CORBA fichier IDL.

Tableau 6.6 Galerie d’objets/Page Entreprise (Fichier|Nouveau)

Module EJB E Crée un nouveau module EJB auquel vous pouvez
ajouter vos enterprise beans. Un module EJB est un
regroupement logique d’enterprise beans que vous
envisagez de déployer en un seul fichier .jar.
Module EJB E Crée un module EJB qui contient les descripteurs de
depuis déploiement des enterprise beans existants.
descripteurs
Enterprise E Crée un composant Enterprise JavaBean.
JavaBean 1.x

Tableau 6.6 Galerie d’objets/Page Entreprise (Fichier|Nouveau) (suite)

Modeleur Bean E Crée un ou plusieurs enterprise beans entité à partir
entité EJB 1.x de tables de base de données existantes.
Concepteur de E Vous permet de sélectionner un module EJB ou d’en
Bean EJB 2.0 créer un si nécessaire, affiche le concepteur EJB où
vous pouvez concevoir de manière visuelle vos
composants EJB 2.0.
Client test EJB E Crée une application client simple pour tester le
fonctionnement d’un enterprise bean.
EAR E Crée un fichier EAR (Enterprise ARchive).
JMS E Crée une classe Java incluant le code de support de la
classe qui produit et utilise des messages dans un
système JMS (Java Message Service).

Tableau 6.7 Galerie d’objets/Page Test (Fichier|Nouveau)

Cas de test E Crée des classes de test qui étendent
junit.framework.TestCase et contiennent des méthodes
squelette permettant de mettre en œuvre les
méthodes de la classe testée.
Suite de test E Crée une suite de tests groupant les cas de test afin
de les exécuter par lot.
Fixture JDBC E Crée une Fixture JDBC que les tests de votre unité
peuvent utiliser pour gérer les connexions JDBC.
Fixture JNDI E Crée une Fixture JNDI que les tests de votre unité
peuvent utiliser pour effectuer des recherches JNDI.
Fixture de E Crée une Fixture de comparaison pouvant servir à
comparaison enregistrer les sorties des tests pour les comparer
aux sorties des tests antérieurs.
Fixture E Crée le squelette d’une fixture test contenant les
personnalisée méthodes setUp() et tearDown().


Tableau 6.8 Menu Experts

Constructeur P, E Crée un fichier archive .jar ou .zip de tous les
d’archives fichiers du projet spécifiés et de leurs dépendances.
Expert Javadoc P, E Crée la sortie Javadoc à partir des commentaires
contenus dans vos fichiers source API.
Implémenter P, E Crée le squelette du code qui indique aux autres
l’interface objets qu’ils peuvent accéder à la classe sélectionnée
via une certaine interface Java.
Remplacer les P, E Crée le squelette du code qui redéfinit une méthode
méthodes dans une superclasse.
EJB|Créateur E Crée une interface locale et une interface distante
d’interface EJB 1.x pour une classe enterprise bean EJB 1.x existante.
EJB|Créateur de E Crée une classe bean EJB 1.x et une interface locale à
bean EJB 1.x partir d’une interface distante existante.
EJB|Utiliser client E Définit une instance d’un client test spécifié dans la
Test EJB classe active, dans l’éditeur de code.
Utiliser un P, E Utilise un composant module de données existant.
module de
données
Utiliser l’interface E Crée une interface serveur CORBA.
CORBA
Chaînes de P, E Crée un fichier bundle de ressource à des fins de
ressource localisation.

Tableau 6.9 Menu Outils

Expert Nouvelle Toutes Définit une nouvelle bibliothèque. Sélectionnez
bibliothèque Outils|Configurer les bibliothèques et appuyez sur
le bouton Nouveau pour ouvrir l’expert nouvelle
bibliothèque.
Expert Nouveau P, E Définit un nouveau JDK. Sélectionnez Outils|
JDK Configurer les JDK et appuyez sur le bouton
Nouveau pour ouvrir l’expert nouveau JDK.
Expert Génération E Génère des stubs client pour des applications
de stub non-containeur. Sélectionnez Outils|Créer une JAR
de client EJB pour ouvrir l’expert Génération de stub.
Expert E Déploie des modules EJB dans un conteneur en train
Déploiement EJB de s’exécuter.


Chapitre
Création et gestion des projets

Chapitre7
7
Tout le travail de JBuilder s’effectue dans la cadre d’un projet. Dans cette
documentation, le terme “projet” inclut tous les fichiers composant un
travail défini par l’utilisateur, la structure des répertoires contenant ces
fichiers, ainsi que les chemins d’accès, les paramètres et les ressources
nécessaires.
Le projet est un outil d’organisation et non un référentiel. Cela signifie que
les fichiers d’un projet peuvent appartenir à n’importe quel dossier.
La restructuration de l’arborescence d’un projet est sans effet sur
l’arborescence des répertoires. Vous contrôlez donc les projets et la
structure des répertoires de manière indépendante.
Chaque projet est administré par un fichier projet (de type .jpr ou .jpx).
Le fichier projet contient la liste des fichiers du projet et maintient les
propriétés de celui-ci, dont le modèle du projet, les chemins par défaut, les
bibliothèques de classes et les configurations de connexion. JBuilder
utilise ces informations lorsque vous chargez, enregistrez, construisez ou
exécutez le projet. Les fichiers projet sont modifiés chaque fois que vous
utilisez l’environnement de développement de JBuilder pour ajouter ou
supprimer des fichiers ou pour définir ou modifier les propriétés du
projet. Le fichier projet se présente sous la forme d’un nœud, dans le volet
Projet. Vous trouverez ci-dessous les différents paquets et fichiers
pouvant constituer un projet.
Remarque Si les paquets source sont activés automatiquement, les nœuds de paquet
source apparaissent aussi dans le volet projet. Ils affichent les fichiers et
les paquets se trouvant dans le chemin source du projet. Voir “Paquets
source automatiques” dans Construction d’applications avec JBuilder.
Vous pouvez inclure n’importe quel type de fichier dans un projet
JBuilder, mais JBuilder en reconnaît certains automatiquement, pour
lesquels il propose une vue adaptée.
Création et gestion des projets 7-1

Création d’un nouveau projet
Fonctionnalité Vous pouvez ajouter des types de fichiers binaires, personnaliser la

de JBuilder Professionnel gestion des types de fichiers et visualiser les icônes associées aux types de
et de JBuilder Entreprise. fichiers en sélectionnant Outils|Options de l’EDI et en choisissant l’onglet
Types de fichiers.
Les deux types de fichier projet de JBuilder sont équivalents sauf sur le
point important suivant : le type JPX a été conçu pour servir aux projets
partagés. C’est un type de fichier XML facile à gérer dans un
environnement de développement en équipes.

Pour démarrer un nouveau projet, utilisez l’expert projet de JBuilder afin
de générer automatiquement un cadre de travail pour les fichiers,
répertoires, chemins et préférences. L’expert projet peut créer
automatiquement à votre place le fichier des notes du projet où seront
insérés annotations et commentaires. Les champs Javadoc classe qui sont
remplis dans l’expert projet servent au fichier des notes du projet, comme
les commentaires d’en-tête Javadoc lorsque vous utilisez les experts de
JBuilder pour créer les fichiers Java et, en conséquence, inclus dans la
documentation générée par Javadoc. Ces commentaires peuvent être
modifiés sur la page Général des Propriétés du projet.
Lors de l’utilisation de nombreux experts de JBuilder, si aucun projet n’est
ouvert, l’expert projet est chargé en premier pour vous permettre de créer
un nouveau projet.
Création d’un nouveau projet en utilisant l’expert projet

L’expert projet définit les paramètres par défaut d’un nouveau projet.
Pour importer un projet existant, utilisez l’expert Importation de projet,
une fonctionnalité de JBuilder Professionnel et de JBuilder Entreprise.
Voir “Importation d’un projet existant”, page 7-8.
Avertissement L’expert projet sert à créer de nouveaux projets, et non à importer des
projets existants. Si vous essayez de l’utiliser pour importer des projets
existants, sachez que la structure de votre projet risque de poser problème
dans JBuilder.
Pour créer un nouveau projet à l’aide de l’expert projet, sélectionnez
Fichier|Nouveau projet. Vous pouvez également choisir Fichier|
Nouveau, sélectionner l’onglet Projet et double-cliquer sur l’icône Projet.
L’expert projet s’affiche.
Etape 1 : Sélection du nom et du modèle du projet

L’étape 1 permet de définir le nom, le type, le répertoire racine et le
modèle de votre projet.

Le modèle du projet fournit des valeurs par défaut aux paramètres

figurant dans la boîte de dialogue Propriétés du projet (Projet|Propriétés
du projet). Si vous possédez déjà un projet dont les propriétés se
rapprochent de celles qu’exige le nouveau projet, sélectionnez-le ici. Cela
réduit au minimum le travail répétitif nécessaire à la configuration d’un
nouveau projet pour un environnement déterminé.
1 Entrez le nom du nouveau projet.

JBuilder utilise le nom du projet comme nom par défaut du paquet.
2 Sélectionnez le type de fichier du projet : .jpx ou .jpr.
Le type .jpx est destiné aux projets partagés. Outre ce fait, les deux
types sont équivalents.
3 Sélectionnez le répertoire parent du projet. La valeur par défaut est
<home>\jbproject\<nomprojet>. Le répertoire <home> dépend de la
plate-forme utilisée. Par exemple, pour Windows 98, <home> sera C:\
Windows. Voir “Conventions utilisées par la documentation” dans l’aide
en ligne. De nombreux autres chemins du projet, comme le chemin
d’accès aux sources ou le chemin de sauvegarde, dépendent par défaut
de ce répertoire.
• Cliquez sur la flèche vers le bas pour sélectionner comme parent un
répertoire utilisé au préalable ou pour choisir un répertoire dans la
même arborescence que vous pouvez modifier.
• Vous pouvez modifier le champ directement ou cliquer sur le bouton
Points de suspension (…) pour naviguer jusqu’à un répertoire
existant.
Remarque Si vous saisissez un chemin dont la syntaxe est erronée, vous ne
pourrez pas continuer.

4 Sélectionnez un modèle de projet.

• Cliquez sur la flèche vers la bas pour choisir comme modèle un
projet utilisé au préalable.
• Cliquez sur le bouton Points de suspension (…) pour utiliser comme
modèle un autre projet via la boîte de dialogue Ouverture de projet.
5 Indiquez si vous voulez générer un fichier HTML pour les notes du
projet. L’information initiale de ce fichier est générée à partir des
champs Javadoc classe définis à l’étape 3 de l’expert projet.
6 Cliquez sur Suivant pour aller à l’étape 2.
Si le bouton Terminer est actif, vous pouvez l’utiliser pour accepter les
valeurs par défaut pour la suite de l’expert et créer le projet
immédiatement.
Etape 2 : Définition des chemins du projet

L’étape 2 définit tous les chemins d’accès pour le projet, y compris la
version du JDK pour laquelle vous compilerez. Ces paramètres peuvent
être modifiés ultérieurement sur la page Chemins de la boîte de dialogue
Propriétés du projet (Projet|Propriétés du projet).
1 Sélectionnez les chemins d’accès du projet : JDK, destination,

sauvegarde et répertoire de travail. Le chemin du répertoire de travail
est également appelé chemin du projet, puisque il amène au répertoire
parent du projet. Notez que le répertoire parent défini à l’étape 1 est
utilisé ici.
Pour modifier un de ces chemins, vous pouvez saisir directement le
nouveau chemin ou cliquer sur le bouton Points de suspension (…), en
face du champ, pour naviguer jusqu’au répertoire voulu.

Remarque Seuls les utilisateurs expérimentés peuvent modifier ces chemins par
défaut. Si vous saisissez un chemin dont la syntaxe est erronée, vous ne
pourrez pas continuer.
Voir aussi
• “Définition du JDK”, page 8-7
Les paramètres source, documentation et bibliothèques sont
disponibles dans des volets à onglets apparaissant sous les paramètres
des champs texte. Chaque page a des boutons qui vous permettent
d’ajouter de nouveaux chemins, de modifier ceux qui existent, d’en
supprimer de la liste et de changer l’ordre dans lequel ils apparaissent.
Modifier cet ordre risque d’améliorer les performances, puisque
JBuilder utilise généralement les chemins dans l’ordre défini ici.
2 Définissez les chemins des sources par défaut et de test sur la page
Source. Il est possible de choisir le même chemin pour les deux
circonstances.
Le test des unités Le chemin des sources par défaut est utilisé par les experts qui créent
est une fonctionnalité des fichiers source. Le chemin des sources de test est utilisé lorsque
de JBuilder Entreprise. vous mettez en œuvre les fonctionnalités de test des unités de JBuilder.
Cela permet d’utiliser une zone différente pour les tests et séparer
ceux-ci de votre code. Cela peut s’avérer très utile lors du déploiement.
Personnalisez les chemins d’accès aux sources en utilisant les boutons
figurant à droite :
• Cliquez sur Ajouter pour parcourir le chemin des sources que vous
voulez ajouter.
• Cliquez sur Modifier pour choisir un chemin de sources qui
remplacera le chemin en cours de sélection.
• Cliquez sur Retirer pour retirer le chemin sélectionné.
• Pour changer l’ordre des chemins dans la liste, cliquez sur les
boutons Vers le haut et Vers le bas.
Rajouter des chemins d’accès aux sources fait fonctionner le projet avec
plusieurs racines source. Notez que les importations sélectionnent
automatiquement tous les répertoires source comme racines source.
Remarque JBuilder utilise le chemin que vous définissez pour l’objectif que vous
désignez. Toutefois, si JBuilder ne trouve le chemin de sources spécifié,
il consultera la liste des chemins disponibles et les utilisera du premier
au dernier. Triez vos chemins d’accès de façon à contrôler celui qui sera
utilisé en premier dans un tel cas.

3 Définissez les chemins de la documentation dans la page

Documentation.
Utilisez les boutons situés à droite pour personnaliser cette
information.
4 Définissez les bibliothèques nécessaires dans la page Bibliothèques
nécessaires. Les bibliothèques sont un excellent moyen de gérer les
informations figurant dans des fichiers archive.
Utilisez les boutons situés à droite pour personnaliser cette liste.
Voir aussi
• “Définition des chemins d’accès aux bibliothèques nécessaires”,
page 8-11
• “Utilisation des bibliothèques”, page 8-1
Ou bien, si les valeurs par défaut de l’étape 3 vous conviennent, cliquez
sur Terminer à l’étape 2 pour créer le nouveau projet.
Etape 3 : Définition des propriétés générales du projet

L’étape 3 de l’expert projet inclut les paramètres généraux du projet,
comme l’encodage, les paquets source automatiques, les champs Javadoc
classe et les références aux bibliothèques du projet.
Cette information peut être modifiée ultérieurement sur la page Général
de la boîte de dialogue Propriétés du projet (Projet|Propriétés du projet).

1 Choisissez un encodage ou acceptez celui proposé par défaut.

L’encodage détermine la façon dont JBuilder gère les caractères au delà
du jeu ASCII. La valeur par défaut de cette option est l’encodeur par
défaut de votre plate-forme.
Voir aussi
• “Spécification d’un encodage natif pour le compilateur” au chapitre
“Internationalisation des programmes avec JBuilder”, dans
• “Outils d’internationalisation : native2ascii” à l’adresse http://
java.sun.com/products/jdk/1.3/docs/tooldocs/tools.html#intl
2 Sélectionnez les options Paquets source automatiques.
Fonctionnalité 1 L’option Activer automatiquement les paquets source est
de JBuilder Professionnel sélectionnée par défaut.
Lorsque l’option est active, voici ce qui se passe :
• Tous les paquets appartenant au chemin des sources du projet
apparaissent dans le volet projet (volet supérieur gauche) de
l’EDI.
• Les paquets contenant des fichiers Java sont compilés
automatiquement.
• Les fichiers générés par cette compilation sont copiés dans le
chemin de sortie du projet.
Tous les paquets ne sont pas affichés, seul apparaît un
sous-ensemble logique qui dépend du choix du niveau d’exposition
des paquets.
2 Sélectionnez le niveau d’exposition des paquets.
JBuilder expose les paquets au niveau que vous définissez et, sauf à
ajouter des niveaux supplémentaires à un paquet, la longueur de la
liste de paquets ne changera pas. Par exemple, si vous avez les trois
paquets suivants :
un.deux.trois.quatre
un.deux.trois.cinq
un.deux.quatre.six
et si vous définissez le niveau d’exposition des paquets par trois,
voici ce qui apparaît dans le volet projet :
un.deux.trois
un.deux.quatre.six
Les paquets un.deux.trois.quatre et un.deux.trois.cinq sont tous deux
contenus dans le paquet un.deux.trois, JBuilder ne représente donc
que le paquet parent et vous permet de développer le nœud du
paquet pour accéder aux paquets et aux fichiers qu’il renferme.

Importation d’un projet existant
Le paquet un.deux.quatre.six est exposé au niveau quatre car abréger

la représentation n’aurait pas raccourci la liste et il vaut mieux alors
que vous voyez ce que vous avez.
Voir aussi
• “Paquets”, page 8-13
3 Spécifiez les champs Javadoc classe. Ils peuvent être utilisés dans le
fichier des notes du projet et la boîte de dialogue Aide|A propos de
votre application, ou insérés comme commentaires d’en-tête JavaDoc
dans les fichiers générés par les experts pour votre projet.
Sélectionnez le champ que vous voulez modifier et saisissez le texte
approprié dans la colonne Texte.
Trouver les références 4 Cochez Inclure les références des fichiers classe de la bibliothèque du
est une fonctionnalité projet si vous voulez pouvoir retrouver les références localisées dans
de JBuilder Professionnel les bibliothèques du projet. La commande Trouver les références est
et de JBuilder Entreprise. accessible dans le menu contextuel de l’éditeur et vous permet de voir
tous les fichiers source utilisant un symbole particulier.
UML est 5 Choisissez également cette option si vous voulez que les diagrammes
une fonctionnalité UML de votre projet affichent les références issues des bibliothèques du
de JBuilder Entreprise. projet.
Voir aussi
• “Recherche des références à un symbole” dans “Refactoring avec
JBuilder”, de Construction d’applications avec JBuilder
• “Visualisation du code avec UML” dans Construction d’applications
avec JBuilder
6 Cliquez sur Terminer quand vous avez fini.
JBuilder vous ramène à l’EDI ; il contient le nouveau projet ouvert.
Les paramètres définis à l’étape 2 et à l’étape 3 peuvent être modifiés dans
la page Chemins et la page Général de la boîte de dialogue Propriétés du
projet (Projet|Propriétés du projet).

Fonctionnalité L’expert Importation de projet vous permet d’importer un projet existant,
de JBuilder Professionnel ou une arborescence de sources, dans un nouveau projet JBuilder. Lors de
et de JBuilder Entreprise. l’utilisation de cet expert, JBuilder explore le répertoire existant et
construit en conséquence les chemins qui seront utilisés pour la
compilation, la recherche, le débogage et autres processus. Tous les
fichiers JAR ou ZIP non reconnus par JBuilder sont placés dans une
bibliothèque et ajoutés au projet. Les bibliothèques du projet sont

énumérées dans l’onglet Bibliothèques nécessaires de la page Chemins de

la boîte de dialogue Propriétés du projet (Projet|Propriétés du projet).
Pour accéder à l’expert Importation de projet,
1 Sélectionnez Fichier|Nouveau. La galerie d’objets apparaît.
2 Sélectionnez l’onglet Projet.
3 Sélectionnez Importer un projet.
Double-cliquez ou cliquez sur OK pour activer l’expert.
Etape 1 : Sélection d’un répertoire source et d’un nom pour

votre nouveau projet JBuilder
L’étape 1 permet de définir le répertoire, le nom, le type et le modèle de
votre projet.
1 Choisissez le répertoire où se trouve le projet existant ou l’arborescence

source. Cliquez sur le bouton Points de suspension pour atteindre ce
répertoire. JBuilder recherche dans le répertoire sélectionné les fichiers
classe, source, JAR et ZIP, et les place dans les répertoires appropriés au
cœur de ce répertoire.
2 Entrez le nom du nouveau projet. JBuilder utilise le nom du projet
comme nom de paquet par défaut ; donc, si vous avez le nom d’un
paquet existant, utilisez-le comme nom de projet. Les experts de
JBuilder utilisent également le nom du projet comme nom de paquet ;
les experts permettent toutefois de modifier ce nom.
3 Sélectionnez le type de fichier du projet : .jpx ou .jpr.
Le type .jpx est destiné aux projets partagés. Outre ce fait, les deux
types sont équivalents.

Affichage des fichiers d’un projet
4 Sélectionnez un modèle de projet.

• Cliquez sur la flèche vers la bas pour choisir comme modèle un
projet utilisé au préalable.
• Cliquez sur le bouton Points de suspension pour utiliser comme
modèle un autre projet via la boîte de dialogue Ouverture de projet.
Le modèle du projet fournit des valeurs par défaut aux paramètres
figurant dans la boîte de dialogue Propriétés du projet (Projet|
Propriétés du projet). Si vous possédez déjà un projet JBuilder dont
les propriétés se rapprochent de celles qu’exige le nouveau projet,
sélectionnez-le ici. Cela réduit au minimum le travail répétitif
nécessaire à la configuration d’un nouveau projet pour un
environnement déterminé.
5 Indiquez si vous voulez générer un fichier HTML pour les notes du
projet. L’information initiale de ce fichier, comme le titre, l’auteur et la
description, est générée à partir des champs Javadoc classe définis à
l’étape 3 de l’expert Importation de projet. Vous pouvez également
ajouter d’autres notes et d’autres informations à ce fichier si nécessaire.
Les étapes 2 et 3 de l’expert Importation de projet sont celles de l’expert
projet. Ces étapes équivalent également à la page Chemins et la page
Général des Propriétés du projet. Voir “Création d’un nouveau projet en
utilisant l’expert projet”, page 7-2.
Si votre projet nécessite des bibliothèques particulières, vous pouvez les
ajouter au projet dans la page Chemins de la boîte de dialogue Propriétés
du projet. Pour définir la classe principale permettant d’exécuter votre
projet, choisissez la page Exécution de la boîte de dialogue Propriétés du
projet.
Voir aussi
page 8-11
• “Utilisation de la commande Exécuter” dans Construction d’applications
avec JBuilder
Affichage des fichiers d’un projet

JBuilder affiche chaque fichier ouvert d’un projet dans le volet contenu de
l’AppBrowser. Double-cliquez sur un fichier dans le volet projet pour
l’ouvrir dans le volet contenu. Un onglet portant le nom du fichier
apparaît en haut du volet contenu.

Enregistrement des projets
La figure suivante montre un fichier projet, Welcome.jpx, dans le volet

projet avec les fichiers source listés en dessous. Ce projet contient un
paquet et trois fichiers source. Deux fichiers sont ouverts dans le volet
contenu ainsi et le fichier sélectionné, WelcomeApp.java, est affiché dans le
volet source.
Cliquez avec le bouton droit sur le fichier projet pour afficher un menu.
Parmi ses options, citons Ouvrir, Ajouter des fichiers/paquets, Retirer du
projet, Fermer le projet, Construire, Reconstruire et Propriétés. Nombre
des ces options sont également accessibles dans le menu Projet.
Voir aussi
• “Travail sur plusieurs projets”, page 7-17
• Chapitre 5, “L’environnement de JBuilder”
Enregistrement des projets

Lorsque vous travaillez sur un projet, vous pouvez l’enregistrer à
l’emplacement proposé ou dans le répertoire de votre choix. Par défaut,
JBuilder enregistre les projets dans le répertoire jbproject sous votre
répertoire de base, bien que cela dépende de la façon dont votre système
est configuré. Chaque projet est enregistré dans son propre répertoire sous
jbproject. Chaque répertoire de projet comprend un fichier projet (.jpr ou
.jpx), un fichier .html facultatif pour les notes, un sous-répertoire classes
pour les fichiers classe (.class), un sous-répertoire src pour les fichiers
source et un sous-répertoire bak pour les fichiers de sauvegarde.
Enregistrement et fermeture des projets

Pour enregistrer un projet, sélectionnez Fichier|Tout enregistrer, Fichier|
Enregistrer le projet, ou cliquez sur le bouton Tout enregistrer dans la
barre d’outils principale.

Ouverture d’un projet existant
Pour fermer un projet, sélectionnez Fichier|Fermer les projets ou cliquez

sur le bouton Fermer le projet dans la barre d’outils projet.
Voir aussi
• “Construction des chemins d’accès par JBuilder”, page 8-16
• “Où sont mes fichiers ?”, page 8-20
Ouverture d’un projet existant

Il n’y a qu’une façon d’ouvrir un projet existant pour la première fois :
utiliser Fichier|Ouvrir un projet. Il y a deux façons d’ouvrir un projet
existant déjà ouvert auparavant : la commande Fichier|Ouvrir un projet
ou la commande Fichier|Réouvrir.
Pour ouvrir un projet avec la commande Fichier|Ouvrir un projet,
1 Choisissez Fichier|Ouvrir un projet. La boîte de dialogue Ouverture
d’un fichier apparaît.
2 Naviguez jusqu’au répertoire contenant le fichier du projet à ouvrir.
3 Sélectionnez le fichier de projet et cliquez sur OK ou appuyez sur la
touche Entrée. Vous pouvez également double-cliquer sur le fichier
projet pour l’ouvrir.
Pour ouvrir un projet ouvert auparavant avec la commande Fichier|
Réouvrir,
1 Choisissez Fichier|Réouvrir.
2 Choisissez le projet que vous souhaitez ouvrir dans la liste des projets
précédemment ouverts.
Le fichier projet et ses fichiers source apparaissent dans le volet projet.
Pour ouvrir un fichier dans le volet contenu, vous pouvez procéder de
trois manières :
• Double-cliquez sur le fichier dans le volet projet.
• Sélectionnez le fichier dans le volet projet et appuyez sur la touche
Entrée.
• Cliquez avec le bouton droit sur le fichier dans le volet projet et
sélectionnez Ouvrir.
Pour voir un projet dans un nouvel AppBrowser,
1 Sélectionnez Fenêtre|Nouveau navigateur.
2 Sélectionnez Fichier|Ouvrir un projet et naviguez jusqu’au fichier dans
la boîte de dialogue Ouverture de projet.

Création d’un nouveau fichier source Java
Si vous avez ouvert plus d’un AppBrowser et si les mêmes fichiers sont
ouverts dans plusieurs AppBrowsers, les modifications apportées dans un
AppBrowser se reflètent immédiatement dans le fichier identique ouvert
dans le ou les autres AppBrowsers. Cela conserve un contenu cohérent à
toutes vos versions de travail d’un fichier.
Remarque Tous les projets ouverts sont accessibles dans tous les AppBrowsers à
partir de la liste déroulante des projets.
Création d’un nouveau fichier source Java

Utilisez la boîte de dialogue Ouverture d’un fichier pour créer un
nouveau fichier Java unique et vide.
Il y a plusieurs façons de créer des fichiers source Java dans JBuilder. De
nombreux experts de JBuilder créent des fichiers. Beaucoup sont
accessibles dans la galerie d’objets (Fichier|Nouveau) ou dans le menu
Experts. En particulier, l’expert classe génère le cadre de travail pour une
nouvelle classe Java.
Pour créer un nouveau fichier source Java en utilisant Fichier|Ouvrir un
fichier,
1 Sélectionnez Fichier|Ouvrir un fichier pour ouvrir la boîte de dialogue
Ouverture d’un fichier.
2 Tapez le nom du fichier.
3 Choisissez le type de fichier .java dans la liste déroulante ou incluez
l’extension lorsque vous saisissez le nom.
4 Cliquez sur OK ou appuyez sur la touche Entrée.
5 Cliquez sur OK lorsque s’affiche le message indiquant que le fichier
n’existe pas.
6 JBuilder crée le nouveau fichier et l’ouvre dans le volet contenu.
Pour créer un nouveau fichier source Java en utilisant l’expert Classe,
1 Créez un nouveau projet comme décrit dans “Création d’un nouveau
projet”, page 7-2.
2 Choisissez Fichier|Nouvelle classe.
3 Entrez les noms du paquet, de la classe et de la classe de base dans
l’expert Classe.
4 Sélectionnez les options d’exposition, de gestion des méthodes et des
commentaires d’en-tête.
Le fichier .java est créé et ajouté à votre projet (son nœud apparaît dans le
volet projet). Le nouveau fichier s’ouvre dans le volet contenu de l’éditeur.

Gestion des projets
Voir aussi
• “Ajout à un projet”, page 7-14
• “Paquets”, page 8-13
• “Etape 3 : Définition des propriétés générales du projet”, page 7-6
Après avoir modifié un fichier, enregistrez-le en choisissant Fichier|
Enregistrer ou en cliquant sur l’icône Enregistrer. Le chemin et le
répertoire parent du fichier apparaissent en haut de la fenêtre de
l’AppBrowser lorsque le fichier est sélectionné et ouvert.
Gestion des projets

JBuilder est conçu pour aider le développeur à accomplir le nombre
maximal de tâches de développement. Dans JBuilder, les outils consacrés
aux projets, l’EDI étendu et les nombreuses fonctionnalités de l’éditeur
automatisent et simplifient le travail de développement : vous pouvez
concentrer votre attention sur votre code.
Voir aussi
• “Utilisation de l’AppBrowser”, page 5-2
Ajout à un projet
Dans l’AppBrowser, vous pouvez ajouter à votre projet des dossiers, des
fichiers existants ou des fichiers nouveaux. Beaucoup de ces commandes
sont disponibles dans le menu contextuel (clic droit) du volet projet, ainsi
que dans le menu principal.
Vous pouvez utiliser les dossiers projet pour organiser en structure
hiérarchique vos projets les plus volumineux.
Remarque Les dossiers projet n’ont qu’une fonction organisationnelle et ne
correspondent pas aux répertoires du disque.
Ajout de dossiers
Les dossiers projet n’affectent pas l’arborescence des répertoires. Ce sont
des outils d’organisation permettant de classer les éléments d’un projet de
manière pratique pour vous mais sans altérer la structure des répertoires.
Pour ajouter un dossier à un projet,
1 Sélectionnez le projet dans le volet projet (volet supérieur gauche).
2 Choisissez Fichier|Nouveau dossier dans le menu principal ou cliquez
avec le bouton droit dans le volet projet.
3 Sélectionnez Nouveau dossier.

Gestion des projets
Astuce Pour imbriquer le nouveau dossier dans un dossier existant,

sélectionnez le dossier existant avant de choisir Fichier|Nouveau
dossier.
4 Tapez le nom du dossier.
5 Cliquez sur OK ou appuyez sur la touche Entrée.
Pour ajouter un fichier à un dossier,
1 Soit cliquez avec le bouton droit sur le dossier et choisissez Ajouter des
fichiers/paquets pour ouvrir la boîte de dialogue Ajout de fichiers ou
paquets au projet, soit sélectionnez le dossier et cliquez sur le bouton
Ajouter des fichiers/paquets de la barre d’outils du volet projet.
2 Dans la page Explorateur de la boîte de dialogue Ajout de fichiers au
projet, naviguez jusqu’au répertoire contenant le fichier que vous
souhaitez ajouter.
3 Sélectionnez le fichier et cliquez sur OK.
Ajout de fichiers et de paquets

Vous devez ajouter explicitement les fichiers et les paquets à un projet
pour que JBuilder les traite comme faisant partie du projet. Ajoutez des
fichiers et des paquets au projet en cours dans la boîte de dialogue Ajout
de fichiers ou paquets au projet.
Il existe deux façons d’accéder à cette boîte de dialogue. Utilisez celle que
vous préférez :
• Cliquez sur le bouton Ajouter des fichiers/paquets dans la barre
d’outils du volet projet.
• Cliquez avec le bouton droit sur un nœud du volet projet et choisissez
Ajouter des fichiers/paquets dans le menu contextuel.
Lorsque la boîte de dialogue est accessible :
1 Sélectionnez :
• La page Explorateur pour ajouter un fichier.
• La page Paquets pour ajouter un paquet.
Ces deux pages acceptent la sélection multiple.
2 Naviguez jusqu’au fichier ou au paquet à importer.
3 Sélectionnez le fichier ou le paquet voulu. Lorsque vous avez atteint le
répertoire parent d’un fichier, vous pouvez taper le nom du fichier au
lieu de le sélectionner.
4 Double-cliquez sur votre sélection, cliquez sur OK ou appuyez sur
Entrée.
Le nouveau nœud apparaît sous le projet dans le volet projet.

Gestion des projets
Retrait d’un élément d’un projet

Vous pouvez enlever de votre projet des dossiers, fichiers, classes et
paquets sans toutefois les supprimer de votre unité de disque.
Utilisez la boîte de dialogue Retrait du projet.
1 Pour accéder à cette boîte de dialogue :
• Cliquez avec le bouton droit sur le nœud que voulez retirer et
choisissez Retirer du projet dans le menu contextuel.
• Ou, sélectionnez-le et cliquez sur le bouton Retirer du projet.
2 Cliquez sur OK ou appuyez sur Entrée dans la boîte de dialogue Retrait
du projet.
Remarque Si un dossier contient des fichiers, ils sont également retirés du projet.
Vous pouvez sélectionner plusieurs fichiers et les retirer du projet en
même temps.
Suppression d’éléments
Vous pouvez aussi supprimer du disque les fichiers, classes et paquets
non souhaités en cliquant avec le bouton droit sur l’élément dans le volet
projet et en choisissant Supprimer.
Attention Ceci supprime définitivement les fichiers du projet et du disque dur de
l’ordinateur.
Ouverture d’un fichier à l’extérieur d’un projet

Utilisez la commande Fichier|Ouvrir un fichier pour ouvrir un fichier
dans l’AppBrowser sans l’ajouter au projet ouvert. Un projet doit être
ouvert pour que cette commande soit accessible.
Pour ouvrir un fichier sans l’ajouter à un projet,
1 Choisissez Fichier|Ouvrir un fichier. La boîte de dialogue Ouverture
d’un fichier apparaît.
2 Sélectionnez le fichier à ouvrir.
3 Cliquez sur OK. Le contenu du fichier est affiché dans l’AppBrowser.
Fonctionnalité Vous pouvez également ouvrir un fichier dans le projet ouvert dans un
de JBuilder Professionnel autre AppBrowser.
1 Cliquez avec le bouton droit sur un fichier dans le volet projet.
2 Choisissez Ouvrir dans un nouveau navigateur.

Travail sur plusieurs projets
Modification des noms de projets et de fichiers

Il y a plusieurs façons de renommer un projet ou l’un de ses fichiers.
1 Sélectionnez le projet ou le fichier dans le volet projet.
2 Sélectionnez Projet|Renommer ou Fichier|Renommer ou cliquez avec
le bouton droit dans le volet projet et sélectionnez Renommer.
3 Entrez le nouveau nom dans la boîte de dialogue Renommer.
4 Cliquez sur Enregistrer.
Il existe une autre façon de renommer un fichier ouvert :
1 Cliquez avec le bouton droit sur l’onglet du fichier en haut du volet
contenu.
2 Sélectionnez Renommer.
3 Entrez le nouveau nom dans la boîte de dialogue Renommer.
4 Cliquez sur Enregistrer.
Attention Renommer les projets et les fichiers ne change pas les noms de paquets ou
de fichiers référencés dans le code. JBuilder Professionnel et JBuilder
Entreprise assurent le refactoring des noms. Ils modifient toutes les
références à l’ancien nom pour qu’elles correspondent au nouveau.
Voir aussi
• “Refactoring des symboles du code” dans Construction d’applications
avec JBuilder.

Vous pouvez travailler sur plusieurs projets simultanément dans
l’environnement de développement de JBuilder. Vous pouvez les ouvrir
dans un seul AppBrowser ou dans des AppBrowsers différents. Tous les
projets ouverts sont accessibles dans n’importe quel AppBrowser ouvert à
partir de la liste déroulante des projets. Toute modification effectuée dans
un AppBrowser est effective dans tous les AppBrowsers ouverts sur le
même projet. Ouvrez un nouvel AppBrowser JBuilder en sélectionnant
Fenêtre|Nouveau navigateur.
Passage d’un projet à l’autre

Lorsque plusieurs projets sont ouverts dans l’AppBrowser, un seul projet
est visible dans le volet projet. Passez à un autre projet ouvert en le
sélectionnant dans la liste déroulante des projets située dans la barre
d’outils au dessus du volet Projet.

Les AppBrowsers, les projets et les fichiers ouverts sont tous accessibles
dans le menu Fenêtre :
Sélectionnez Nouveau navigateur pour ouvrir un autre AppBrowser.

Vous contrôlerez les fenêtres navigateur au moyen des quatre commandes
suivantes. Sélectionnez le fichier ouvert ou le fichier projet appartenant à
un autre AppBrowser pour passer d’une fenêtre navigateur à l’autre.
Les fichiers ouverts dans le navigateur sélectionné sont également
accessibles dans ce menu. Cela constitue un autre moyen d’accéder aux
fichiers ouverts – spécialement utile à ceux qui ont décidé de ne pas
afficher les noms sur les onglets de fichiers.
Enregistrement de plusieurs projets

Pour enregistrer les modifications dans tous les fichiers et projets ouverts,
choisissez Fichier|Tout enregistrer. Tous les fichiers de tous les
AppBrowsers ouverts sont enregistrés.

Chapitre
Gestion des chemins d’accès

Chapitre8
8
Les chemins d’accès forment l’infrastructure du développement des
programmes Java. Les chemins d’accès fournissent au programme ce qui
est nécessaire à son exécution. Lorsque vous définissez un JDK, vous
indiquez au programme le chemin qui lui permettra d’accéder à ce JDK.
Lorsque vous créez une bibliothèque, vous assemblez une suite de
chemins dont le programme aura besoin. Chaque fois qu’un fichier fait
référence à un autre fichier, il utilise son chemin d’accès pour l’atteindre.
Cette section explique comment JBuilder construit les chemins d’accès,
comment manipuler les chemins d’accès dans la boîte de dialogue
Propriétés du projet, et comment utiliser les outils touchant les chemins
d’accès comme les bibliothèques ou les fonctionnalités d’audit de code.
Utilisation des bibliothèques

Qu’est-ce qu’une bibliothèque ?
JBuilder utilise des bibliothèques pour rechercher tout élément nécessaire
à l’exécution d’un projet, ainsi que pour la navigation dans le source, la
visualisation Javadoc, l’utilisation du concepteur visuel, l’application de
l’audit de code et la compilation du code. Les bibliothèques sont des
collections de chemins comprenant des classes, fichiers source et fichiers
de documentation. Les bibliothèques sont statiques, non dynamiques. Les
chemins des bibliothèques individuelles sont souvent contenus dans des
fichiers JAR ou ZIP mais ils peuvent aussi être contenus dans des
répertoires.
Lorsque des bibliothèques sont ajoutées à JBuilder, elles sont ajoutées au
chemin des classes pour que JBuilder les trouve. Les bibliothèques sont
Gestion des chemins d’accès 8-1

recherchées dans l’ordre dans lequel elles sont énumérées. L’ordre des
bibliothèques peut être modifié dans la boîte de dialogue Configuration
des bibliothèques (Outils|Configurer les bibliothèques) et sur la page
Chemins de la boîte de dialogue Propriétés du projet (Projet|Propriétés
du projet).
Voir aussi
Les configurations des bibliothèques sont enregistrées dans des fichiers
.library et peuvent être sauvegardées dans plusieurs emplacements :
Home de Enregistrer le fichier .library dans le répertoire

l’utilisateur <.jbuilder> du répertoire home de l’utilisateur.
JBuilder Fonctionnalité de JBuilder Professionnel et de JBuilder
Entreprise.
Enregistrer le fichier .library dans le répertoire
<jbuilder>/lib. Plusieurs utilisateurs employant
JBuilder sur un réseau ou partageant JBuilder sur une
même machine ont accès aux bibliothèques de ce
dossier.
Projet Fonctionnalité de JBuilder Professionnel et de JBuilder
Entreprise.
Permet d’enregistrer le fichier .library dans le
répertoire du projet en cours. Lorsque vous utilisez la
fonctionnalité de contrôle de versions dans JBuilder
Entreprise, le fichier .library est archivé avec les
autres fichiers du projet.
Dossier défini Fonctionnalité de JBuilder Entreprise.
par l’utilisateur
Permet d’enregistrer le fichier .library dans un dossier
défini par l’utilisateur ou un répertoire partagé. Vous
devez ajouter le nouveau dossier dans la boîte de
dialogue Configuration des bibliothèques pour qu’il
apparaisse dans la liste déroulante.
Ajout et configuration des bibliothèques

Plusieurs procédés permettent d’ajouter de nouvelles bibliothèques à
votre projet. D’abord, vous pouvez rassembler vos fichiers en fichiers JAR,
notamment si vous envisagez de déployer votre programme.

Après avoir créé la bibliothèque, ajoutez-la à JBuilder comme suit :

1 Sélectionnez Outils|Configurer les bibliothèques. La boîte de dialogue
Configuration des bibliothèques apparaît.
Le volet de gauche vous permet de naviguer entre les bibliothèques
disponibles. Le volet de droite montre les spécifications pour la
bibliothèque sélectionnée.
2 Cliquez sur le bouton Nouveau pour ouvrir l’expert nouvelle
bibliothèque.
3 Nommez la nouvelle bibliothèque dans le champ Nom.

4 Sélectionnez dans la liste déroulante l’emplacement où vous souhaitez
enregistrer les configurations de la bibliothèque : Projet, Home de
l’utilisateur, JBuilder ou un dossier défini par l’utilisateur. Les dossiers
définis par l’utilisateur sont une fonctionnalité de JBuilder Entreprise.
5 Cliquez sur le bouton Ajouter et sélectionnez un ou plusieurs chemins
contenant des fichiers classe, source et de documentation. JBuilder
détermine automatiquement le chemin adéquat pour les fichiers.
Cliquez sur OK. Notez que la sélection apparaît dans la liste Chemins
de bibliothèques.
6 Cliquez sur OK pour fermer l’expert nouvelle bibliothèque. Notez que
la bibliothèque est enregistrée dans la boîte de dialogue Configuration
des bibliothèques dans les chemins des classe, des source et de la
documentation appropriés. Vous pouvez également ajouter, modifier,
supprimer et réorganiser les listes de bibliothèques dans cette boîte de

dialogue. JBuilder Entreprise comprend également une fonctionnalité

Ajouter un dossier.
7 Cliquez sur OK ou appuyez sur Entrée pour fermer la boîte de dialogue

Configuration des bibliothèques.
Pour ajouter la bibliothèque à un projet, voir “Définition des chemins
d’accès aux bibliothèques nécessaires”, page 8-11.
Vous pouvez également ajouter des bibliothèques dans la boîte de
dialogue Propriétés du projet.
1 Sélectionnez Projet|Propriétés du projet.
2 Sélectionnez l’onglet Bibliothèques nécessaires sur la page Chemins et
cliquez sur le bouton Ajouter.
3 Cliquez sur le bouton Nouveau pour ouvrir l’expert nouvelle
bibliothèque.
Voir aussi
page 8-11
• “Using JAR Files: The Basics” à l’adresse http://java.sun.com/docs/
books/tutorial/jar/basics/index.html

Modification des bibliothèques

Pour modifier une bibliothèque existante,
1 Sélectionnez Outils|Configurer les bibliothèques.
2 Sélectionnez la bibliothèque à modifier dans la liste des bibliothèques.
3 Sélectionnez l’onglet Classe, Source ou Documentation pour choisir le
nom de la bibliothèque que vous voulez modifier.
4 Sélectionnez le nom de la bibliothèque et cliquez sur Modifier.
5 Naviguez jusqu’à un fichier ou un dossier défini par l’utilisateur dans
la boîte de dialogue Sélection d’un répertoire. Cliquez sur OK.
6 Cliquez sur Ajouter pour naviguer jusqu’à la bibliothèque à ajouter.
7 Sélectionnez le nom d’une bibliothèque et cliquez sur Retirer pour le
retirer.
8 Modifiez l’ordre des chemins d’accès aux bibliothèques en
sélectionnant un nom et en cliquant sur Vers le haut ou Vers le bas.
Astuce JBuilder recherche les bibliothèques en suivant l’ordre de la liste.
9 Cliquez sur OK ou appuyez sur Entrée pour fermer la boîte de dialogue
Configuration des bibliothèques.
Affichage des listes de bibliothèques

Les bibliothèques répertoriées dans les boîtes de dialogue JBuilder
peuvent être affichées en trois couleurs :
Tableau 8.1 Couleurs des listes des bibliothèques

Couleur Description Solution des problèmes
Noir La bibliothèque est
correctement définie.
Rouge La définition de la Cela signifie généralement que le projet
bibliothèque est manquante. fait référence à une bibliothèque qui
n’est pas encore définie. Cela peut aussi
signifier que la bibliothèque a été définie
sans chemin d’accès.
Gris L’utilisation de cette Vous devez mettre à niveau votre
bibliothèque nécessite une édition de JBuilder pour pouvoir utiliser
mise à niveau. cette bibliothèque. Par exemple, si vous
possédez JBuilder Personnel, l’utilisation
de la bibliothèque dbSwing requiert une
mise à niveau vers JBuilder
Professionnel ou JBuilder Entreprise.


Les propriétés d’un projet contrôlent la façon dont celui-ci est compilé.
Dans boîte de dialogue Propriétés du projet (Projet|Propriétés du projet),
vous pouvez définir les options suivantes :
• Page Chemins
Elle définit les paramètres de chemins du projet pour la version du
JDK, le chemin de sortie, le chemin de sauvegarde, le répertoire de
travail, les chemins des sources, le chemin de test, le chemin de la
documentation et les chemins d'accès aux bibliothèques nécessaires.
• Page Général
Elle sert à définir les options d’encodage et d’activation des paquets
source automatiques, à modifier les champs Javadoc classe
éventuellement générés par les experts, à spécifier l’option permettant
d’inclure des références issues des bibliothèques du projet.
• Page Exécution
Elle permet de définir les paramètres d’exécution à passer à votre
application ou applet lors de son exécution.
• Page Débogage
Elle permet de définir les options de débogage du projet.
• Page Construction
Elle permet de définir les options de compilation pour la construction
du projet, y compris les informations de débogage et la copie sélective
des ressources.
• Page Style de code
Elle permet de définir les options de personnalisation du style de
codage, projet par projet.
• Page Style import
Fonctionnalité de JBuilder Professionnel et de JBuilder Entreprise. Elle
permet de définir les options de configuration des instructions import.
• Page Editeur
Elle définit les caractères de fin de ligne.
Fonctionnalité • Page UML
Elle définit les options d’affichage des diagrammes UML, par exemple
Filtres d’exclusion de paquet/classe et Le diagramme fait référence au
source généré.

Fonctionnalité de • Page Serveur Web

JBuilder Professionnel.
Elle définit les options du serveur web.
Fonctionnalité • Page Serveurs
Elle définit les options du serveur d’applications ou du serveur web.
Remarque Vous pouvez également définir ces options pour tous les projets à venir en
utilisant la boîte de dialogue Propriétés du projet par défaut (Projet|
Propriétés du projet par défaut) ou en sélectionnant le projet par défaut
comme modèle de projet dans l’expert projet.
Pour définir les propriétés d’un projet,
1 Cliquez avec le bouton droit sur le nom de fichier .jpr ou .jpx dans le
volet projet et choisissez Propriétés pour afficher la boîte de dialogue
Propriétés du projet. Ou, sélectionnez le projet et choisissez Projet|
Propriétés du projet. La boîte de dialogue Propriétés du projet apparaît.
2 Sélectionnez l’onglet approprié aux options à définir. Dans cette image,
la page Chemins est sélectionnée.
Sur la page Chemins, vous pouvez définir la version JDK, les différents
chemins d’accès du projet et les chemins d’accès aux bibliothèques
nécessaires.
Définition du JDK
Les éditions Professionnel et Entreprise de JBuilder prennent en charge la
permutation des JDK, tandis que JBuilder Personnel vous permet de
modifier un JDK unique. JBuilder peut compiler et s’exécuter par rapport
à toutes les versions JDK de Sun et à beaucoup d’autres.

Les éditions Professionnel et Entreprise de JBuilder vous permettent de

définir la version de JDK de votre projet sur la page Chemins de la boîte
de dialogue Propriétés du projet, ainsi que d’ajouter, de modifier et de
supprimer des JDK dans la boîte de dialogue Configuration des JDK. Voir
“Définition du JDK”, page 8-7.
JBuilder Personnel vous permet de modifier le JDK dans la boîte de
dialogue Configuration des JDK (Outils|Configurer les JDK). Voir
“Modification du JDK”, page 8-8.
Modification du JDK
Vous pouvez modifier la version courante du JDK comme suit :
1 Sélectionnez Outils|Configurer les JDK pour ouvrir la boîte de
dialogue Configuration des JDK :
2 Choisissez le bouton Points de suspension situé à droite du champ

Répertoire de base du JDK. La boîte de dialogue Sélection d’un
répertoire apparaît.
3 Naviguez jusqu’au JDK souhaité.
4 Cliquez sur OK pour changer le JDK.
Remarquez la modification du nom et du répertoire de base du JDK
dans la boîte de dialogue Configuration des JDK.
5 Cliquez sur OK pour fermer la boîte de dialogue Configuration des
JDK.
L’option Toujours déboguer avec -classic de la boîte de dialogue
Configuration des JDK apporte une amélioration des performances aux

utilisateurs de versions de la JVM inférieures à 1.3.1. Automatiquement,

JBuilder vérifie si cette option augmenterait ou non les performances, puis
coche ou non la case selon ce qui donnera les meilleurs résultats. Cette
fonctionnalité est disponible dans toutes les éditions de JBuilder.
Pendant cette évaluation, JBuilder effectue deux vérifications :
1 Avez-vous la VM classique ?
2 Si oui, s’agit-il d’une JVM de version antérieure à 1.3.1 ?
Cette sélection est remplacée lorsque vous définissez des paramètres pour
la VM tels que native, hotspot, green ou server.
Définition du JDK dans les éditions Professionnel et Entreprise

Les éditions Professionnel et Entreprise de JBuilder prennent en charge la
permutation de JDK. Vous pouvez également ajouter, modifier et
supprimer des JDK. Pour passer d’un JDK à un autre, procédez comme
suit :
1 Sélectionnez Projet|Propriétés du projet et sélectionnez l’onglet
Chemins.
2 Cliquez sur le bouton Points de suspension à droite de la version du
JDK. La boîte de dialogue Sélection d’un JDK apparaît :
3 Si le JDK cible est dans la liste, sélectionnez-le et appuyez sur OK.

S’il n’est pas répertorié, sélectionnez Nouveau pour ouvrir l’expert

nouveau JDK.
1 Cliquez sur le bouton Points de suspension et naviguez jusqu’au

répertoire du JDK à ajouter à la liste. Cliquez sur OK. Notez que le
champ Nom est rempli automatiquement.
2 Sélectionnez l’emplacement où stocker les spécifications du JDK :
• Home de l’utilisateur : permet d’enregistrer les spécifications du
JDK dans un fichier .library dans le répertoire <.jbuilder> du
répertoire de base de l’utilisateur. Enregistrez à cet emplacement
si vous souhaitez que le JDK soit disponible pour tous les projets.
Fonctionnalité • JBuilder : permet d’enregistrer les spécifications JDK dans un
de JBuilder Professionnel fichier .library dans le répertoire <jbuilder>. Lorsque plusieurs
et de JBuilder Entreprise. utilisateurs utilisent JBuilder dans un réseau ou partagent
JBuilder sur une même machine, ils accèdent aux JDK de ce
dossier.
Fonctionnalité • Projet : permet d’enregistrer les spécifications JDK dans un fichier
de JBuilder Professionnel .library dans le répertoire du projet. Utilisez cet emplacement si
et de JBuilder Entreprise. vous voulez que le JDK soit disponible uniquement pour ce
projet.
Fonctionnalité • Dossier défini par l’utilisateur : permet d’enregistrer les
de JBuilder Entreprise. spécifications du JDK dans un dossier ou dans un répertoire
partagé. Vous devez ajouter le nouveau dossier (sélectionnez
Outils|Configurer les JDK et cliquez sur Ajouter un dossier) pour
le faire apparaître dans la liste déroulante.
3 Cliquez sur OK. Notez que les spécifications du JDK ont été ajoutées
au répertoire spécifié dans la boîte de dialogue Sélection d’un JDK.
4 Cliquez sur OK pour fermer la boîte de dialogue Sélection d’un JDK.
Notez que le chemin du JDK est mis à jour en fonction de la nouvelle
sélection.

5 Cliquez sur OK pour fermer la boîte de dialogue Propriétés du projet.

6 Enregistrez le projet. La version du JDK est mise à jour dans le fichier
projet.
Astuce Vous pouvez ajouter, modifier et supprimer des JDK en sélectionnant
Outils|Configurer les JDK. Vous pouvez également modifier les
propriétés du projet par défaut (Projet|Propriétés du projet par défaut) en
changeant le JDK de tous les futurs projets.
Configuration des JDK

L’ajout et la suppression Vous pouvez ajouter, modifier et supprimer des JDK dans la boîte de
de JDK sont dialogue Configuration des JDK (Outils|Configurer les JDK). Les
des fonctionnalités utilisateurs de l’édition Personnel peuvent modifier les JDK en suivant les
de JBuilder Professionnel explications fournies dans “Modification du JDK”, page 8-8.
Dans cette boîte de dialogue, vous pouvez :
• Nommer le JDK à l’aide du bouton Renommer.
• Ajouter, modifier, retirer et réorganiser les fichiers classe, source et
documentation des JDK.
• Ouvrir l’expert nouveau JDK et ajouter des JDK à l’aide du bouton
Nouveau.
Fonctionnalité • Ajouter un dossier pouvant être partagé.
• Supprimer un JDK existant de la liste.
Pour plus d’informations, sélectionnez le bouton Aide de la boîte de
dialogue Configuration des JDK et de l’expert nouveau JDK.
Définition des chemins d’accès aux bibliothèques

nécessaires
Dans la page Chemins de la boîte de dialogue Propriétés du projet, vous
pouvez définir les bibliothèques à utiliser lors de la compilation. JBuilder
place toutes les bibliothèques sélectionnées sur le chemin de classes.

Pour ajouter, modifier, supprimer et réorganiser des bibliothèques,

sélectionnez l’onglet Bibliothèques nécessaires.
Vous pouvez sélectionner des bibliothèques dans la liste Bibliothèques

nécessaires de la page Chemins et les modifier, les supprimer ou changer
l’ordre dans lequel elles seront utilisées.
Remarque Les bibliothèques sont recherchées dans l’ordre dans lequel elles sont
énumérées. Pour modifier l’ordre des bibliothèques, sélectionnez une
bibliothèque, puis cliquez sur Vers le haut ou Vers le bas.
Le bouton Ajouter affiche la boîte de dialogue Sélection de bibliothèques,
où vous pouvez choisir les bibliothèques à ajouter à votre projet.
Sélectionnez Nouveau dans cette boîte de dialogue pour ouvrir l’Expert
nouvelle bibliothèque et créer une nouvelle bibliothèque.
Vous pouvez également configurer les bibliothèques en sélectionnant

Outils|Configurer les bibliothèques.

Paquets
Voir aussi
Paquets
Java regroupe les fichiers .java et .class dans un paquet. Tous les fichiers
qui constituent le source d’un paquet Java se trouvent dans le même
sous-répertoire (src) ; tous les fichiers compilés sont dans un autre
sous-répertoire (classes). Lors de la construction des applications, JBuilder
utilise le nom du projet comme nom de paquet par défaut dans les experts
application et applet. Par exemple, si le nom du projet est sans_titre1.jpr,
l’expert application ou l’expert applet propose le nom de paquet
sans_titre1. Les noms de paquets suggérés sont toujours basés sur le nom
du projet.
Examinons un exemple de projet pour comprendre comment le nom de
paquet affecte la structure des répertoires.
Remarque Dans ces exemples, les chemins d’accès s’appliquent à la plate-forme
UNIX. Pour connaître les conventions utilisées par la documentation
quant aux chemins d’accès, voir “Conventions utilisées par la
documentation”.
Imaginons que vous ayez un projet organisé dans un dossier appelé
ProjetExemple. Ce dossier projet contient un fichier projet (afrique.jpr), un
répertoire classes et un répertoire src :
Vous voudrez certainement créer vos propres paquets pour rassembler les
sources et les classes correspondantes. Dans cet exemple, afrique.jpr
contient un nom de paquet : felins.afrique. Ce paquet contient des fichiers
source sur certains des félins trouvés en Afrique : les lions, les tigres et les
léopards.
Les fichiers classe, sauvegardés dans une structure de répertoires calquée
sur les noms de paquets, sont enregistrés dans le sous-répertoire classes

Paquets
du projet. Le sous-répertoire src, qui contient les fichiers .java, a la même

structure que le sous-répertoire des classes.
Supposons que les classes contenues dans le projet soient Lion.class,

Tigre.class et Leopard.class. Elles se trouveront dans classes/felins/
afrique. Les fichiers source, Lion.java, Tigre.java et Leopard.java, se
trouveront dans src/felins/afrique comme ci-dessous.
emplacement du fichier .java = chemin du source + chemin

du paquet
Il est important de comprendre quelles sont les informations qu’utilise
JBuilder pour construire l’emplacement du répertoire d’un fichier .java.
La première partie du chemin d’accès est déterminée par le chemin des
sources. Le chemin des sources est défini au niveau du projet et peut être
modifié dans la page Chemins de la boîte de dialogue Propriétés du
projet.
Si nous reprenons l’exemple ProjetExemple, le chemin des sources de
Lion.java est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/src
Remarque Pour la définition du répertoire <home>, voir “Conventions sur la
documentation JBuilder” dans l’aide en ligne.
La deuxième partie du chemin d’accès est déterminée par le nom du
paquet, dans notre cas felins.afrique.

Paquets
Remarque La nomenclature Java utilise le point (.) pour séparer les parties d’un
paquet.
L’emplacement du fichier Lion.java est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/src/felins/afrique/Lion.java
Voir aussi
emplacement du fichier .class = chemin de sortie + chemin

du paquet
L’emplacement du répertoire du fichier .class est déterminé par le chemin
de sortie et le nom du paquet. Le chemin de sortie est la “racine” à laquelle
JBuilder ajoute les chemins des paquets pour créer la structure des
répertoires des fichiers .class générés par le compilateur. Le chemin de
sortie est défini au niveau du projet et peut être modifié dans la page
Chemins de la boîte de dialogue Propriétés du projet.
Dans l’exemple ProjetExemple, le chemin de sortie pour Lion.class est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/classes
La deuxième partie du chemin d’accès est déterminée par le nom du
paquet, dans notre cas felins.afrique.
Comme indiqué ci-dessous, l’emplacement du fichier Lion.class est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/classes/felins/afrique/
Lion.class
Voir aussi
Utilisation des paquets dans JBuilder

Lorsque vous référencez des classes appartenant à un paquet, vous
pouvez utiliser une instruction import. Une instruction import permet à
votre code de faire référence à une classe du paquet importé en utilisant la
version abrégée de son nom. (Les concepteurs et les experts de JBuilder
ajoutent automatiquement cette instruction.) Voici un exemple
d’instruction import :
import felins.afrique.*;
Si cette instruction import est incluse dans votre code source, vous pouvez
faire référence à la classe Lion par Lion seulement.

Construction des chemins d’accès par JBuilder
Si vous n’importez pas le paquet, pour faire référence à une classe

particulière, vous devez indiquer son nom entièrement qualifié. Comme le
montre le diagramme suivant, le nom de classe entièrement qualifié pour
Lion.java est felins.afrique.Lion (nom du paquet + nom de la classe sans
extension).
Pour en savoir davantage sur les paquets et le langage Java, consultez les
nombreuses et excellentes sources d’informations tierces.
Prescriptions pour l’appellation des paquets

Les prescriptions d’appellation des paquet suivantes sont recommandées
pour tous les programmes Java. Afin d’assurer la cohérence en matière de
lisibilité et de maintenance, les noms de paquets doivent être :
• constitués d’un seul mot
• au singulier, plutôt qu’au pluriel
• tout en minuscules, même s’ils comportent plusieurs mots (par
exemple, nompaquetquatremots et non NomPaquetQuatreMots)
Si vos paquets sont destinés à être partagés à l’extérieur de votre groupe,
leurs noms doivent commencer par un nom de domaine Internet dont les
éléments sont cités dans l’ordre inverse. Par exemple, si vous utilisez le
nom de domaine mon.domaine.com, vos noms de paquets doivent être
préfixés par com.domaine.mon.

L’EDI de JBuilder utilise plusieurs chemins au cours du traitement :
• Chemin des sources
• Chemin de sortie
• Chemin des classes
• Chemin de recherche
• Chemin de la documentation
• Chemin de sauvegarde
• Répertoire de travail
Les chemins sont définis au niveau du projet. Pour les définir, utilisez la
boîte de dialogue Propriétés du projet. Voir “Définition des propriétés
d’un projet”, page 8-6, pour plus d’informations.

Dans la construction des chemins, JBuilder élimine les noms de chemin en

double. Pour Windows, cela évite les problèmes liés aux limites de
l’environnement DOS.
Remarque Dans ces exemples, les chemins d’accès s’appliquent à la plate-forme
UNIX. Voir “Conventions utilisées par la documentation” dans l’aide en
ligne.
Chemin des sources

Le chemin des sources contrôle l’emplacement dans lequel le compilateur
recherche les fichiers source. Le chemin des sources est construit à partir
des deux éléments suivants :
• Le chemin défini sur l’onglet Source de la page Chemins de la boîte de
dialogue Propriétés du projet.
• Le répertoire des fichiers générés. Ce répertoire contient les fichiers
source automatiquement générés par l’EDI. Les fichiers squelette et
serveur IDL sont des exemples de ces fichier source. Le répertoire des
fichiers générés est placé dans le chemin de sortie. Vous pouvez
changer cette option dans la page Construction de la boîte de dialogue
Propriétés du projet.
Le chemin des sources complet est composé de ces deux éléments, dans
l’ordre qui suit :
chemin des sources + chemin de sortie/du source généré
Dans l’exemple ProjetExemple, le chemin des sources du projet
felins.afrique.jpr est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/src
Chemin de sortie
Le chemin de sortie contient les fichiers .class créés par JBuilder. Le
chemin de sortie est construit à partir du chemin défini dans la boîte texte
Chemin de sortie, située dans la page Chemins de la boîte de dialogue
Propriétés du projet.
Les fichiers sont placés dans un répertoire dont le chemin d’accès
correspond au chemin de sortie + le nom de paquet. Il n’y a qu’un seul
chemin de sortie par projet.
Dans l’exemple ProjetExemple, le chemin de sortie du projet
felins.afrique.jpr est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/classes

Chemin des classes

Le chemin des classes est utilisé pendant la compilation. Ce chemin est
construit à partir de tous les éléments suivants :
• Le chemin de sortie
• Le chemin des classes de chaque bibliothèque répertoriée dans la page
Chemins de la boîte de dialogue Propriétés du projet (dans l’ordre de la
liste)
• La version du JDK cible sélectionnée dans la page Chemins de la boîte
de dialogue Propriétés du projet
Le chemin des classes complet est composé de ces éléments, dans l’ordre
qui suit : chemin de sortie + chemins des classes des bibliothèques (dans
l’ordre dans lequel elles sont répertoriées dans la boîte de dialogue
Propriétés du projet) + cible JDK
Par exemple, le chemin complet de Lion.class est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/classes:
/user/jbuilder/lib/dbswing3.1.jar:/user/jdk1.3/bin
Le chemin des classes est affiché dans l’onglet du compilateur après la
compilation.
Chemin de recherche
Le chemin de recherche est utilisé par l’EDI lorsque vous :
• Utilisez l’audit de code
• Choisissez la commande Trouver la définition dans le menu déroulant
de l’éditeur
• Choisissez la commande Chercher|Parcourir les classes
• Exécutez le débogueur
Le chemin de recherche est construit à partir de tous les éléments
suivants :
• Le chemin des sources
• Le chemin des source de chaque bibliothèque répertoriée dans la page
Chemins de la boîte de dialogue Propriétés du projet (dans l’ordre de la
liste)
• Le chemin des sources de la version du JDK de destination sélectionnée
dans la page Chemins de la boîte de dialogue Propriétés du projet
Le chemin de recherche complet est composé de ces éléments, dans l’ordre
qui suit : chemin des sources + chemins des sources des bibliothèques (dans

l’ordre dans lequel elles sont répertoriées dans la page Chemins de la boîte
de dialogue Propriétés du projet) + chemin des sources de la cible JDK
Par exemple, le chemin de recherche complet pour Lion.class est :
/<home>/<nomutilisateur>/jbproject/ProjetExemple/src:
/user/jbuilder/lib/dbswing3.1.jar:
/user/jbuilder/lib/dx3.1.jar:/user/jdk1.3/bin
Chemin de la documentation
Le chemin de la documentation est le chemin ou les chemins qui
contiennent les fichiers de documentation HTML pour les fichiers classe
API. Cela permet d’afficher la documentation de référence dans la page
Doc du volet contenu.
Le chemin de la documentation peut être défini dans la page Chemins de
la boîte de dialogue Propriétés du projet. La recherche s’effectue dans
l’ordre des chemins.
Chemin de sauvegarde
JBuilder utilise le chemin de sauvegarde pour enregistrer les fichiers de
sauvegarde. Le répertoire de sauvegarde par défaut est :
/<home>/<nomutilisateur>/jbproject/<nomprojet>/bak
Important Le fichiers JSP, les fichiers HTML et quelques autres fichiers texte ne sont
pas considérés comme des fichiers source. Ces fichiers sont sauvegardés
dans leurs répertoires originaux respectifs.
Mais, vous pouvez inclure ces sauvegardes dans le répertoire de
sauvegarde de votre projet. Pour cela,
1 Sélectionnez Projet|Propriétés du projet et allez à la page Chemins.
2 Sélectionnez l’onglet Source dans la page Chemins.
3 Cliquez sur le bouton Ajouter de l’onglet Source. Cela affiche la boîte
de dialogue Sélection d’un ou de plusieurs répertoires.
4 Naviguez jusqu’au répertoire de sauvegarde du projet, sélectionnez-le
et cliquez sur OK.
Répertoire de travail
JBuilder utilise le répertoire de travail pour enregistrer les fichiers projet.
Le répertoire de travail par défaut est :
/<home>/<nomutilisateur>/jbproject/<nomprojet>

Où sont mes fichiers ?

Chaque fichier d’un projet a un chemin d’accès relatif à l’emplacement du
fichier projet (.jpr ou .jpx). JBuilder utilise le chemin des sources, le
chemin de test, le chemin des classes, le chemin de recherche et le chemin
de sortie pour chercher et enregistrer les fichiers.
• Le chemin des sources contrôle l’emplacement dans lequel le
compilateur recherche les fichiers source.
• Le chemin de test est utilisé comme chemin des sources lorsque vous
mettez en œuvre les fonctionnalités de test des unités de JBuilder.
• Le chemin des classes est utilisé pendant la compilation et à l’exécution,
ainsi que pour certaines fonctions de l’éditeur de JBuilder Entreprise.
• Le chemin de recherche sert dans l’EDI lorsque vous utilisez l’audit de
code ou Trouver la définition dans l’éditeur, lorsque vous effectuez des
recherches et lorsque vous déboguez.
• Le chemin de sortie contient les fichiers .class créés par JBuilder
lorsque vous compilez votre projet.
Voir aussi
Comment JBuilder trouve les fichiers pendant l’examen du

code source (“forage”)
Quand vous explorez le code source, JBuilder recherche les fichiers .java
en utilisant le chemin de recherche. Pour plus d’informations sur l’examen
du code source, voir “Navigation dans le code source”, page 5-10.
Comment JBuilder trouve les fichiers pendant la

compilation
Lorsque vous compilez votre projet, JBuilder utilise les chemins suivants :
• chemin des classes
• chemin des sources
• chemin de sortie
Dans le chemin des classes, JBuilder recherche l’emplacement des fichiers
.class, les bibliothèques à utiliser et la version JDK cible pour la
compilation. Le compilateur compare les fichiers .class avec leurs fichiers
source, qui se trouvent dans le chemin des sources, et détermine si les

fichiers .class doivent être recompilés pour être à jour. Les fichiers .class
obtenus sont placés dans le chemin de sortie spécifié.
Pour davantage d’informations sur la compilation des fichiers, voir
“Compilation des programmes Java” dans Construction d’applications avec
JBuilder.
Comment JBuilder trouve les fichiers classe pendant

l’exécution ou le débogage
Lorsque vous exécutez et déboguez votre programme, JBuilder utilise le
chemin des classes pour localiser toutes les classes utilisées par votre
programme.
Lorsque vous avancez dans le code avec le débogueur, JBuilder utilise le
chemin de recherche pour trouver les fichiers source.
Pour davantage d’informations sur le débogage des fichiers, voir
“Débogage des programmes Java” dans Construction d’applications avec
JBuilder.

Chapitre
Comparaison Chapitre9
9
des fichiers et versions
JBuilder fournit de nombreux moyens de comparer des fichiers, d’afficher
les différences entre différents fichiers et entre différentes versions d’un
même fichier, et de gérer, fusionner et restaurer les différences entre les
fichiers. La boîte de dialogue Comparaison de fichiers et les pages
Historique permettent d’accéder à ces fonctionnalités.
Glossaire relatif à la gestion des versions

Certains termes spécialisés sont utilisés dans cette section :
Terme Définition
révision, version Dans ce contexte, ces termes sont interchangeables. Chaque fois
que vous modifiez (ou révisez) un fichier, vous en créez une
nouvelle version (ou révision).
diff Abréviation de différence. Un diff est une zone de texte
différente entre deux fichiers ou entre deux versions d’un même
fichier.
bloc de diff Zone où il existe une différence entre deux fichiers ou deux
versions d’un fichier. Une vue diff permet de mieux voir les
différences car les deux fichiers ou versions d’un fichier sont
fusionnés dans une source apparente et les différences sont
marquées.
Les mécanismes de gestion des diff proposés par JBuilder
évaluent les fichiers physiquement, et non pas logiquement. Ils
comparent seulement le texte des fichiers ou versions, et non pas
leur structure logique ou de code.
restaurer Rétablir la version précédente d’un fichier.
Comparaison des fichiers et versions 9-1

Comparaison de deux fichiers
Terme Définition
contrôle de Moyen de gestion des révisions qui conserve l’enregistrement de
versions toutes les modifications apportées à chaque fichier sous le
contrôle du système de versions. Les systèmes de contrôle de
versions comportent également d’autres fonctionnalités de
gestion des codes telles que les branches et les libellés.
copie de Version enregistrée d’un fichier conservée dans le répertoire de
sauvegarde sauvegarde local de ce fichier.
JBuilder utilise les copies de sauvegarde comme versions
précédentes du fichier. Définissez le nombre de sauvegardes que
vous voulez conserver sur la page Editeur de Outils|Options de
l’éditeur. Quand la limite est atteinte, les versions les plus
récentes sont conservées et renumérotées en conséquence.
tampon Version de travail la plus récente utilisée dans JBuilder. Inclut les
modifications non enregistrées.
référentiel Dans le système de contrôle des versions, emplacement dans
lequel les versions du fichier maître et les historiques des
révisions sont conservés.
espace de travail Dans le système de contrôle des versions, fichiers locaux et
structure de répertoires que vous modifiez directement.

La boîte de dialogue Comparaison de fichiers de JBuilder vous permet de
comparer deux fichiers.
Pour comparer deux fichiers texte,
1 Choisissez Fichier|Comparer les fichiers. La boîte de dialogue
Sélection de l’ancien fichier apparaît :
2 Sélectionnez le premier fichier et cliquez sur OK. La boîte de dialogue

Sélection du nouveau fichier s’affiche.

3 Sélectionnez le second fichier et cliquez sur OK. La boîte de dialogue

Comparaison de fichiers apparaît :
La vue Source affiche les deux fichiers côte à côte. Réduisez l’écran dans
n’importe quelle direction en sélectionnant le bouton radio approprié.
Synchronisez le défilement entre les deux panneaux en cochant la case
Synchroniser le défilement.
La vue Source supporte les fonctions de base d’édition de texte. Ceci vous
permet d’apporter des modifications aux deux tampons. Si vous apportez
des modifications, les options du menu contextuel (clic droit) Recharger
nomfichier et Enregistrer nomfichier deviennent disponibles :
La vue Diff supporte la restauration de blocs de diff individuels. Le

premier fichier que vous choisissez apparaît en tant que version la plus
ancienne et le second fichier en tant que version la plus récente. Ainsi, si
l’ancien et le nouveau fichier ont deux blocs de texte différents dans la
même partie du fichier, JBuilder peut les rendre identiques en remplaçant
le bloc de texte du nouveau fichier par le bloc de texte correspondant dans
l’ancien fichier.
Si vous modifiez des fichiers en utilisant la boîte de dialogue
Comparaison de fichiers, le système vous demande d’enregistrer vos
modifications quand vous fermez la boîte de dialogue.

Utilisation de la vue historique

La vue historique vous montre les versions précédentes d’un fichier dans
tous les types de version de fichier disponibles, y compris les diverses
versions sauvegardées, les modifications enregistrées localement et le
tampon mémoire d’un fichier actif. Si le fichier en cours bénéficie du
contrôle de versions, tous les types de révisions sont disponibles dans la
vue historique ; sinon, la vue historique utilise les sauvegardes, les
modifications enregistrées et le tampon non enregistré pour vous
permettre de gérer les révisions.
La vue historique se trouvant dans le volet contenu, ses pages reflètent
l’état du fichier actif. Double-cliquez sur le fichier dans le volet projet pour
le rendre actif. Cliquez sur l’onglet d’un fichier ouvert dans le volet
contenu pour rendre actif ce fichier.
Il y a trois pages dans la vue Historique. Elles fournissent les fonctions
suivantes :
• La page Sommaire, disponible dans toutes les éditions de JBuilder,
affiche les versions actuelles et précédentes du fichier.
• La page Diff, disponible dans JBuilder Professionnel et JBuilder
Entreprise, affiche les différences entre les versions sélectionnées du
fichier.
• La page Info, disponible dans JBuilder Entreprise, affiche tous les
libellés et les commentaires concernant le fichier actif.
Ces trois pages contiennent des tableaux de révision présentant la liste de
toutes les versions du fichier actif. Les listes de révisions montrent le
numéro de version du fichier, le type et la date de révision et d’autres
informations. Vous pouvez trier les listes de révisions en cliquant sur
l’en-tête de colonne de la caractéristiques selon laquelle vous souhaitez
trier. JBuilder utilise les icônes suivantes dans les tables de révision pour
distinguer les différents types de versions :
Icône Description
Une version de sauvegarde du fichier.
La dernière version enregistrée du fichier.
La version du fichier qui se trouve dans le tampon mémoire. La version

du tampon inclut les modifications non sauvegardées.
Fonctionnalités de JBuilder Entreprise :
La version du fichier que vous avez extrait du référentiel.
Une version de fichier d’un système de contrôle de versions.

Astuce Lorsque votre curseur se trouve dans la liste des révisions, vous pouvez
faire défiler celle-ci en appuyant sur Entrée ou en utilisant les touches de
direction du clavier.
Les pages Sommaire et Diff possèdent un visualiseur source. Le
visualiseur source affiche le code source de la version de fichier
sélectionnée dans la liste des révisions. Vous pouvez copier et coller à
partir du visualiseur source dans l’éditeur, même si vous ne pouvez pas
modifier directement le visualiseur source. Cela simplifie la récupération
d’un travail précédent tout en protégeant l’intégrité des versions de
fichiers précédentes.
Rafraîchir l’information de révision

Le bouton Rafraîchir l’information de révision met à jour votre vue de la
liste des révisions pour inclure les modifications apportées par d’autres
utilisateurs au fichier du référentiel. Il est utile uniquement sous le
système de contrôle de versions. Ce bouton est disponible à partir des
trois pages Historique.
Restaurer la version précédente

La page Info est Lorsque vous appuyez sur le bouton Restaurer la version précédente, la
une fonctionnalité version que vous avez sélectionnée devient à nouveau la version la plus
de JBuilder Entreprise. courante. La version ancienne devient la plus récente. Ce bouton est
disponible à partir des pages Sommaire et Info.
Remarque La restauration d’une version précédente provoque la perte de toutes les
modifications non sauvegardées dans le tampon de l’éditeur. Sous le
contrôle de versions, toutes les versions intermédiaires sont conservées
dans le référentiel.
Synchroniser le défilement
La page Diff est Le bouton Synchroniser le défilement permet de synchroniser le
une fonctionnalité défilement entre les visualiseurs source des pages Sommaire, Diff ou
de JBuilder Professionnel Historique et l’éditeur. Il met en correspondace la ligne de texte qui
et de JBuilder Entreprise. contient le curseur et la ligne de texte la plus proche dans l’autre vue. S’il
ne trouve aucun texte correspondant dans cette partie du fichier, il met en
correspondance les numéros de lignes. Ce bouton est disponible dans les
pages Sommaire et Diff.
Synchroniser le défilement est aussi une case à cocher de la boîte de
dialogue Fichier|Comparaison de fichiers.

Page Sommaire
La page Sommaire de la vue historique affiche toutes les versions
disponibles du fichier actif. La liste des révisions en haut de l’écran vous
permet de trier les versions des fichiers par type de version, numéro de
révision, libellé, date de modification ou auteur. Cliquez sur un en-tête
pour effectuer le tri en fonction de cet en-tête. Cliquez de nouveau sur
l’en-tête pour inverser le tri. Sélectionnez une version dans la liste des
révisions pour voir son source dans le visualiseur source :
Les boutons Rafraîchir l’information de révision, Restaurer la révision

précédente et Synchroniser le défilement sont activés sur cette page.
Page Diff
Fonctionnalité La page Diff affiche les différences entre deux versions sélectionnées du
de JBuilder Professionnel fichier actif. La liste des révisions en haut de l’écran vous permet de trier
et de JBuilder Entreprise. les versions de fichiers par type de version, numéro de révision ou date de
modification. Les boutons Rafraîchir l’information de révision et
Synchroniser le défilement sont activés sur cette page.
Il existe deux listes de révisions dans la page Diff : la liste Depuis et la liste
Vers. Sélectionnez une version dans la liste Depuis et une autre version

dans la liste Vers. Les différences seront affichées dans le visualiseur

source situé sous les listes :
Dans chaque bloc de différences, la suppression diff (avec le signe moins)

est en rouge et l’ajout diff (avec le signe plus) est en jaune. Si le tampon est
sélectionné comme version Vers, annulez un ajout en cliquant sur le
bouton Annuler dans la gouttière.
Utilisez les flèches diff pour vous déplacer entre les blocs diff. Vous
pouvez également utiliser Alt + n pour déplacer le curseur vers le bloc de
différences suivant, ou Alt + p pour le déplacer vers le bloc de différences
précédent.
Astuce Les utilisateurs du contrôle de versions peuvent voir toutes les
modifications apportées au référentiel depuis l’extraction initiale.
Sélectionnez la version initiale du référentiel dans la zone Depuis et la
version du fichier portant le plus grand numéro de version dans la zone
Vers. JBuilder met à jour la version la plus récente avec les modifications
du référentiel.
Page Info
Fonctionnalité La page Info de la vue historique affiche le texte complet des libellés et des
de JBuilder Entreprise. commentaires pour une version sélectionnée quelconque du fichier actif.
La liste des révisions en haut de l’écran vous permet de trier les versions
de fichiers par type de version, numéro de révision, libellé, date de

modification, auteur ou commentaire. Les boutons Rafraîchir

l’information de révision et Restaurer la révision précédente sont activés
sur cette page.
Pour utiliser la page Info, sélectionnez une version dans la liste des
révisions. Son libellé (le cas échéant) et les commentaires entrés pour
décrire la révision sont affichés dans la partie inférieure de la page :
La page Info est un outil d’examen. Elle vous permet d’examiner les
commentaires de toutes les révisions d’un fichier pour que vous puissiez
avoir un aperçu des modifications apportées à ce fichier.
Pour plus d’informations sur ces fonctionnalités, appuyez sur F1 dans
n’importe quelle page de la vue historique. Ceci affiche l’aide contextuelle
du volet contenu. Sélectionnez Historique dans le tableau de l’aide
contextuelle.

Chapitre
Tutoriel : Construction
Chapitre10
10
d’une application
Ce tutoriel vous permet de vous familiariser avec l’environnement de
développement intégré (EDI) de JBuilder. Le tutoriel montre comment :
• Créer un projet pour l’application.
• Créer une application simple, “Hello World”.
• Compiler et exécuter l’application.
• Modifier l’interface utilisateur d’une application.
• Ajouter des composants Swing, comme JPanel, JLabel et JButton.
• Modifier le code source.
• Exécuter l’application depuis la ligne de commande.
• Ajouter à un bouton une méthode d’événement.
• Compléter l’interface utilisateur.
Fonctionnalités • Regrouper les fichiers en vue du déploiement.
• Exécuter l’application déployée depuis la ligne de
commande. Pour plus d’informations sur les conventions de la
documentation, voir “Conventions de la documentation”, page 1-2.
Le code source complet se trouve dans “Code source de HelloWorld”,
page 10-22.
Tutoriel : Construction d’une application 10-1

Etape 1 : Création du projet

Avant de créer une application dans JBuilder, vous devez créer un projet
dans lequel travailler. JBuilder utilise un fichier projet (.jpx ou .jpr) pour
organiser les fichiers de l’application et maintenir les paramètres de
fonctionnement et les propriétés du projet. L’expert projet peut créer le
projet à votre place.
1 Choisissez Fichier|Nouveau projet pour ouvrir l’expert projet.
2 Apportez les modifications suivantes aux champs appropriés dans au
cours de l’étape 1 de l’expert projet.
1 Nom : HelloWorld
Remarque Au fur et à mesure que vous tapez dans le champ Nom, le même
nom est entré par défaut dans le champ Répertoire. Par défaut,
JBuilder utilise ce nom de projet pour composer les noms du
répertoire et du paquet des classes du projet. Le nom de paquet est
passé en minuscules pour respecter les conventions d’appellation
des paquets Java. Par défaut, JBuilder enregistre les projets dans le
répertoire /<home>/jbproject/. Le répertoire home dépend de la
plate-forme. Voir “Conventions utilisées par la documentation” dans
l’aide en ligne. Pour plus d’information sur les projets, voir
Chapitre 7, “Création et gestion des projets”.
2 Type (type de fichier) : .jpx ou .jpr
Remarque JBuilder utilise une extension .jpx ou .jpr pour les fichiers projet. Le
type de fichier .jpx, un fichier projet XML, est utilisé dans un
environnement de développement en équipe et pour le contrôle de
versions. Le type de fichier .jpr est d’emploi général. Les deux types
de fichiers fonctionnent pour ce tutoriel.
3 Cochez l’option Créer un fichier de notes pour le projet. Lorsque
vous sélectionnez cette option, l’expert projet crée un fichier HTML
pour les annotations du projet et l’ajoute à celui-ci.

L’étape 1 de l’expert projet doit ressembler à ceci :
3 Acceptez toutes les autres valeurs par défaut de l’étape 1.

4 Cliquez sur Suivant pour passer à l’étape 2 de l’expert projet.
5 Acceptez les chemins par défaut proposés à l’étape 2. Notez où sont
enregistrés les fichiers classes compilées, projet et sources. Pour plus
d’informations sur les chemins d’accès et sur la façon dont JBuilder
enregistre les fichiers, voir Chapitre 8, “Gestion des chemins d’accès”.
6 Cliquez sur Suivant pour passer à l’étape 3 de l’expert.

7 Apportez les modifications suivantes dans les champs appropriés de

l’étape 3 :
1 Acceptez les valeurs proposées par défaut pour Encodage et Paquets
source automatiques.
L’option Paquets source 2 Entrez HelloWorld dans le champ Titre des champs Javadoc classe.
automatiques est
une fonctionnalité
3 Entrez votre nom et celui de votre société, ainsi que la description de
votre application, dans les champs facultatifs appropriés.
Remarque L’information contenue dans les champs Javadoc classe apparaît
dans le fichier HTML du projet et comme commentaires d’en-tête
facultatifs dans le code source.
L’étape 3 de l’expert projet doit ressembler à ceci :
8 Cliquez sur le bouton Terminer. Deux fichiers, HelloWorld.jpx et

HelloWorld.html, sont générés par l’expert et apparaissent dans le volet
projet situé dans la partie supérieure gauche de l’AppBrowser.
Voir aussi
9 Double-cliquez sur HelloWorld.html, le fichier de notes du projet, pour le
voir dans le volet contenu situé au centre de l’AppBrowser. Remarquez
qu’il contient les informations du projet sur le nom, l’auteur, la société
et la description saisies à l’étape 3 de l’expert projet.

Etape 2 : Génération de vos fichiers source

L’expert application crée les fichiers source .java qui seront ajoutés au
projet que vous venez de créer.
Pour générer les fichiers source de votre application en utilisant l’expert
application, procédez comme suit :
1 Sélectionnez Fichier|Nouveau ou cliquez sur le bouton Nouveau dans
la barre d’outils principale pour ouvrir la galerie d’objets.
2 Choisissez l’onglet Nouveau et double-cliquez sur l’icône Application

pour ouvrir l’expert application.
3 Acceptez le nom de paquet par défaut, helloworld, dans l’étape 1 de
l’expert application. Par défaut, l’expert dérive le nom du paquet du
nom du fichier projet, HelloWorld.jpx.
4 Entrez HelloWorldClasse dans le champ Classe. C’est un nom de classe
Java qui distingue les majuscules des minuscules.
5 Cochez Générer les commentaires d’en-tête. Quand vous sélectionnez
cette option, les informations des notes du projet qui ont été entrées à
l’étape 3 de l’expert projet apparaissent au début de tous les fichiers
source générés par l’expert application.

L’étape 1 de l’expert application doit ressembler à ceci :
6 Cliquez sur le bouton Suivant pour atteindre l’étape 2 de l’expert

application.
7 Entrez HelloWorldCadre dans le champ Classe pour nommer la classe
Cadre.
8 Entrez Hello World dans le champ Titre. Ce texte apparaît dans la barre
de titre du cadre de votre application.
9 Cochez toutes les options correspondant aux fonctionnalités que vous
voulez ajouter à votre application : Créer la barre de menus, Créer la
barre d’outils, Créer la barre d’état, Créer la boîte de dialogue A propos
et Centrer le cadre à l’écran. L’expert génère le code de base gérant ces
fonctionnalités.
L’étape 2 de l’expert application doit ressembler à ceci :

10 Cliquez sur le bouton Terminer.

Les nouveaux fichiers source .java et les images de la barre d’outils sont
ajoutés à votre projet et affichés en tant que nœuds dans le volet projet.
Le code source de HelloWorldCadre.java est ouvert dans le volet contenu
comme le montre l’image suivante.
Remarque Dans les éditions JBuilder Professionnel et JBuilder Entreprise, un
nœud de paquet source automatique, appelé helloworld, apparaît
également dans le volet projet lorsque l’option Activer
automatiquement les paquets source est sélectionnée dans la page
Général de la boîte de dialogue Propriétés du projet (Projet|Propriétés
du projet).
Figure 10.1 Eléments de l’AppBrowser
11 Choisissez Fichier|Tout enregistrer pour enregistrer les fichiers source

et le fichier projet.
Remarque Les fichiers source sont enregistrés dans :
/<home>/jbproject/HelloWorld/src/helloworld
Les fichiers classe générés par le compilateur Java à partir des fichiers
source sont enregistrés dans : /<home>/jbproject/HelloWorld/classes/
helloworld

Etape 3 : Compilation et exécution de votre application

Maintenant, compilez et exécutez votre application. La compilation
consiste à exécuter le compilateur Java. Le compilateur, qui traduit le code
source en bytecode Java, génère des fichiers .class.
1 Choisissez Exécuter|Exécuter le projet ou cliquez sur le bouton
Exécuter pour compiler et exécuter votre application.
Astuce Vous pouvez aussi sélectionner HelloWorldClasse.java dans le volet
projet, cliquer avec le bouton droit et sélectionner Exécuter.
D’abord, le volet message s’ouvre en montrant le processus
d’exécution. Ensuite, votre application s’affiche ; elle doit ressembler
à ceci :
Remarque L’application qui s’exécute dans ce tutoriel reflète l’apparence

Windows.
2 Choisissez Fichier|Quitter dans l’application “Hello World” pour
fermer celle-ci.
3 Cliquez avec le bouton droit sur l’onglet HelloWorldClasse dans le
volet message en bas de l’AppBrowser et sélectionnez Retirer l’onglet
“HelloWorldClasse” pour fermer tous les messages.
Etape 4 : Personnalisation de l’interface utilisateur de votre

application
Suivez les étapes ci-dessous pour personnaliser l’interface utilisateur de
votre application.
1 Double-cliquez sur HelloWorldCadre.java dans le volet projet s’il n’est
pas déjà ouvert.
2 Cliquez sur l’onglet Conception en bas du volet contenu pour passer
dans la vue conception. Le concepteur d’interface utilisateur apparaît
dans le volet contenu, la palette de composants au-dessus de lui et

Etape 4 : Personnalisation de l’interface utilisateur de votre application
l’inspecteur à sa droite. Utilisez la palette des composants pour ajouter

des composants à votre interface utilisateur et l’inspecteur pour
modifier les propriétés et ajouter des événements à votre code. Le volet
structure, situé à gauche du volet contenu, affiche désormais une
arborescence de composants et de dossiers, tels que Interface
utilisateur, Menu et Autre.
Figure 10.2 Eléments du concepteur d’interface utilisateur
3 Cliquez sur l’onglet Conteneurs Swing dans la palette des composants,

au-dessus du concepteur d’interface utilisateur, et choisissez le
composant JPanel pour ajouter un panneau à votre conception.
Astuce Placez le curseur sur un composant de la palette pour voir son nom
s’afficher dans une bulle d’aide.
4 Cliquez au centre du cadre, dans le concepteur d’interface utilisateur,

pour lâcher le composant au centre du cadre de conception.

Etape 4 : Personnalisation de l’interface utilisateur de votre application
Remarque La propriété constraints, dans l’inspecteur, doit avoir la valeur Center.

Sinon, cliquez sur la colonne de droite de la propriété constraints et
choisissez Center dans la liste déroulante.
jPanel1 est désormais sélectionné dans la conception de votre
application, ainsi que dans l’arborescence des composants.
Remarque Le composant sélectionné dans l’arborescence des composants ou dans

le concepteur d’interface utilisateur s’affiche dans la barre d’état, en bas
du volet structure.
5 Définissez par White la couleur du fond de jPanel1.
1 Cliquez dans l’inspecteur sur la colonne située à droite de la
propriété background.
2 Cliquez sur la flèche vers le bas pour ouvrir la liste déroulante des
couleurs et sélectionnez White au début de celle-ci.
Remarque Si vous cliquez trop à droite de la colonne, la boîte de dialogue
Background s’ouvrira. Vous pouvez y choisir le blanc en entrant 255
pour chacune des composantes couleur (Rouge, Vert, Bleu).
6 Ajoutez une bordure de ligne à jPanel1 et changez sa couleur en Gray.
1 Cliquez dans l’inspecteur sur la colonne à droite de la propriété
border.
bordures et sélectionnez Line.
3 Sélectionnez le bouton Points de suspension pour accéder à la boîte
de dialogue Bordure.
4 Cliquez sur Black dans Options|Couleur pour accéder à la liste
déroulante et sélectionnez Gray.
5 Cliquez sur OK pour fermer la boîte de dialogue Bordure.
7 Changez le gestionnaire de disposition de jPanel1 en null.
layout.

Etape 5 : Ajout d’un composant à votre application
2 Choisissez null dans la liste déroulante.

null, c’est à dire aucune disposition, est un bon choix lorsque vous
prototypez votre conception. Comme null n’utilise aucun
gestionnaire de disposition, vous pouvez placer les composants
exactement ou vous voulez qu’ils soient. Mais, null utilisant le
positionnement absolu des composants, et non le positionnement
relatif, l’interface utilisateur ne se redimensionne pas correctement
lorsque l’utilisateur change la taille de la fenêtre de l’application. De
ce fait, il est conseillé de ne jamais laisser un conteneur en null pour
le déploiement. Plus tard dans ce tutoriel, vous pourrez choisir une
disposition portable appropriée à votre conception et son
déploiement.
8 Choisissez Fichier|Tout enregistrer pour enregistrer le projet.
Etape 5 : Ajout d’un composant à votre application

Vous allez maintenant utiliser la palette des composants pour ajouter un
composant JLabel au composant JPanel.
1 Sélectionnez l’onglet Swing dans la palette des composants et cliquez
sur le composant JLabel.
2 Placez le composant dans le panneau JPanel de votre conception en

utilisant une des deux méthodes suivantes :
• Cliquez sur jPanel1 dans l’arborescence des composants. Cela place
le composant dans le coin supérieur gauche du panneau.
• Cliquez sur jPanel1 dans le concepteur. Le coin supérieur gauche du
composant se place là où vous avez cliqué.
Notez que jLabel1 est ajouté sous jPanel1 dans l’arborescence des
composants. Si vous avez lâché le composant à un mauvais
emplacement, vous pouvez le sélectionner, dans l’arborescence des
composants ou dans le concepteur, et appuyer sur la touche Suppr.
Ensuite, ajoutez-le à nouveau.
3 Cliquez au milieu du composant libellé dans le concepteur, et faites-le
glisser au centre du panneau.
4 Sélectionnez jLabel1 dans l’arborescence des composants et suivez les
étapes ci-dessous :
1 Double-cliquez dans l’inspecteur sur la colonne à droite de la
propriété text. Tapez Hello World! Appuyez sur Entrée.

Etape 6 : Modification de votre code source
“Hello World!” apparaît alors dans le libellé. Ne vous inquiétez pas

s’il n’apparaît pas complètement dans le libellé. Vous corrigerez ce
problème en changeant de fonte.
2 Cliquez sur la colonne de droite de la propriété font pour définir la
fonte. Cliquez sur le bouton Points de suspension pour ouvrir la
boîte de dialogue.
3 Choisissez Serif dans la liste des fontes. Cochez Gras et Italique.
Entrez 28 dans la boîte Taille. Cliquez sur OK.
4 Retaillez jLabel1 en faisant glisser les poignées noires jusqu’à ce que
“Hello World!” soit complètement visible.
foreground pour définir la couleur du texte “Hello World!”. Cliquez
sur la flèche vers le bas et sélectionnez Blue dans la liste déroulante des
couleurs.
Votre conception doit ressembler à ceci :
5 Choisissez Fichier|Tout enregistrer.

Vous pouvez changer les informations de la boîte de dialogue A propos,
en modifiant directement le code. Par défaut, la version créée par l’expert
application est la version 1.0.

1 Double-cliquez sur HelloWorldCadre_AboutBox.java dans le volet projet

pour ouvrir le fichier. Le volet contenu se transforme en une vue source
où vous pouvez modifier le code dans l’éditeur.
2 Choisissez Chercher|Chercher. Entrez la ligne de code suivante dans la
boîte de dialogue Chercher/Remplacer du texte :
String version = "1.0";
3 Cliquez sur Chercher. L’éditeur trouve le texte sélectionné.
4 Sélectionnez 1.0 et saisissez 2.0 entre les guillemets.


Vous pouvez maintenant compiler et exécuter l’application.
1 Choisissez Projet|Construire le projet pour compiler le projet.
2 Choisissez Exécuter|Exécuter le projet.

Etape 8 : Exécution de votre application depuis la ligne de commande
L’application “Hello World” s’affiche :
3 Choisissez Aide|A propos. Les informations de version que vous avez

modifiées s’affichent dans la boîte de dialogue A propos.
4 Cliquez sur OK pour fermer la boîte de dialogue.

5 Choisissez Fichier|Quitter dans votre application “Hello World” pour
la fermer.
Etape 8 : Exécution de votre application depuis la ligne de

commande
Vous pouvez aussi exécuter l’application hors de l’environnement de
JBuilder, depuis la ligne de commande.
Remarque Le répertoire <jdk>/bin/ qui contient la commande java doit se trouver
dans votre chemin d’accès. Si java est dans votre chemin d’accès, lorsque
vous saisissez java sur la ligne de commande, des informations expliquant
la commande doivent s’afficher. Si ce n’est pas le cas, vous devez exécuter
l’application depuis le répertoire <jdk>/bin/.
Pour exécuter l’application, en supposant que java fait partie de votre
commande path,
1 Ouvrez la fenêtre de la ligne des commandes.

Etape 9 : Ajout d’un événement à un bouton
2 Exécutez l’application en saisissant ce qui suit sur la ligne de l’invite de

commande :
java -classpath
/<home>/jbproject/HelloWorld/classes helloworld.HelloWorldClasse
Remarque Pour Windows, utilisez une barre oblique inverse (\).
Cette commande est de la forme :
java -classpath cheminclasses nom-paquet.nom-classe-principale
Dans cet exemple,
• java = le lanceur de l’application Java
• -classpath = une option qui définit le chemin de recherche des classes
et des ressources de l’application.
• cheminclasses = /<home>/jbproject/HelloWorld/classes
cheminclasses doit pointer sur le répertoire contenant les classes
compilées. Dans cet exemple, le répertoire classes a été défini comme
chemin de destination des classes compilées à l’étape 1 de l’expert
projet.
• <home> = votre répertoire de base, par exemple, c:\winnt\profiles\
<nomutilisateur>
• nom-paquet = helloworld
• nom-classe-principale = HelloWorldClasse
3 Fermez l’application “Hello World”.
Voir aussi
• “Setting the classpath” dans la documentation sur les outils Java
• “Basic tools” à l’adresse http://java.sun.com/j2se/1.3/docs/tooldocs/
tools.html

Nous allons maintenant ajouter un composant Swing à votre application.
1 Ouvrez HelloWorldCadre.java, puis cliquez sur l’onglet Conception pour
passer dans le concepteur d’interface utilisateur.
2 Cliquez sur le composant JButton dans l’onglet Swing de la palette des
composants et lâchez-le soit sur jPanel1 dans l’arborescence des
composants, soit sur le panneau lui-même dans votre conception.
jButton4 est ajouté sous jPanel1 dans l’arborescence des composants.

3 Cliquez sur jButton4 dans le concepteur et faites-le glisser au centre de

la partie supérieure de votre conception, comme le montre l’image
ci-après.
4 Dans l’inspecteur, changez la valeur de la propriété Text de jButton4 en

Appuyer. Appuyez sur Entrée. Agrandissez le bouton en faisant glisser les
poignées noires jusqu’à ce que “Appuyer” soit complètement visible.
L’inspecteur doit ressembler à ceci :
5 Cliquez sur l’onglet Evénements de l’inspecteur pour définir ce qui doit

se passer lorsque jButton4 est enfoncé.
6 Double-cliquez sur la colonne située à droite de l’événement
ActionPerformed.
JBuilder va dans l’éditeur là où a été ajouté le squelette de code pour
l’événement ActionPerformed.
void jButton4_actionPerformed(ActionEvent e) {

Etape 10 : Fin de la conception de votre interface utilisateur
Vous pouvez alors entrer votre code et définir l’événement.

7 Tapez le code suivant indiqué en gras :
jLabel1.setForeground(new Color(255,0,0));
}
Astuce Utilisez l’audit de code pour écrire le code. Tapez jLabel1. et attendez la
fenêtre surgissante ou appuyez sur Ctrl+barre d’espace pour l’appeler. Si
l’audit de code n’apparaît pas, vérifiez le paramétrage de la page Audit
de code dans la boîte de dialogue Options de l’éditeur (Outils|Options
de l’éditeur). Tapez setfor pour mettre en évidence setForeground(Color)
dans la fenêtre surgissante ou utilisez les flèches de direction. Appuyez
sur Entrée.
Maintenant, lorsque vous exécutez l’application et appuyez sur le
bouton “Appuyer”, “Hello World!” doit apparaître en rouge.
9 Choisissez Projet|Construire le projet.
10 Choisissez Exécuter|Exécuter le projet.
11 Cliquez sur le bouton “Appuyer”. La couleur du texte “Hello World!”
devient rouge.
12 Choisissez Fichier|Quitter pour fermer l’application “Hello World”.

La dernière étape de la construction de votre application consiste à
changer sa disposition en une disposition portable. N’oubliez pas que, si
vous laissez jPanel1 en null, c’est-à-dire sans disposition, les composants
de votre interface utilisateur ne se repositionnent pas lorsque l’utilisateur
change la taille de la fenêtre de l’application pendant l’exécution. null
utilisant le positionnement absolu des composants, ceux-ci conservent la
même place quelle que soit la taille de la fenêtre. De ce fait, null n’est pas

un gestionnaire de disposition approprié au déploiement final de votre

application.
Pour illustrer ce problème de redimensionnement de la fenêtre avec null,
exécutez l’application comme ci-dessous :
1 Cliquez avec le bouton droit sur HelloWorldClasse.java, qui contient la
méthode main(), et choisissez Exécuter.
2 Changez les dimensions de la fenêtre de l’application “Hello World”,
en l’augmentant et en la diminuant, et observez le comportement des
composants. Notez que les composants libellé et bouton ne se déplacent
pas lorsque vous retaillez la fenêtre, car leur position est absolue et non
realative à la taille de la fenêtre.

Les dispositions portables, au contraire de null, utilisent le
positionnement relatif, qui est dynamique. Dans les dispositions
portables, les composants se repositionnent correctement lorsque
l’utilisateur retaille la fenêtre de l’application. Dans cet exemple, vous
changerez la disposition en GridBagLayout. Pour plus d’informations sur les
dispositions, voir “Utilisation des gestionnaires de dispositions” dans
Conception d’interfaces utilisateur avec JBuilder.
1 Revenez au fichier HelloWorldCadre.java dans le volet contenu, puis
cliquez sur l’onglet Conception pour passer dans le concepteur.
2 Choisissez jPanel1 dans l’arborescence des composants.
3 Choisissez l’onglet Propriétés de l’inspecteur.
4 Changez la propriété layout de jPanel1 en GridBagLayout dans
l’inspecteur. Sélectionnez chaque composant dans le concepteur et
notez la zone de la grille qu’il occupe.
GridBagLayout est un choix approprié à la disposition sur une grille de
composants de tailles variées. V oir “GridBagLayout” dans Conception
d’interfaces utilisateur avec JBuilder.
5 Enregistrez et exécutez l’application.

Etape 11 : Préparation de l’application pour son déploiement
6 Retaillez la fenêtre de l’application et remarquez comment les

composants se repositionnent lorsque changent les dimensions de la
fenêtre.

Les étapes 11 et 12 utilisent des fonctionnalités offertes par JBuilder
Professionnel et JBuilder Entreprise. Si vous utilisez JBuilder Personnel, ce
tutoriel est terminé.

Poursuivez les exercices Le Constructeur d’archives rassemble tous les fichiers requis pour
de ce tutoriel si vous êtes distribuer votre programme et peut les archiver dans un fichier archive
en possession d’une Java (fichier JAR).
version Professionnel ou
Entreprise de JBuilder. Pour déployer votre application :
1 Choisissez Experts|Constructeur d’archives pour ouvrir le
Constructeur d’archives.
2 Sélectionnez Application dans la liste déroulante Type d’archive.


4 Acceptez le nom par défaut de l’archive et le chemin par défaut du
fichier JAR. Notez que HelloWorld.jar sera enregistré dans le répertoire
HelloWorld.
5 Acceptez les valeurs par défaut de l’étape 3 à l’étape 5 en cliquant sur

Suivant pour atteindre l’étape d’après.
6 Cliquez sur Terminer à l’étape 6 pour fermer le Constructeur
d’archives. Un nœud d’archive nommé Application apparaît dans le
volet projet. Vous pouvez modifier ce fichier en cliquant dessus avec le
bouton droit et en sélectionnant Propriétés.
7 Cliquez avec le bouton droit sur le nœud Application et choisissez
Construire, ou bien choisissez Projet|Construire le projet pour
compiler votre application et générer le fichier JAR. Le Constructeur
d’archives rassemble tous les fichiers du chemin de sortie du projet
(Projet|Propriétés du projet|Chemins) dans le fichier JAR.
8 Cliquez sur l’icône de développement à côté du nœud d’archive
Application pour développer le nœud et voir le fichier archive
HelloWorld.jar. Double-cliquez sur le fichier JAR dans le volet projet.

Etape 12 : Exécution de l’application déployée depuis la ligne de commande
Le fichier manifest apparaît dans le volet contenu et le contenu du

fichier JAR apparaît dans le volet structure.
9 Enregistrez votre projet.

Pour plus d’informations sur le déploiement, voir “Déploiement des
programmes Java” dans Construction d’applications avec JBuilder.
Etape 12 : Exécution de l’application déployée depuis la ligne de

commande
Poursuivez les exercices Pour tester l’application déployée, vous pouvez exécuter le fichier JAR
de ce tutoriel si vous êtes depuis la ligne de commande.
en possession d’une
version Professionnel ou
Entreprise de JBuilder.
Remarque Le répertoire <jdk>/bin/ qui contient la commande java doit se trouver
dans votre chemin d’accès. Si java est dans votre chemin d’accès, lorsque
vous saisissez java sur la ligne de commande, des informations expliquant
la commande doivent s’afficher. Si ce n’est pas le cas, vous devez exécuter
l’application depuis le répertoire <jdk>/bin/.
2 Entrez la commande suivante sur la ligne de l’invite de commande :
java -classpath /<home>/jbproject/HelloWorld/HelloWorld.jar
helloworld.HelloWorldClasse
Remarque Pour Windows, utilisez une barre oblique inverse (\).
La commande doit respecter la syntaxe :
java -classpath cheminclasses nom-paquet.nom-classe-principale

Code source de HelloWorld
Dans cet exemple,

• java = le lanceur de l’application Java
• -classpath = une option qui définit le chemin de recherche des classes
et des ressources de l’application.
• cheminclasses = /<home>/jbproject/HelloWorld/HelloWorld.jar
cheminclasses doit inclure le fichier JAR et son emplacement correct.
Dans cet exemple, le fichier JAR est placé dans le répertoire du
projet, HelloWorld. Le Constructeur d’archives l’enregistre par défaut
à cet emplacement.
• <home> = votre répertoire de base, par exemple, c:\winnt\profiles\
<nomutilisateur>
• nom-paquet = helloworld
• nom-classe-principale = HelloWorldClasse
Pour plus d’informations sur les fichiers JAR, voir le tutoriel JAR à
l’adresse
http://java.sun.com/docs/books/tutorial/jar/index.html.
3 L’application “Hello World” se charge et s’exécute.
Bravo. Vous venez de créer votre première application avec JBuilder.
Maintenant que vous êtes familier de l’environnement de développement
de JBuilder, vous allez constater que ses nombreuses fonctionnalités
facilitent la programmation et vous font gagner du temps.
Pour trouver d’autres tutoriels sur la conception d’interfaces utilisateur
dans JBuilder, voir “Editeur de texte”, “GridBagLayout” et “Dispositions
imbriquées” dans Conception d’interfaces utilisateur avec JBuilder.

Code source de HelloWorldCadre.java
package helloworld;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;
/**
* Titre : HelloWorld
* Description : Voici le tutoriel "HelloWorld".
* Copyright: Copyright (c) 2001
* Société : Ma Société

* @author Mon Nom

* @version 1.0
*/
public class HelloWorldCadre extends JFrame {

JPanel contentPane;
JMenuBar jMenuBar1 = new JMenuBar();
JMenu jMenuFile = new JMenu();
JMenuItem jMenuFileExit = new JMenuItem();
JMenu jMenuHelp = new JMenu();
JMenuItem jMenuHelpAbout = new JMenuItem();
JToolBar jToolBar = new JToolBar();
JButton jButton1 = new JButton();
ImageIcon image1;
ImageIcon image2;
ImageIcon image3;
JLabel statusBar = new JLabel();
BorderLayout borderLayout1 = new BorderLayout();
JPanel jPanel1 = new JPanel();
Border border1;
JLabel jLabel1 = new JLabel();
GridBagLayout gridBagLayout1 = new GridBagLayout();
/**Construire le cadre*/
public HelloWorldCadre() {
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
catch(Exception e) {
e.printStackTrace();
}
}
/**Initialiser le composant*/
private void jbInit() throws Exception {
image1 = new
ImageIcon(helloworld.HelloWorldCadre.class.getResource("openFile.gif"));
image2 = new
ImageIcon(helloworld.HelloWorldCadre.class.getResource("closeFile.gif"));
image3 = new
ImageIcon(helloworld.HelloWorldCadre.class.getResource("help.gif"));
//setIconImage(Toolkit.getDefaultToolkit().createImage
(HelloWorldFrame.class.getResource("[Votre icône]")));
contentPane = (JPanel) this.getContentPane();
border1 = BorderFactory.createLineBorder(Color.gray,2);
contentPane.setLayout(borderLayout1);
this.setSize(new Dimension(400, 300));
this.setTitle("Hello World");
statusBar.setText(" ");
jMenuFile.setText("Fichier");
jMenuFileExit.setText("Quitter");
jMenuFileExit.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

jMenuFileExit_actionPerformed(e);
}
});
jMenuHelp.setText("Aide");
jMenuHelpAbout.setText("A propos");
jMenuHelpAbout.addActionListener(new ActionListener() {
jMenuHelpAbout_actionPerformed(e);
}
});
jButton1.setIcon(image1);
jButton1.setToolTipText("Ouvrir un fichier");
jButton2.setToolTipText("Fermer le fichier");
jButton3.setToolTipText("Aide");
jPanel1.setBackground(Color.white);
jPanel1.setBorder(border1);
jPanel1.setLayout(gridBagLayout1);
jLabel1.setFont(new java.awt.Font("Serif", 3, 28));
jLabel1.setForeground(Color.blue);
jLabel1.setText("Hello World!");
jButton4.setText("Appuyer");
jButton4.addActionListener(new java.awt.event.ActionListener() {
jButton4_actionPerformed(e);
}
});
jToolBar.add(jButton1);
jMenuFile.add(jMenuFileExit);
jMenuHelp.add(jMenuHelpAbout);
jMenuBar1.add(jMenuFile);
jMenuBar1.add(jMenuHelp);
this.setJMenuBar(jMenuBar1);
contentPane.add(jToolBar, BorderLayout.NORTH);
contentPane.add(statusBar, BorderLayout.SOUTH);
contentPane.add(jPanel1, BorderLayout.CENTER);
jPanel1.add(jLabel1, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0
,GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(45, 125,
102, 110), 10, -6));
jPanel1.add(jButton4, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0
,GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(46,
148, 0, 149), 16, 0));
}
/**Opération Fichier|Quitter effectuée*/
public void jMenuFileExit_actionPerformed(ActionEvent e) {
System.exit(0);
}
/**Opération Aide|A propos effectuée*/
public void jMenuHelpAbout_actionPerformed(ActionEvent e) {
HelloWorldCadre_AboutBox dlg = new HelloWorldCadre_AboutBox(this);

Dimension dlgSize = dlg.getPreferredSize();

Dimension frmSize = getSize();
Point loc = getLocation();
dlg.setLocation((frmSize.width - dlgSize.width) / 2 + loc.x,
(frmSize.height - dlgSize.height) / 2 + loc.y);
dlg.setModal(true);
dlg.show();
}
/**Remplacé, ainsi nous pouvons sortir quand la fenêtre est fermée*/
protected void processWindowEvent(WindowEvent e) {
super.processWindowEvent(e);
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
jMenuFileExit_actionPerformed(null);
}
}
jLabel1.setForeground(new Color(255,0,0));
}
}
Code source de HelloWorldClasse.java

package helloworld;
import javax.swing.UIManager;
import java.awt.*;
/**
* @author Mon Nom
* @version 1.0
*/
public class HelloWorldClasse {

boolean packFrame = false;
/**Construire l’application*/
public HelloWorldClasse() {
HelloWorldCadre frame = new HelloWorldCadre();
//Valider les cadres ayant des tailles prédéfinies
//Compacter les cadres ayant des infos de taille préférées - ex. depuis
//leur disposition
if (packFrame) {
frame.pack();
}
else {
frame.validate();
}
//Centrer la fenêtre

Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();

Dimension frameSize = frame.getSize();
if (frameSize.height > screenSize.height) {
frameSize.height = screenSize.height;
}
if (frameSize.width > screenSize.width) {
frameSize.width = screenSize.width;
}
frame.setLocation((screenSize.width - frameSize.width) / 2,
(screenSize.height - frameSize.height) / 2);
frame.setVisible(true);
}
/**Méthode principale*/
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
}
}
new HelloWorldClasse();
}
}
Code source de HelloWorldCadre_AboutBox.java

package helloworld;
import java.awt.*;
import javax.swing.*;
import javax.swing.border.*;
/**
* @author Mon Nom
* @version 1.0
*/
public class HelloWorldCadre_AboutBox extends JDialog implements ActionListener

{
JPanel panel1 = new JPanel();

JPanel panel2 = new JPanel();
JPanel insetsPanel1 = new JPanel();
JButton button1 = new JButton();
JLabel imageLabel = new JLabel();
JLabel label1 = new JLabel();


FlowLayout flowLayout1 = new FlowLayout();
GridLayout gridLayout1 = new GridLayout();
String product = "";
String version = "2.0";
String copyright = "Copyright (c) 2001";
String comments = "";
public HelloWorldCadre_AboutBox(Frame parent) {
super(parent);
enableEvents(AWTEvent.WINDOW_EVENT_MASK);
try {
jbInit();
}
}
pack();
}
//imageLabel.setIcon(new
ImageIcon(HelloWorldFrame_AboutBox.class.getResource("[Votre image]")));
this.setTitle("A propos");
setResizable(false);
panel1.setLayout(borderLayout1);
insetsPanel1.setLayout(flowLayout1);
insetsPanel2.setLayout(flowLayout1);
insetsPanel2.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10));
gridLayout1.setRows(4);
gridLayout1.setColumns(1);
label1.setText(product);
label2.setText(version);
label3.setText(copyright);
label4.setText(comments);
insetsPanel3.setLayout(gridLayout1);
insetsPanel3.setBorder(BorderFactory.createEmptyBorder(10, 60, 10, 10));
button1.setText("Ok");
button1.addActionListener(this);
insetsPanel2.add(imageLabel, null);
panel2.add(insetsPanel2, BorderLayout.WEST);
this.getContentPane().add(panel1, null);
insetsPanel3.add(label1, null);
panel2.add(insetsPanel3, BorderLayout.CENTER);
insetsPanel1.add(button1, null);
panel1.add(insetsPanel1, BorderLayout.SOUTH);

panel1.add(panel2, BorderLayout.NORTH);
}
/**Remplacé, ainsi nous pouvons sortir quand la fenêtre est fermée*/
protected void processWindowEvent(WindowEvent e) {
if (e.getID() == WindowEvent.WINDOW_CLOSING) {
cancel();
}
super.processWindowEvent(e);
}
/**Fermer le dialogue*/
void cancel() {
dispose();
}
/**Fermer le dialogue sur un événement bouton*/
if (e.getSource() == button1) {
cancel();
}
}
}

Chapitre
11
Tutoriel : Construction
Chapitre11
d’une applet
Ce tutoriel vous permet de créer pas à pas une applet AWT dans
l’environnement de développement intégré (EDI) de JBuilder. Pour plus
d’informations sur l’EDI et ses composants, voir “Environnement de
JBuilder” dans le menu Aide.
Le tutoriel montre comment :
• Créer un projet pour l’applet.
• Utiliser l’expert applet pour créer une applet AWT.
• Compiler et exécuter l’applet.
• Personnaliser l’interface utilisateur de l’applet.
• Ajouter des composants AWT, comme Choice, Label et Button.
• Modifier le code source.
• Déployer l’applet.
• Modifier le fichier HTML.
• Exécuter depuis la ligne de commande l’applet déployée.
• Tester l’applet.
Astuce Le code source de l’applet est donné à la fin du tutoriel. L’exemple
FirstApplet se trouve dans le répertoire samples/Tutorials/FirstApplet de
votre répertoire JBuilder.
Important Si vous avez installé JBuilder en tant que root, mais l’exécutez sous votre
compte utilisateur normal, vous devez copier le répertoire entier des
exemples dans un répertoire où vous avez tous les droits de lecture/
écriture pour les exécuter.
Important Avant de commencer ce tutoriel, lisez la présentation qui traite de
questions importantes relatives aux applets.
Pour plus d’informations sur les conventions de la documentation, voir
“Conventions de la documentation”, page 1-2.
Tutoriel : Construction d’une applet 11-1

Présentation
Présentation
Il est important de se souvenir que lors de la conception d’applets le
support de Java du navigateur est limité. Au moment où nous écrivons ces
lignes, Internet Explorer et Netscape supportent le JDK 1.1.5. Les
navigateurs ne supportent pas encore les composants Swing, introduits
dans le JDK 1.1.7, mais ils le feront à l’avenir. Si vous créez vos applets
avec une version plus récente du JDK, faites bien attention à utiliser des
composants supportés par les navigateurs. Par exemple, si vous
développez vos applets en utilisant strictement des composants AWT,
elles fonctionneront dans la plupart des cas. Des modifications peuvent
avoir été apportées aux composants AWT (par exemple, le JDK 1.1.x peut
avoir des fonctionnalités légèrement différentes de celles du JDK 1.3) et
vous serez amené à modifier votre applet en conséquence. Vous pouvez
rechercher les problèmes de votre applet dans le navigateur en consultant
les messages d’erreur de la Console Java. Le moyen le plus sûr de
concevoir votre applet est d’utiliser les composants AWT et le JDK
supporté par le navigateur.
Remarque Les navigateurs supportant le JDK 1.1 sont Netscape 4.06 et au-delà, ainsi
qu’Internet Explorer 4.01 et au-delà. La prise en charge des versions JDK
peut varier d’une plate-forme à l’autre.
Un autre moyen consiste à concevoir vos applets en utilisant le JDK en
cours et des composants Swing, et à fournir à vos utilisateurs le Plug-in
Java. Ce n’est généralement possible que dans un environnement contrôlé,
comme dans l’intranet d’une entreprise. Les navigateurs supportés par le
Plug-in Java, qui fournit le navigateur avec le Java 2 SDK 1.3 Runtime
Environment (JRE), peuvent exécuter les applets basées sur le JDK 1.3.
Plusieurs étapes supplémentaires sont requises pour développer des
applets fonctionnant avec le Plug-in Java. Visitez la page d’accueil du
Plug-in Java, à l’adresse http://www.javasoft.com/products/plugin/
index.html, pour plus d’informations.
Bien que des navigateurs plus récents ne supportent que JDK 1.1.5, vous
vous servirez dans ce tutoriel de JDK 1.3 et uniquement de composants
AWT, en évitant d’utiliser les nouvelles fonctionnalités JDK 1.3. L’applet
s’exécutera quand même, car vous aurez soigneusement choisi les
composants utilisés. Les navigateurs plus anciens qui s’exécutent sur JDK
1.02 ne pourront pas exécuter cette applet, car la gestion des événements a
été modifiée dans JDK 1.1. Si vous prévoyez d’utiliser votre applet sur les
navigateurs anciens, vous devez utiliser la gestion d’événement JDK 1.02.
Important Pour plus d’informations sur l’exécution des applets JDK 1.1.x et 1.2/1.3
dans JBuilder, voir “Exécution des applets” dans le chapitre “Utilisation
des applets” du Guide du développeur d’applications web.

Applet “Good Evening”

L’applet “Good Evening” que vous créez dans ce tutoriel contient une
liste déroulante permettant de choisir une langue. Quand vous
sélectionnez une langue, comme l’allemand, le panneau se trouvant sous
la sélection change pour la traduction de “Good Evening” : “Guten
Abend”.
Quand le tutoriel est terminé, votre applet en train de s’exécuter dans le
visualiseur d’applet de JBuilder ressemble à ceci :
Pour voir le code complet de l’applet, reportez-vous au code source à la

fin du tutoriel.
Pour plus de détails sur les applets et leur déploiement, voir “Utilisation
des applets” dans le Guide du développeur d’applications web et
“Déploiement des programmes Java” dans Construction d’applications avec
JBuilder.

Avant de commencer ce tutoriel, lisez la “Présentation” qui traite de
questions importantes relatives aux applets, comme le support du
navigateur, les versions du JDK et les composants utilisés dans les applets.
Avant de créer votre applet, vous avez besoin d’un projet pour la stocker.
L’expert projet le crée à votre place :
1 Choisissez Fichier|Nouveau projet pour ouvrir l’expert projet.
2 Apportez les modifications suivantes à l’étape 1 de l’expert projet :
1 Nom : FirstApplet
Remarque Au fur et à mesure que vous tapez dans le champ Nom, le même
nom est entré par défaut dans le champ Répertoire. Par défaut,

JBuilder utilise ce nom de projet pour composer les noms du

répertoire et du paquet des classes du projet. Par défaut, JBuilder
enregistre les projets dans le répertoire /<home>/jbproject/. Voir
“Conventions de la documentation”, page 1-2. Pour plus
d’information sur les projets, voir Chapitre 7, “Création et gestion
des projets”.
2 Type (type de fichier) : .jpr ou .jpx
Remarque JBuilder utilise une extension .jpr ou .jpx pour les fichiers projet. Le
type de fichier .jpr est d’emploi général. Le type de fichier .jpx, un
fichier projet XML, est utilisé dans un environnement de
développement en équipe et pour le contrôle de versions. Les deux
types de fichiers fonctionnent pour ce tutoriel.
3 Cochez l’option Créer un fichier de notes pour le projet. Lorsque
vous sélectionnez cette option, l’expert projet crée un fichier HTML
pour les annotations du projet et l’ajoute à celui-ci.
3 Acceptez toutes les autres valeurs par défaut de l’étape 1.

4 Cliquez sur Suivant pour passer à l’étape 2 de l’expert projet.
5 Acceptez les chemins par défaut proposés à l’étape 2. Notez où sont

enregistrés les fichiers classes compilées, projet et sources. Pour plus
d’informations sur les chemins d’accès et sur la façon dont JBuilder
enregistre les fichiers, voir Chapitre 8, “Gestion des chemins d’accès”.
Astuce Si vous préférez créer votre applet en utilisant une version antérieure
du JDK, changez de version du JDK au cours de cette étape. Bien que
JBuilder Personnel ne supporte pas le changement de JDK et soit limité
à un seul JDK, vous pouvez modifier la version du JDK existante dans
la boîte de dialogue Configuration des JDK (Outils|Configurer les
JDK). Pour le JDK 1.1.x, vous devez également télécharger la version
JFC spécifique au JDK 1.1.x.
Voir aussi
• “Définition des propriétés d’un projet”, page 8-6, pour plus
d’informations sur le changement ou l’édition du JDK
• La rubrique “Exécution des applets” du chapitre “Utilisation des
applets” dans le Guide du développeur d’applications web
6 Cliquez sur Suivant pour passer à l’étape 3 de l’expert.

7 Apportez les modifications suivantes dans les champs appropriés de

l’étape 3 :
L’option Paquets source 1 Acceptez les valeurs proposées par défaut pour Encodage et Paquets
automatiques est source automatiques.
une fonctionnalité
2 Entrez Good Evening dans le champ Titre des champs Javadoc classe.
et de JBuilder Entreprise. 3 Entrez votre nom et celui de votre société, ainsi que la description de
votre applet, dans les champs facultatifs appropriés.
Remarque L’information contenue dans les champs Javadoc classe apparaît
dans le fichier HTML du projet et comme commentaires d’en-tête
facultatifs dans le code source.
8 Cliquez sur le bouton Terminer.

L’expert crée un fichier projet et un fichier de notes sur le projet,
FirstApplet.jpx et FirstApplet.html, qui apparaissent dans le volet projet

de l’AppBrowser. Double-cliquez sur le fichier HTML pour voir les

notes sur le projet dans le volet contenu.

L’expert applet crée un fichier .java et le fichier HTML de l’applet, et les
place dans le projet que vous venez de créer à l’aide de l’expert projet.
Pour générer les fichiers source de votre applet, suivez ces étapes :
1 Choisissez Fichier|Nouveau et choisissez l’onglet Web de la galerie
d’objets.
Dans JBuilder Personnel, 2 Double-cliquez sur l’icône Applet pour afficher l’expert applet.
l’icône Applet se trouve
sur la page Nouveau.
3 Acceptez le nom de paquet par défaut, firstapplet, à l’étape 1. Par
défaut, l’expert tire le nom du paquet du nom du fichier projet,
FirstApplet.jpx.
4 Entrez GoodEveningApplet dans le champ Classe. C’est un nom de classe
Java qui distingue les majuscules des minuscules.
Remarque Le nom de classe complet (nom du paquet + nom de la classe) est
firstapplet.GoodEveningApplet.class.
5 Acceptez la Classe de base par défaut, java.applet.Applet.
Attention Si vous créez l’applet en utilisant javax.swing.JApplet, elle ne s’exécutera
pas dans beaucoup de navigateurs web. A l’heure où nous écrivons,
Swing n’est pas encore supporté par les navigateurs web. Voir
“Présentation”, page 11-2, pour plus d’informations.
6 Cochez Créer les méthodes standard.

L’étape 1 de l’expert applet doit ressembler à ceci :
7 Cliquez sur Suivant pour passer à l’étape 2. Au cours de cette étape,

vous allez ajouter des paramètres à votre applet. L’expert ajoute les
balises <param> à l’intérieur des balises <applet> dans le fichier HTML de
l’applet et insère dans le code source le code de gestion des paramètres.
Les paramètres de l’applet, équivalents des arguments de la ligne de
commande pour les applications, vous permettent de personnaliser
l’applet. N’ajoutez aucun paramètre.
Voir aussi
• “Defining and using parameters” à l’adresse http://
www.java.sun.com/docs/books/tutorial/applet/appletsonly/
param.html
8 Cliquez sur Suivant pour passer à l’étape 3 de l’expert applet.
9 Apportez les modifications suivantes à l’étape 3 :
1 Acceptez l’option par défaut Créer une page HTML. Quand vous
sélectionnez cette option, le fichier HTML qui appelle l’applet est
créé. Ce fichier HTML contient la balise <applet> et divers attributs.
2 Tapez Page HTML Good Evening dans le champ Titre.
Le titre s’affiche dans la fenêtre du navigateur web quand l’applet
s’exécute.
3 Acceptez les valeurs par défaut de tous les autres attributs.

L’étape 3 de l’expert applet doit ressembler à ceci :
La balise <applet> du fichier HTML peut inclure les attributs suivants :
codebase Cet attribut facultatif spécifie le chemin relatif au fichier

HTML de l’applet dans lequel le navigateur recherche les
fichiers classe nécessaires. La valeur “.” spécifie le même
répertoire que le fichier HTML exécutant l’applet.
L’attribut codebase est obligatoire quand les fichiers classes
se trouvent dans un répertoire différent de celui du fichier
HTML.
code Cet attribut obligatoire, qui est automatiquement inséré
par l’expert applet de JBuilder, est le nom complet (nom
du paquet + nom de la classe) de la classe applet
contenant la méthode init(). Vous le verrez dans le fichier
HTML lorsqu’il sera généré. Dans cet exemple, le nom
complet de la classe est
archive Cet attribut facultatif, qui ne figure pas dans le code
généré par l’expert applet, est obligatoire lorsque l’applet
est déployée dans un fichier JAR, ZIP ou CAB. Les fichiers
d’archive doivent se trouver dans le répertoire spécifié par
codebase.
name Cet attribut facultatif est le nom de l’applet.
width/height Ces attributs obligatoires déterminent la largeur et la
hauteur en pixels de la zone d’affichage de l’applet.
hspace/vspace Ces attributs facultatifs déterminent l’ajout d’espace
horizontal (marges de gauche et de droite) et l’ajout
d’espace vertical (marges en haut et en bas) autour de
l’applet, en pixels.
align Cet attribut facultatif détermine l’alignement de l’applet
sur la page HTML.

Important Les valeurs de codebase, code, archive et name doivent être entre
guillemets et distinguent les majuscules des minuscules.
Voir aussi
• “Attributs de la balise <applet>” de “Utilisation des applets” dans le
Guide du développeur d’applications web
10 Sélectionnez Terminer pour clore l’expert applet. Remarquez que deux
fichiers sont créés et ajoutés au projet, GoodEveningApplet.java et
GoodEveningApplet.html. GoodEveningApplet.java est ouvert dans le volet
contenu.
Remarque Dans les éditions JBuilder Professionnel et JBuilder Entreprise, un
nœud de paquet source automatique, appelé firstapplet, apparaît
également dans le volet projet lorsque l’option Activer
automatiquement les paquets source est sélectionnée dans la page
Général de la boîte de dialogue Propriétés du projet (Projet|Propriétés
du projet).
Regardons maintenant le code source des deux fichiers.

Etape 3 : Compilation et exécution de votre applet
1 Examinez GoodEveningApplet.java et remarquez ce qui suit :

• Il contient la méthode init(). Le fichier HTML de l’applet doit
appeler la classe contenant la méthode init() pour l’applet à
exécuter.
• Le nom du paquet firstapplet est la première ligne du code. Le
fichier classe est enregistré dans un répertoire firstapplet
conformément aux conventions Java.
• Les instructions import importent des paquets AWT et non Swing :
import java.awt.*;
import java.applet.*;
2 Double-cliquez sur GoodEveningApplet.html dans le volet projet et
choisissez l’onglet Source en bas du volet contenu pour voir le code
source. Remarquez que l’expert a inséré la valeur de code,
3 Choisissez Fichier|Tout enregistrer pour enregistrer les fichiers source
et le fichier projet.
Remarque Par défaut, JBuilder enregistre les fichiers source dans :
/<home>/jbproject/FirstApplet/src/firstapplet/
Le fichier HTML de l’applet est enregistré dans le répertoire classes :
/<home>/jbproject/FirstApplet/classes/
Les fichiers classe, après la compilation, sont enregistrés dans le chemin
de sortie : /<home>/jbproject/FirstApplet/classes/firstapplet/
JBuilder suit toujours la hiérarchie des paquets lors de l’enregistrement
des fichiers. Dans cet exemple, les fichiers source et classe sont
enregistrés à l’intérieur d’un répertoire firstapplet dans les chemins du
source et de sortie pour suivre la structure du paquet firstapplet. Ces
chemins sont définis pour le projet par l’expert projet et visibles dans la
boîte de dialogue Propriétés du projet (Projet|Propriétés du projet).
Dans ce tutoriel, vous avez accepté les chemins proposés par défaut à
l’étape 2 de l’expert projet.

Maintenant, compilez et exécutez l’applet. La compilation consiste à
exécuter le compilateur Java. Le compilateur, qui traduit le code source en
bytecode Java, génère des fichiers .class.
Important Pour plus d’informations sur l’exécution des applets JDK 1.1.x et 1.2/1.3
dans JBuilder, voir “Exécution des applets” dans le chapitre “Utilisation
des applets” du Guide du développeur d’applications web.

1 Choisissez Exécuter|Exécuter le projet ou cliquez sur le bouton

Exécuter pour compiler et exécuter votre application. Le menu et le
bouton Exécuter exécutent l’applet dans le visualiseur d’applet de
JBuilder, AppletTestbed.
Astuce Vous pouvez aussi cliquer avec le bouton droit sur
GoodEveningApplet.html dans le volet projet et sélectionner Exécuter. Cela
exécute votre applet dans l’appletviewer de Sun.
La fenêtre de l’applet est vide car l’applet n’a pas encore d’interface
utilisateur.
S’il y a une erreur de compilation lorsque vous exécutez votre applet, le
volet message apparaît en bas de l’AppBrowser. Corrigez ces erreurs et
exécutez à nouveau l’applet.
Votre applet s’affiche et doit ressembler à ceci dans l’AppletTestbed de
JBuilder :
Vous pouvez changer les paramètres d’exécution de l’applet dans la

page Exécution de la boîte de dialogue Propriétés du projet. Pour
accéder à cette boîte de dialogue, sélectionnez Projet|Propriétés du
projet, ou bien cliquez avec le bouton droit sur FirstApplet.jpx et
sélectionnez Propriétés. Les paramètres de la page Exécution contrôlent
le comportement du menu Exécuter et de l’icône Exécuter figurant dans
la barre d’outils. Choisissez l’option Classe principale pour exécuter
votre applet dans l’AppletTestbed de JBuilder. Choisissez l’option
HTML pour exécuter votre applet dans l’appletviewer de Sun. Lorsque
vous utilisez l’expert applet pour créer votre applet, l’option Classe
principale est sélectionnée par défaut.

Etape 4 : Personnalisation de l’interface utilisateur de votre applet
Important Les applets s’exécutent depuis le fichier HTML qui appelle la classe
contenant la méthode init(), et non depuis le fichier .java. Toute
tentative d’exécuter le fichier .java entraînera un message d’erreur
(sauf si l’option Peut s’exécuter indépendamment a été sélectionnée à
l’étape 1 de l’expert applet) :
java.lang.NoSuchMethodError: main
Exception dans thread "main"
2 Choisissez Exit dans l’applet “Good Evening” pour fermer celle-ci.
3 Cliquez avec le bouton droit sur l’onglet GoodEveningApplet du volet
message et sélectionnez Retirer l’onglet “GoodEveningApplet” pour
fermer tout message d’exécution.

Maintenant que l’expert applet a généré l’ossature de l’applet, vous allez
la personnaliser au cours des étapes suivantes à l’aide de divers
composants.
1 Choisissez l’onglet du fichier GoodEveningApplet.java en haut du volet
contenu.
2 Cliquez sur l’onglet Conception en bas du volet contenu pour passer
dans la vue conception. Le concepteur d’interface utilisateur apparaît
dans le volet contenu, la palette de composants en haut au-dessus de lui
et l’inspecteur à sa droite. Vous allez maintenant utiliser la palette des
composants pour ajouter des composants à votre interface utilisateur et
l’inspecteur pour modifier les propriétés et ajouter des événements à
votre code. Le volet structure contient maintenant une arborescence de

composants ayant des dossiers comme Interface utilisateur, Menu et

Autre.
3 Changez la disposition de this en BorderLayout, dans l’inspecteur :

1 Sélectionnez this dans l’arborescence des composants du volet
structure.
2 Cliquez avec le bouton droit sur la propriété layout, dans la page
Propriétés de l’inspecteur. Sélectionnez BorderLayout dans la liste
déroulante des dispositions.
BorderLayout organise les composants d’un conteneur en zones appelées
North, South, East, West et Center (Nord, Sud, Est, Ouest et Centre).
Utilisez BorderLayout quand vous voulez forcer des composants à se
placer contre un ou plusieurs bords d’un conteneur ou remplir le
milieu de ce conteneur avec un composant. C’est également la
disposition que vous utiliserez pour qu’un composant seul occupe tout
son conteneur.
Attention A tout moment, si vous choisissez XYLayout (une disposition
personnalisée de Borland) dans la liste déroulante de l’inspecteur,
JBuilder ajoute l’instruction import suivante au code source :
com.borland.jbcl.layout.*. Cette instruction import n’est pas supprimée
lorsque vous changez pour une disposition plus portable avant le
déploiement. Si vous ne supprimez pas cette instruction import, votre

applet déployée ne s’exécutera pas, car elle sera bloquée par

l’importation des classes de disposition de la jbcl. Vous devez
supprimer l’instruction import manuellement avant le déploiement.
Le concepteur d’interface utilisateur de JBuilder utilise un gestionnaire
de disposition par défaut pour chaque conteneur, généralement la
disposition du conteneur AWT parent. Dans l’AWT Java, les panneaux
utilisent tous FlowLayout par défaut. Pour voir le gestionnaire de
disposition du panneau, cliquez sur l’icône de développement dans
l’arborescence des composants afin de développer la sélection. Le
gestionnaire de disposition s’affiche dans l’arborescence en tant
qu’élément, juste au-dessous du conteneur parent.
Voir aussi
• “Utilisation des gestionnaires de disposition” dans Conception
d’interfaces utilisateur avec JBuilder
• “Création d’une interface utilisateur ayant des dispositions
imbriquées” dans Conception d’interfaces utilisateur avec JBuilder
4 Choisissez l’onglet AWT de la palette des composants en haut du
concepteur d’interface utilisateur. Vous aurez probablement besoin de
faire défiler la palette des composants vers la droite pour trouver
l’onglet AWT. Les composants AWT, contrairement aux composants
Swing, sont supportés par la plupart des navigateurs web.
Attention Le concepteur d’interface utilisateur s’ouvre toujours avec les
composants Swing sur la première page de la palette. Si vous
sélectionnez par erreur ces composants Swing, votre applet ne

fonctionnera pas dans les navigateurs web. Faites donc bien attention à
choisir les composants de la page AWT de la palette.
5 Ajoutez deux panneaux au panneau this. Le panneau du haut

contiendra la liste déroulante des langues à sélectionner et un libellé
pour identifier cette liste. Le panneau du bas contiendra “Good
Evening” en différentes langues.
1 Faites un Maj+Clic sur le composant AWT Panel, java.awt.Panel, dans
la palette de composants. Maj+Clic vous permet de placer plusieurs
fois le composant sans avoir à le sélectionner à chaque fois dans la
palette. Vous pouvez alors ajouter plusieurs panneaux à this.
Astuce Placez le curseur sur un composant de la palette pour voir son nom
s’afficher dans une bulle d’aide.
2 Cliquez deux fois sur this dans l’arborescence des composants du
volet structure. panel1 et panel2 sont ajoutés sous this dans
l’arborescence des composants.
3 Cliquez sur l’outil de sélection, à gauche de la palette de
composants, pour désactiver la sélection des composants.
4 Vérifiez la propriété constraints des panneaux dans l’inspecteur.
Pour le panneau du haut, elle doit être North, et pour celui du bas,
Center. Pour vérifier la propriété constraints,
1 Sélectionnez un panneau dans l’arborescence des composants ou
dans le concepteur d’interface utilisateur. Si un composant est
sélectionné dans le concepteur, de petites poignées apparaissent à
chaque coin du composant.
2 Assurez-vous que, dans l’inspecteur, la propriété constraints est
définie par North pour le panneau du haut et par Center pour le
panneau du bas. Sinon, cliquez sur la colonne située à droite de la
propriété constraints et choisissez la contrainte appropriée dans la
liste déroulante.
5 Renommez le panneau du haut upper.
1 Sélectionnez le panneau du haut, dans l’arborescence des
composants ou dans le concepteur, et double-cliquez dans
l’inspecteur sur la colonne située à droite de la propriété name.
2 Entrez upper et appuyez sur Entrée.
Astuce Vous pouvez aussi renommer un composant en cliquant dessus avec
le bouton droit dans l’arborescence des composants et en
sélectionnant Renommer dans le menu.

6 Renommez le panneau du bas lower.
6 Changez dans l’inspecteur la couleur du fond du panneau upper en

Orange :
1 Sélectionnez le panneau upper dans l’arborescence des composants
ou dans le concepteur.
propriété background.
couleurs, et sélectionnez Orange dans cette liste.
7 Changez la couleur du fond de lower en Magenta.
8 Changez la disposition de lower en CardLayout. Le panneau CardLayout
contiendra 5 panneaux, chacun avec “Good Evening” dans une langue
différente.
CardLayout place les composants (généralement des panneaux) les uns
par dessus les autres, comme un jeu de cartes. Vous n’en voyez qu’un à
la fois, et vous pouvez les faire permuter en utilisant un autre contrôle
pour sélectionner celui du dessus. CardLayout est généralement associé à
un composant de contrôle, comme une case à cocher ou une liste. L’état
du composant de contrôle détermine le composant CardLayout qui
s’affiche. L’utilisateur fait son choix en sélectionnant quelque chose
dans l’interface utilisateur.
9 Ajoutez 5 panneaux (panneaux 1 à 5) au panneau lower en utilisant
Maj+Clic lorsque vous sélectionnez le composant Panel. Chacun de ces

Etape 5 : Ajout de composants AWT à votre applet
panneaux contiendra “Good Evening” dans une langue différente.

Choisissez l’outil de sélection pour désactiver la sélection multiple du
composant Panel.
Remarque Si vous lâchez le composant au mauvais endroit, sélectionnez-le dans
l’arborescence des composants et appuyez sur Suppr. Puis, ajoutez-le à
nouveau.
10 Changez la disposition des panneaux 1 à 5 en BorderLayout.
1 Utilisez Maj+Clic ou Ctrl+Clic pour sélectionner les panneaux 1 à 5 dans
l’arborescence des composants.
2 Dans l’inspecteur, changez la valeur de la propriétélayout en
BorderLayout. Désormais, les 5 panneaux ont tous la disposition
BorderLayout.
3 Sélectionnez un autre composant dans l’arborescence ou dans le
concepteur pour désélectionner tous les panneaux.
11 Dans l’inspecteur, choisissez une couleur différente comme couleur du
fond de chacun des 5 panneaux.
Astuce Cliquez sur le bouton Points de suspension, à droite de la propriété
background dans l’inspecteur, et utilisez les glissières pour créer une
couleur.
12 Enregistrez le fichier et le projet.
13 Cliquez avec le bouton droit sur GoodEveningApplet.html et sélectionnez
Exécuter. Quand l’applet s’exécute dans l’appletviewer de Sun, vous
voyez uniquement upper et le panneau du dessus dans la disposition
CardLayout. Les panneaux des autres langues s’afficheront plus tard,
lorsque vous ajouterez la liste déroulante et des événements aux
éléments de cette liste.
14 Quittez l’applet.
15 Fermez le volet message en cliquant avec le bouton droit sur l’onglet
GoodEveningApplet et sélectionnez Retirer l’onglet
“GoodEveningApplet”.

Vous allez maintenant utiliser la palette des composants pour ajouter un
composant Label et un composant Choice au panneau du haut de votre
conception, upper.
1 Sélectionnez l’onglet AWT de la palette des composants et cliquez sur
le composant Choice.
2 Placez ce composant dans le panneau orange en haut de votre
conception, upper.

Utilisez l’une des méthodes suivantes :

• Cliquez sur le panneau upper dans l’arborescence des composants.
• Cliquez sur le panneau upper dans le concepteur d’interface
utilisateur.
Notez que choice1 est ajouté à upper dans l’arborescence des
composants.
3 Sélectionnez le composant Label dans la page AWT de la palette et
placez-le dans le panneau upper, à gauche du composant Choice. Notez
que label1 est ajouté à upper dans l’arborescence des composants.
4 Sélectionnez label1 dans l’arborescence des composants et effectuez les
étapes suivantes :
1 Double-cliquez sur la colonne de droite de la propriété text, dans
l’inspecteur, pour mettre en évidence le texte existant. Entrez
Choisissez une langue et appuyez sur Entrée. “Choisissez une langue”
apparaît maintenant dans le libellé, à côté du composant Choice.
2 Cliquez sur la colonne de droite de la propriété font pour définir la
fonte. Cliquez sur le bouton Points de suspension pour ouvrir la
boîte de dialogue.
3 Choisissez Serif dans la liste des fontes et cochez Gras. Entrez 20
dans la boîte Taille. Cliquez sur OK.
propriété foreground pour définir la couleur du texte. Cliquez sur la
flèche vers le bas et sélectionnez Blue dans la liste déroulante des
couleurs.
Votre conception doit maintenant ressembler à ceci :

5 Utilisez Maj+Clic et sélectionnez le composant AWT Label dans la palette

de composants. Ajoutez un libellé AWT à chacun des panneaux (1 à 5)
du panneau CardLayout inférieur. Chacun de ces libellés contiendra
“Good Evening” dans une langue différente. N’oubliez pas de choisir
l’outil de sélection, à gauche de la palette de composants, pour
désactiver la sélection multiple.
6 Pour chaque libellé, traduisez “Good Evening” dans une langue
différente. D’abord, sélectionnez le libellé au-dessous de chaque
panneau, dans l’arborescence des composants, et entrez “Good
Evening” dans la langue appropriée comme valeur de la propriété text,
dans l’inspecteur. Utilisez les langues suivantes ou choisissez les
vôtres :
• label2 : Good Evening (Anglais)
• label3 : Guten Abend (Allemand)
• label4 : Bonsoir (Français)
• label5 : God Kväll (Suédois)
• label6 : Gudday, Mate (Australien)
7 Sélectionnez label2 à label6 en faisant un Ctrl+Clic et changez les
propriétés font de tous les libellés en Gras et en taille 24. Changez la
propriété foreground des libellés en Black. Cliquez sur un composant
dans l’arborescence des composants ou dans le concepteur d’interface
utilisateur pour désélectionner les libellés.
8 Changez la position de chaque libellé en changeant dans l’inspecteur la
propriété constraints en North, South, East, West ou Center, comme
suit :
• label2 : North
• label3 : South
• label4 : East
• label5 : West
• label6 : Center
Remarque Notez la position de chaque libellé dans son panneau BorderLayout
propre. Center remplit tout le panneau, alors que North, South, East et
West remplissent seulement une partie du panneau.
9 Changez le gestionnaire de disposition de panel5 en FlowLayout, la
disposition que vous avez utilisée pour le panneau upper. Notez que le
libellé “Gudday, Mate” se place au haut du milieu du panneau.
FlowLayout est le bon choix lorsque vous voulez disposer en lignes vos
composants. Vous ajouterez ensuite un bouton que FlowLayout placera
sur la même ligne que le libellé.
FlowLayout arrange les composants de gauche à droite sur la ligne.
Lorsque la ligne est pleine, les composants restants se placent sur une
nouvelle ligne.

10 Cliquez sur le composant AWT Button et lâchez-le à gauche du libellé

“Gudday, Mate”. Essayez de déplacer le bouton dans le concepteur.
FlowLayout le ramène toujours sur la ligne où se trouve le libellé. La
conception de votre applet pour panel5 doit maintenant ressembler à
ceci :
11 Choisissez Fichier|Tout enregistrer pour enregistrer le projet.

Pour plus d’informations sur les dispositions et leurs comportements, voir
“Utilisation des gestionnaires des dispositions” et “Tutoriel : Dispositions
imbriquées” dans Conception d’interfaces utilisateur avec JBuilder.

Dans cette étape, vous ajouterez des langues à la liste déroulante, puis
vous ajouterez des événements pour associer chaque panneau de langue
au composant Choice.
1 Ajoutez les langues de la liste déroulante à la méthode init() comme
ceci :
1 Cliquez sur l’onglet Source du volet contenu pour modifier le code
source dans l’éditeur.
2 Sélectionnez la méthode init() dans le volet structure. Le code de la
méthode init() est en évidence dans l’éditeur.
Astuce Pour chercher une méthode dans le volet structure, cliquez dans le
volet et tapez le nom de la méthode.
3 Positionnez le curseur après l’accolade ouvrante et avant
l’instruction try/catch puis appuyez sur Entrée pour créer une ligne
vide supplémentaire.
Astuce Pour développer l’éditeur et cacher les volets projet et structure,
sélectionnez Voir|Volet en plein écran.

4 Ajoutez à la méthode init() le bloc de code mentionné en gras

ci-après :
//initialiser l’applet
public void init() {
choice1.addItem("Anglais");
choice1.addItem("Allemand");
choice1.addItem("Français");
choice1.addItem("Suédois");
choice1.addItem("Australien");
try {
jbinit();
}
}
}
Astuce Utilisez l’audit de code pour écrire le code. Entrez choice1. et
attendez la fenêtre surgissante ou appuyez sur Ctrl+barre d’espace pour
l’appeler. Assurez-vous d’inclure le point (.) après choice1. Utilisez
les flèches de direction pour sélectionner addItem(String) dans la
fenêtre surgissante. Appuyez sur Entrée. Vous pouvez configurer
l’audit de code dans la boîte de dialogue Options de l’éditeur
(Outils|Options de l’éditeur|Audit de code).
S’il y a des erreurs de syntaxe dans votre code, un dossier Erreurs

apparaîtra dans le volet structure dès que vous taperez dans l’éditeur.
Ouvrez ce dossier et sélectionnez le message d’erreur pour mettre
l’erreur en évidence dans le code source.
Voir aussi
• “A propos des messages d’erreur et d’avertissement” dans le manuel
en ligne Construction d’applications avec JBuilder.
Ensuite, vous allez connecter l’événement au choix de langue. Quand
vous sélectionnez une langue dans le composant liste déroulante Choice,

“Good Evening” apparaît dans le panneau cardLayout dans la langue

sélectionnée.
2 Connectez les événements à la liste Choice comme suit :
1 Revenez dans le concepteur d’interface utilisateur.
2 Sélectionnez choice1 sous upper dans l’arborescence des composants.
3 Sélectionnez l’onglet Evénements dans l’inspecteur.
4 Double-cliquez à droite de l’événement itemStateChanged. JBuilder
génère le code de la méthode et vous positionne dans le code source,
le curseur à l’intérieur de la méthode.
void choice1_itemStateChanged(ItemEvent e) {
}
5 Ajoutez le code indiqué en gras ci-après afin de connecter le bon
panneau de langue au choix de langue :
if ("Anglais".equals(choice1.getSelectedItem())){
cardLayout1.show(lower, "panel1");
}
else if ("Allemand".equals(choice1.getSelectedItem())){
}
else if ("Français".equals(choice1.getSelectedItem())){
}
else if ("Suédois".equals(choice1.getSelectedItem())){
}
else if ("Australien".equals(choice1.getSelectedItem())){
}
}
Astuce Vous pouvez utiliser des modèles pour générer le code. Tapez if et
appuyez sur Ctrl+J pour accéder à la fenêtre surgissante des modèles
de code. Utilisez les flèches de direction pour naviguer entre les
sélections. Sélectionnez le modèle if-else if et appuyez sur Entrée. Le
code est généré :
if () {
}
else if{
}

4 Exécutez l’applet en cliquant avec le bouton droit sur

GoodEveningApplet.html dans le volet projet puis en sélectionnant
Exécuter.
L’applet “Good Evening” s’exécute dans l’appletviewer de Sun :
S’il y a des erreurs, elles s’affichent dans le volet message, en bas de

l’AppBrowser. Sélectionnez un message d’erreur et appuyez sur F1
pour avoir de l’aide. Sélectionnez le message d’erreur pour mettre le
code en évidence dans l’éditeur. Parfois, l’erreur peut être avant ou
après la ligne de code en évidence. Corrigez ces erreurs, enregistrez le
projet et exécutez à nouveau l’applet.
5 Testez la liste déroulante. La langue sélectionné dans la liste doit
correspondre au texte affiché dans le panneau qui est dessous.
Maintenant, ajoutez un événement bouton au button1 de panel5. Quand
vous appuyez sur le bouton, le texte “Gudday, Mate” de label6 devient
rouge.
1 Ajoutez un libellé bouton et un événement bouton comme ceci :
1 Revenez dans le concepteur d’interface utilisateur.
2 Sélectionnez button1 dans panel5. Changez dans l’inspecteur la
propriété Label du bouton de button1 en Appuyer. Appuyez sur Entrée.
Notez comment le bouton est automatiquement retaillé pour
s’adapter au texte.
3 Cliquez sur l’onglet Evénements de l’inspecteur pour définir ce qui
se passe lorsqu’on appuie sur button1.
4 Double-cliquez sur la colonne située à droite de l’événement
ActionPerformed. JBuilder passe dans l’éditeur, où le squelette de code
suivant a été ajouté pour l’événement ActionPerformed, juste
au-dessous des instructions if-else if.

Etape 7 : Déploiement de votre applet
void button1_actionPerformed(ActionEvent e) {
}
Astuce Double-cliquer sur le bouton dans le concepteur produit le même
effet.
Maintenant, vous allez entrer le code définissant l’événement bouton
qui fait passer “Gudday, Mate” en rouge.
5 Tapez le code indiqué en gras ci-après :
label6.setForeground(new Color(255,0,0));
}
2 Enregistrez le projet.
3 Exécutez l’applet et sélectionnez “Australien” dans la liste déroulante.
Cliquez sur le bouton “Appuyer”. “Gudday, Mate” doit devenir rouge.
Votre applet doit maintenant ressembler à ceci :

Déployer une applet Java consiste à rassembler les fichiers classe Java, les
fichiers image et les autres fichiers nécessaires à l’applet, et à les copier,
ainsi que le fichier HTML de l’applet, sur une machine serveur ou client
où ils peuvent être exécutés. Vous pouvez livrer les fichiers séparément ou
dans des fichiers d’archive compressés ou non. Les fichiers JAR, fichiers
archive Java, sont le plus couramment utilisés. L’avantage des fichiers JAR
est qu’ils sont plus petits et que leur téléchargement est plus rapide.
Lorsque vous déployez votre applet, n’oubliez pas ceci :
• Enregistrez et compilez votre projet avant de le déployer.

• Ouvrez GoodEveningApplet.html et cliquez sur l’onglet Source pour

examiner les points suivants :
• Vérifiez que l’attribut code contient le nom de classe complet, avec le
nom de paquet. Dans cet exemple, la valeur de code est
firstappplet.GoodEveningApplet.class.
• Vérifiez que l’attribut codebase spécifie le bon emplacement du
fichier classe par rapport à celui du fichier HTML. Dans cet exemple,
la valeur de codebase est “.”, car le fichier JAR contenant le fichier
classe sera dans le même répertoire que le fichier HTML.
• Maintenez la structure des répertoires existante. Dans cet exemple,
GoodEveningApplet.class doit se trouver dans un répertoire firstapplet
pour suivre la structure du paquet : firstapplet/GoodEveningApplet.class.
Si vous effectuez le déploiement dans un fichier JAR, vérifiez que la
structure des répertoires dans ce fichier est conforme.
• Livrez toutes les classes nécessaires au serveur Internet approprié. Les
fichiers classe doivent se trouver dans l’emplacement correct par
rapport au fichier HTML et correspondre à l’attribut codebase.
• Livrez le fichier HTML de l’applet au serveur Internet approprié.
Attention Si vous créez vos applets pour d’anciens navigateurs basés sur le JDK 1.02,
n’oubliez pas qu’ils ne supportent pas les fichiers JAR. Créez à la place un
fichier archive ZIP.
Voir aussi
• “Déploiement des programmes Java” dans Construction d’applications
avec JBuilder
• L’étape 16 du tutoriel de JBuilder “Construction d’un éditeur de texte
Java — Déploiement de l’application Editeur de texte” dans Conception
d’interfaces utilisateur avec JBuilder
Selon l’édition de JBuilder que vous possédez, il existe différents outils
pour déployer votre applet :
• L’outil jar de Java, livré avec le JDK
• L’expert Constructeur d’archives de JBuilder, livré dans les éditions
JBuilder Professionnel et JBuilder Entreprise
Déploiement de votre applet à l’aide de l’outil jar

JBuilder Personnel Le JDK contient un outil jar, dans le répertoire bin, pour créer les fichiers
JAR du déploiement. L’outil jar, utilitaire d’archivage et de compression,
regroupe plusieurs fichiers dans une seule archive JAR.

La commande jar de base est de la forme suivante :

jar {ctxu}[vfm0M] [fichier-jar] [fichier-manifest] [-C répertoire] fichiers ...
Remarque Pour obtenir de l’aide sur les autres options JAR, entrez jar -help sur la
ligne de commande ou reportez-vous à la documentation jar, à l’adresse
http://java.sun.com/j2se/1.3/docs/tooldocs/tools.html#basic.
Créez le fichier JAR en suivant ces étapes :
3 Créez pour votre applet un répertoire applets dans votre répertoire /
<home>/jbproject/. Ce sera le répertoire de test dans lequel vous mettrez
le fichier HTML de votre applet et le fichier JAR.
4 Ouvrez la fenêtre de commandes ou une fenêtre DOS.
5 Passez dans le répertoire du projet : /<home>/jbproject/FirstApplet/
6 Entrez la commande JAR suivante :
jar cvf GoodEvening.jar -C classes firstapplet
où :
jar = la commande qui génère le fichier JAR

c= crée une nouvelle archive
v= génère une sortie spécifiant ce qui a été ajouté au fichier
JAR
f= spécifie le nom du fichier JAR à créer
-C = change temporairement pour le répertoire spécifié
pendant l’exécution de la commande jar (dans ce cas, le
répertoireclasses)
classes = le répertoire où la commande jar est exécutée
firstapplet = le paquet des classes à ajouter au fichier JAR
Remarque Le JDK doit se trouver dans votre chemin d’accès. Sinon, utilisez la
commande suivante :
<jbuilder>/<jdk>/bin/jar cvf GoodEvening.jar -C classes firstapplet
Où <jbuilder> est le nom du répertoire contenant JBuilder et <jdk> le
nom du répertoire contenant le JDK.
Par exemple, jbuilder6/jdk1.3.1/.... Si JBuilder se trouve sur un autre
lecteur, mentionnez le nom du lecteur avant le répertoire JBuilder.
Remarque Pour Windows, utilisez des barres obliques inverses (\).

L’outil jar envoie les résultats sur l’écran qui doit ressembler à ce qui
suit :
added manifest
adding: firstappplet/(in = 0) (out= 0)(stored 0%)
adding: firstappplet/GoodEveningApplet.class(in = 5501)
(out= 2683)(deflated 51%)
adding: firstappplet/GoodEveningApplet$1.class(in = 745)
adding: firstappplet/GoodEveningApplet$2.class(in = 741)
Remarquez la structure de répertoires des classes : firstapplet/
GoodEveningApplet.class. De même, remarquez que l’outil jar a créé un
fichier manifest. C’est dans le fichier manifest que sont stockées toutes
les méta-informations sur l’archive. Le fichier JAR est enregistré dans le
répertoire FirstApplet du projet.
7 Copiez GoodEvening.jar dans le répertoire applets pour le tester.
Une fois le fichier JAR créé, passez à l’“Etape 8 : Modification du fichier
HTML”, page 11-31.
Voir aussi
• “Using JAR Files: The Basics” à l’adresse http://java.sun.com/docs/
books/tutorial/jar/basics/index.html
• “jar-The Java Archive Tool” à l’adresse http://java.sun.com/j2se/1.3/
docs/tooldocs/tools.html#basic
avec JBuilder
Déploiement de votre applet à l’aide du Constructeur

d’archives
Fonctionnalité Le Constructeur d’archives de JBuilder rassemble tous les fichiers requis
de JBuilder Professionnel pour distribuer votre applet et peut les archiver dans un fichier JAR.
Pour déployer votre applet avec JBuilder Professionnel et JBuilder
Entreprise :
3 Créez pour votre applet un répertoire applets dans votre répertoire /
<home>/jbproject/. Ce sera le répertoire de test dans lequel vous mettrez
le fichier HTML de votre applet et le fichier JAR.

4 Choisissez Experts|Constructeur d’archives pour ouvrir le

Constructeur d’archives.
5 Sélectionnez JAR de l’applet dans la liste déroulante Type d’archive, à

l’étape 1. Cliquez sur Suivant pour passer à l’étape 2.
Remarque Sélectionnez le type d’archive ZIP de l’applet si vous développez des
applets pour des navigateurs anciens ne supportant pas les fichiers
JAR.
6 Acceptez le nom par défaut, JAR de l’applet, dans le champ Nom.
7 Cliquez sur le bouton Points de suspension, à côté du champ Fichier, et
naviguez jusqu’au répertoire /<home>/jbproject/applets/.
8 Changez le nom du fichier JAR en GoodEvening.jar et choisissez OK.

10 Choisissez Inclure les classes requises et ressources connues. Ensuite,

vous choisirez manuellement les classes que vous voulez ajouter.
Choisir cette option vous permet d’exclure le fichier HTML, qui n’a pas
besoin d’être déployé avec les classes.
11 Cliquez sur le bouton Ajouter une classe et sélectionnez le paquet
firstapplet. Cliquez sur OK pour fermer la boîte de dialogue. Le paquet
s’affiche dans la liste Classes, paquets et ressources nécessaires.

13 Choisissez Suivant pour atteindre l’étape 5. Vous n’avez pas à ajouter
de bibliothèque.
14 Acceptez les valeurs par défaut à l’étape 5. Notez que la création d’un
fichier manifest pour l’archive est active par défaut.
Remarque Pour plus d’informations sur les fichiers manifest, voir “A propos du
fichier manifest” de “Déploiement des programmes Java” dans
15 Cliquez sur Terminer pour quitter le Constructeur d’archives. Un
nœud d’archive, appelé JAR de l’applet, apparaît dans le volet projet.
Vous pouvez modifier ce fichier en cliquant dessus avec le bouton droit
et en sélectionnant Propriétés.
16 Cliquez avec le bouton droit sur le nœud d’archive Applet JAR et
choisissez Construire pour compiler votre projet. Le Constructeur
d’archives joint le paquet firstapplet que vous avez ajouté dans le
fichier JAR à l’étape 3 de l’expert.
17 Cliquez sur l’icône de développement, à côté du nœud d’archive JAR de
l’applet pour voir le fichier d’archive GoodEvening.jar. Double-cliquez
sur le fichier JAR dans le volet projet. Le fichier manifest apparaît dans
le volet contenu et le contenu du fichier JAR apparaît dans le volet

Etape 8 : Modification du fichier HTML
structure. Sélectionnez un fichier dans le volet structure pour le voir

dans le volet contenu.
Remarque Si vous livrez plusieurs programmes au même endroit, vous pouvez livrer
séparément les fichiers redistribuables, au lieu de les inclure dans chacun
de vos fichiers JAR.
Voir aussi
• “Utilisation du Constructeur d’archives” dans Construction
d’applications avec JBuilder
avec JBuilder

Maintenant que votre applet est déployée dans un fichier JAR, vous avez
besoin de modifier dans le fichier HTML l’attribut archive pour y inclure le
nom du fichier JAR. Vous allez aussi insérer un message entres les balises
<applet> indiquant aux utilisateurs qui ne disposent pas d’un navigateur
supportant Java qu’ils ne pourront pas voir l’applet, sauf s’ils activent Java
dans leur navigateur ou s’ils mettent ce dernier à jour.
Pour modifier le fichier HTML,
1 Ouvrez GoodEveningApplet.html dans JBuilder et ajoutez l’attribut archive
comme ci-après :
1 Sélectionnez l’onglet Source pour voir le code source du HTML.
2 Ajoutez le code HTML suivant dans la balise <applet> :
archive = "GoodEvening.jar"
La balise <applet> doit ressembler à ceci :
<applet
codebase = "."
code = "firstapplet.GoodEveningApplet.class"
name = "TestApplet"
width = 400
height = 300
hspace = 0
vspace = 0
align = top
>
</applet>
Astuce Si vous avez plusieurs fichiers JAR pour votre applet, séparez-les par
une virgule, comme ceci :
archive="fichier1.jar, fichier2.jar"

Important Certains anciens navigateurs web ne supportent ni les fichiers JAR ni

les listes multiples de fichiers archive, mais supportent un seul fichier
ZIP dans l’attribut archive.
Ensuite, ajoutez un message pour signaler aux utilisateurs n’ayant pas
de navigateur supportant Java que leur navigateur ne supportera pas
Java et qu’ils ne pourront donc pas voir l’applet.
2 Entrez le message suivant entre les balises <applet> d’ouverture et de
fermeture :
Vous devez avoir un navigateur supportant Java et exécutant JDK 1.1.x ou une
version supérieure pour voir cette applet.
La balise <applet> doit ressembler à ceci :
<applet
codebase = "."
name = "TestApplet"
width = 400
height = 300
hspace = 0
vspace = 0
align = top
>
</applet>
Les navigateurs web ne supportant pas Java ignorent les balises
<applet> et affichent tout ce qui se trouve entre ces balises. Comme un
navigateur supportant Java reconnaît les balises <applet>, tout
utilisateur disposant d’un tel navigateur verra l’applet et non le
message.
Important Avant d’enregistrer le fichier HTML, vérifiez encore les valeurs de
codebase et de code. Si ces valeurs sont incorrectes, l’applet ne
s’exécutera pas. N’oubliez pas que la valeur de codebase est
l’emplacement du code de l’applet (fichier classe ou fichier JAR) par
rapport au fichier HTML. La valeur “.” signifie que le fichier classe se
trouve dans le même répertoire que le fichier HTML. La valeur de code
doit être le nom de classe complet de l’applet, y compris le nom du
paquet.
3 Enregistrez et fermez le fichier.
4 Copiez le fichier GoodEveningApplet.html modifié, du répertoire classes
du projet vers le répertoire applets. Le répertoire applets doit contenir
deux fichiers, GoodEveningApplet.html et GoodEvening.jar.
Attention Souvenez-vous que JBuilder crée deux fichiers HTML : le fichier HTML
des notes du projet, FirstApplet.html, se trouvant dans la racine du
répertoire du projet et le fichier HTML de l’applet contenant la balise

Etape 9 : Exécution depuis la ligne de commande de l’applet déployée
<applet>, GoodEveningApplet.html, se trouvant dans le répertoire src du

projet. Ne copiez pas FirstApplet.html au lieu de GoodEveningApplet.html
dans le répertoire applets car l’applet ne s’exécuterait pas.
Etape 9 : Exécution depuis la ligne de commande de l’applet

déployée
C’est une bonne idée de tester l’applet déployée en local avant de la tester
sur le web. Vous pouvez faire cela à partir de la ligne de commande, en
utilisant l’appletviewer de Sun. Cela vous indiquera si le navigateur web
possède tout ce qui est nécessaire à l’exécution de l’applet. Si des fichiers
sont manquants ou s’il y a des erreurs dans le fichier HTML, l’applet ne
s’exécutera pas. Vous pourrez alors corriger les erreurs avant de l’envoyer
sur le web.
Pour exécuter l’applet depuis la ligne de commande,
1 Assurez-vous que les copies de GoodEveningApplet.html et de
GoodEvening.jar se trouvent bien dans le répertoire applets.
3 Effacez toute variable CLASSPATH afin de supprimer d’éventuels
chemins de classe pour cette session, comme ceci :
• Windows 95, 98, NT et 2000 : set CLASSPATH=
• UNIX :
• dans le shell csh : unsetenv CLASSPATH
• dans le shell sh : unset CLASSPATH
4 Passez dans le répertoire applets.
5 Exécutez l’appletviewer en entrant la commande suivante :
<jbuilder>/<jdk>/bin/appletviewer GoodEveningApplet.html
Où <jbuilder> représente la version de JBuilder que vous exécutez, par
exemple, jbuilder6/.
Important Si JBuilder se trouve sur un autre lecteur, incluez le nom de ce lecteur.
Remarque Pour Windows, utilisez des barres obliques inverses (\).
Si l’applet “Good Evening” se charge et s’exécute dans l’appletviewer,
c’est que le déploiement a réussi et que les classes ont toutes été
trouvées et incluses. Si l’applet ne s’exécute pas, lisez les messages
d’erreur, corrigez les erreurs, recompilez, déployez et essayez à
nouveau.
L’applet “Good Evening” est fournie en exemple dans le répertoire
samples/Tutorials/FirstApplet/ de JBuilder.

Test sur le web de votre applet déployée
Si vous avez des problèmes pour exécuter votre applet, reportez-vous au

code source de l’applet, à la fin de ce tutoriel, et lisez les rubriques
suivantes pour les erreurs les plus courantes :
• “Solving common applet problems” à l’adresse http://
www.java.sun.com/docs/books/tutorial/applet/problems/
index.html
• “Erreurs couramment commises dans la balise <applet>” et “Conseils
supplémentaires pour faire fonctionner les applets” au chapitre
“Utilisation des applets” du Guide du développeur d’applications web.
La dernière étape du développement de votre applet est de la tester en
l’exécutant sur le web. Cela vous indiquera si elle a bien tous les fichiers
nécessaires. Bien que ce tutoriel n’approfondisse pas les détails du test
d’une applet, vous trouverez dans “Test sur le web de votre applet
déployée”, page 11-34, une présentation du test des applets.
Félicitations ! Vous venez de créer votre première applet avec JBuilder.
Maintenant que vous êtes familier de l’environnement de développement
de JBuilder, vous allez constater que ses nombreuses fonctionnalités
facilitent la programmation et vous font gagner du temps.
Pour d’autres tutoriels sur les applets, voir :
• “The Java™ Tutorial” à l’adresse http://java.sun.com/docs/books/
tutorial/index.html
• Part II: Applets de Charlie Calvert, à l’adresse
http://homepages.borland.com/ccalvert/JavaCourse/index.htm
• Le site web Curmudgeon de Rich Wilkman, à l’adresse
http://formlessvoid.com/jc/applets/
• “Applet design and deployment” de John Moore, à l’adresse
http://www.microps.com/mps/p_appletdesign.html
Test sur le web de votre applet déployée

La dernière étape du développement de votre applet est de l’exécuter sur
le web. Cela vous indiquera si elle a bien tous les fichiers nécessaires. Il est
important de tester votre applet sur une grande variété de navigateurs
pour être certain que tous les fichiers nécessaires sont inclus dans
l’archive.
Effectuez les étapes suivantes, puis testez votre applet en l’exécutant sur le
web dans divers navigateurs.
1 Transférez les fichiers HTML et les fichiers JAR de l’applet sur un
serveur Internet ou copiez-les sur un serveur Windows NT.

Code source de l’applet
1 Servez-vous d’un utilitaire de transfert FTP pour transférer les

fichiers sur le serveur. Vérifiez que vous transférez les fichiers en
tant que fichiers binaires.
2 Assurez-vous que les emplacements sur le serveur des fichiers
HTML et JAR correspondent bien à l’attribut codebase du fichier
HTML et que l’attribut code contient le nom de classe complet (y
compris le nom du paquet).
2 Testez l’applet dans divers navigateurs. Si l’applet ne peut se charger,
vérifiez que le navigateur supporte Java. Consultez aussi les messages
d’erreur dans la console Java du navigateur.
Pour ouvrir la console Java :
• Sélectionnez Communicator|Outils|Console Java dans Netscape.
• Sélectionnez Affichage|Console Java dans Internet Explorer.
3 Corrigez ces erreurs, redéployez votre applet et testez-la à nouveau
dans divers navigateurs.

Code source de l’applet HTML pour
GoodEveningApplet.html
<html>
<head>
<meta http="Content-Type" content="text/html; charset=windows-1252">
<title>
Page HTML de l’applet Good Evening
</title>
</head>
<body>
firstapplet.GoodEveningApplet apparaîtra dans un navigateur supportant Java.
<applet
codebase = "."
name = "TestApplet"
width = 400
height = 300
hspace = 0
vspace = 0
align = top
>
</applet>
</body>
</html>

Code source de la classe de l’applet pour

GoodEveningApplet.java
package firstapplet;
import java.awt.*;
import java.applet.*;
public class GoodEveningApplet extends Applet {

boolean isStandalone = false;
Panel lower = new Panel();
Panel upper = new Panel();
CardLayout cardLayout1 = new CardLayout();
Panel panel1 = new Panel();
Choice choice1 = new Choice();
Label label1 = new Label();
FlowLayout flowLayout1 = new FlowLayout();
Button button1 = new Button();
/**Obtenir la valeur d’un paramètre*/
public String getParameter(String key, String def) {
return isStandalone ? System.getProperty(key, def) :
(getParameter(key) != null ? getParameter(key) : def);
}
/**Construire l’applet*/
public GoodEveningApplet() {
}
/**Initialiser l’applet*/
public void init() {
choice1.addItem("Anglais");
choice1.addItem("Allemand");
choice1.addItem("Français");
choice1.addItem("Suédois");
choice1.addItem("Australien");
try {
jbInit();
}

}
}
this.setLayout(borderLayout1);
upper.setBackground(Color.orange);
lower.setBackground(Color.magenta);
lower.setLayout(cardLayout1);
panel5.setLayout(flowLayout1);
panel1.setBackground(new Color(190, 173, 255));
label1.setFont(new java.awt.Font("Serif", 1, 20));
label1.setForeground(Color.blue);
label1.setText("Choisissez une langue");
label2.setFont(new java.awt.Font("Dialog", 1, 24));
label2.setForeground(Color.black);
label2.setText("Good Evening");
label3.setText("Guten Abend");
label4.setText("Bonsoir");
label5.setText("God Kvall");
choice1.addItemListener(new java.awt.event.ItemListener() {
public void itemStateChanged(ItemEvent e) {
choice1_itemStateChanged(e);
}
});
label6.setText("Gudday, Mate");
button1.setLabel("Appuyer");
button1.addActionListener(new java.awt.event.ActionListener() {
button1_actionPerformed(e);
}
});
this.add(lower, BorderLayout.CENTER);
lower.add(panel1, "panel1");
panel1.add(label2, BorderLayout.NORTH);

panel2.add(label3, BorderLayout.SOUTH);
panel3.add(label4, BorderLayout.EAST);
panel4.add(label5, BorderLayout.WEST);
panel5.add(button1, null);
panel5.add(label6, null);
this.add(upper, BorderLayout.NORTH);
upper.add(label1, null);
upper.add(choice1, null);
}
/**Lancer l’applet*/
public void start() {
}
/**Arrêter l’applet*/
public void stop() {
}
/**Détruire l’applet*/
public void destroy() {
}
/**Obtenir l’information Applet*/
public String getAppletInfo() {
return "Information Applet";
}
/**Obtenir l’information Paramètre*/
public String[][] getParameterInfo() {
return null;
}
if ("Anglais".equals(choice1.getSelectedItem())){
}
else if ("Allemand".equals(choice1.getSelectedItem())){
}
else if ("Français".equals(choice1.getSelectedItem())){
}
else if ("Suédois".equals(choice1.getSelectedItem())){
}
else if ("Australien".equals(choice1.getSelectedItem())){
}
}
label6.setForeground(new Color(255,0,0));
}
}

Chapitre
Tutoriel : Utilisation de la vue

Chapitre12
12
historique
Ce tutoriel explique comment utiliser la vue historique L’interface de
contrôle de versions est parfois mentionné, mais il n’est pas nécessaire
pour suivre ce tutoriel. Vous pouvez utiliser la vue historique que vous
ayez ou non installé un système de contrôle de versions.
La terminologie afférente à la gestion des versions varie selon l’outil que
vous utilisez. Ce tutoriel utilise les termes génériques, et non les termes
spécifiques aux outils, pour les fonctionnalités de contrôle de versions
indépendantes de tout outil qui sont disponibles dans JBuilder. Pour plus
d’informations sur ces termes, voir “Glossaire relatif à la gestion des
versions”, page 9-1.
Le contrôle de versions La vue historique est disponible dans toutes les éditions de JBuilder, mais
est une fonctionnalité ses fonctionnalités sont différentes selon les éditions. Ce tutoriel présente
de JBuilder Entreprise. toutes les fonctionnalités disponibles, classées par édition. Tous les
utilisateurs de JBuilder peuvent exécuter les deux premières leçons. Les
utilisateurs des versions Professionnel et Entreprise peuvent suivre les
trois premières. Les utilisateurs de la version Entreprise peuvent effectuer
les quatre leçons.
Les modifications apportées aux fichiers dans ce tutoriel sont très simples.
Cela vous permettra de vous concentrer sur les procédés de la
fonctionnalité historique exposés plutôt qu’aux transformations du code.
Nous utiliserons le projet Welcome dans cette leçon. Vous le trouverez
dans le répertoire /samples/welcome de votre installation JBuilder. Ouvrez
ce projet immédiatement.
Si vous voulez voir comment se présentent les fonctionnalités d’historique
lorsque le projet est sous contrôle de versions, ouvrez le projet Welcome,
Tutoriel : Utilisation de la vue historique 12-1

Etape 1 : Génération de plusieurs versions d’un fichier
sélectionnez votre système de contrôle de versions et placez le projet sous

le contrôle de versions avant de commencer. Au cours de ce tutoriel,
utilisez les étapes commençant par la phrase suivante : Utilisateurs du
contrôle de versions.
Utilisateurs du contrôle Si vous ne disposez pas de l’accès nécessaire pour placer un projet sous
de versions votre système de contrôle de versions, mais voulez voir comment se
comporte le contrôle de versions dans la vue historique, utilisez
l’installation de CVS fournie par l’installation de JBuilder. CVS vous
permet de créer un référentiel local dont vous serez entièrement maître.
Pour des informations sur le contrôle de versions dans JBuilder, voir
Développement en équipe en utilisant JBuilder. Pour plus d’informations sur
CVS, voir “CVS dans JBuilder” dans Développement en équipe en utilisant
JBuilder.

D’abord, nous devons générer plusieurs versions différentes d’un même
fichier pour voir quelque chose dans la vue Historique.
Vérifiez que le projet Welcome est ouvert dans JBuilder.
Utilisateurs du contrôle Vérifiez que vous avez placé ce projet sous contrôle de version.
de versions
Pour apporter des modifications à un fichier source,
1 Double-cliquez sur WelcomeApp.java dans le volet projet s’il n’est pas déjà
ouvert et actif dans le volet contenu.
2 Regardez dans la barre d’état dans le volet contenu. Les deux nombres
dans la barre d’état indiquent la ligne et la colonne correspondant à la
position actuelle du curseur :
3 Placez le curseur à la fin de la ligne 27. Le texte de cette ligne est : import
javax.swing.UIManager;.

4 Appuyez sur Entrée à la fin de la ligne 27 pour ajouter une ligne en

dessous.
5 Tapez import java.applet.*; sur la ligne 28.
6 Choisissez Fichier|Enregistrer nomfichier ou cliquez sur l’icône
Enregistrer <nomfichier> pour enregistrer le fichier. Cela génère une
version de sauvegarde que nous utiliserons plus tard.
Les versions de sauvegarde sont conservées dans le sous-répertoire bak
du répertoire du projet. Par défaut, JBuilder conserve les 5 versions de
sauvegarde les plus récentes. Pour modifier le niveau de sauvegarde (le
nombre de versions de sauvegarde maintenues par JBuilder), choisissez
Outils|Options de l’éditeur, sélectionnez la page Editeur si ce n’est pas
automatique, et réglez la glissière Niveau de sauvegarde dans le
premier tiers de la page Editeur. Vous pouvez avoir jusqu’à 30 versions
sauvegardées dans le répertoire bak.
Utilisateurs du contrôle 7 Modifiez import java.applet.*; en import java.applet.Applet; et validez
de versions le fichier. Entrez le commentaire import java.applet.* modifié en import
java.applet.Applet. Cela génère un version de type contrôle de version
que nous utiliserons plus tard.
8 Modifiez import java.applet.*; en import java.applet.Applet; et
enregistrez le fichier.
9 Allez à la ligne, qui contient boolean packFrame = false;.
10 Modifiez false en true.
11 Enregistrez le fichier.
Faites une modification supplémentaire mais ne l’enregistrez pas.
12 Placez le curseur sur la ligne 35, colonne 23, où se lit WelcomeFrame frame
= new WelcomeFrame;
13 Modifiez le nom de l’objet frame en frame2.
Votre code ressemble alors à :
Cette image a été arrangée pour mettre en évidence tous les

changements effectués à ce stade.

Etape 2 : Utilisation de la page Sommaire

La page Sommaire affiche toutes les révisions du fichier sélectionné dans
le volet contenu, elle vous permet de les trier de différentes façons et
fournit un accès aux boutons Rafraîchir, Restaurer et Synchroniser le
défilement.
1 Choisissez l’onglet Historique. La page Sommaire apparaît :
Dans la partie supérieure, la liste des révisions affiche les versions par
numéro de révision, les révisions les plus récentes se trouvant en haut
de la liste.
Le code source de la version la plus récente est affiché dans le
visualiseur de source sous la liste des révisions.
Remarquez les informations affichées par la barre d’état : nom de
fichier, date et heure, position ligne et colonne.
2 Cliquez sur une version du fichier pour la voir dans le visualiseur de
source. JBuilder récupère la version demandée où qu’elle se trouve
stockée, dans son propre système de fichiers ou dans le contrôle de
version.
3 Cliquez sur l’en-tête de la colonne d’icônes pour trier les versions par
type de révisions. Remarquez les différentes icônes associées aux

différents types de versions utilisés : sauvegardes locales, contrôle de

version (si applicable) et dernière version sauvegardée :
4 Cliquez sur l’en-tête de la colonne Date pour trier les versions dans
l’ordre inverse de leurs dates de modification.
5 Sélectionnez l’élément du haut de la liste (~1~ Sauvegarde locale). Cette
version apparaît dans le volet source sous la liste de révision.
6 Cliquez sur le bouton Synchroniser le défilement.
7 Allez à la ligne 30, qui contient l’instruction boolean packFrame.
8 Sélectionnez l’ensemble de l’instruction et copiez-la :
Sélectionnez Edition|Copier ou utilisez le clavier. Dans la plupart des

schémas d’affectation des touches, le raccourci clavier pour copier est
Ctrl + c.
9 Sélectionnez l’onglet Source pour revenir dans l’éditeur.
Le texte montré dans l’éditeur est le bloc de texte montré dans la page
Sommaire de l’historique comme ci-dessus. Même si la fenêtre de
JBuilder est petite, vous n’aurez pas à faire défiler l’éditeur pour
trouver la ligne 31. Cela, parce que vous avez utilisé le bouton
Synchroniser le défilement.
10 Dans l’éditeur, sélectionnez la ligne 31 (l’instruction boolean packFrame
dans la dernière version) et collez le texte copié dans la page Sommaire

Etape 3 : Utilisation de la page Diff
de l’historique. Sélectionnez Edition|Copier ou utilisez le clavier. Dans

la plupart des schémas d’affectation des touches, le raccourci clavier
pour coller est Ctrl + v.
11 Enregistrez le fichier.
Vous pouvez utiliser la page Sommaire de l’historique pour voir toutes les
versions enregistrées d’un fichier et utiliser les boutons Restaurer et
Synchroniser le défilement. Cette page protège les versions précédentes en
les rendant accessibles en lecture seulement ; elle permet le copier/coller
des versions précédentes vers votre code source actuel.
Ce tutoriel s’achève ici pour les utilisateurs de JBuilder Personnel. Pour
plus d’informations sur la vue historique et les pages Historique, voir
Chapitre 9, “Comparaison des fichiers et versions”.

Fonctionnalité La page Diff montre les différences entre deux versions quelconques du
de JBuilder Professionnel fichier actif et donne accès au bouton Rafraîchir. Nous allons l’essayer.
1 Choisissez l’onglet Diff de l’historique.
2 Cliquez sur l’en-tête Rev. dans la zone Depuis pour trier les versions
par numéro de révisions.
3 Cliquez sur l’en-tête de la colonne d’icônes dans la zone Vers pour trier
les versions par type de révisions.
Vous aurez remarqué que les zone Depuis et Vers sont triées
séparément.
4 Cliquez sur l’en-tête Rev. dans la zone Vers.
Examinons les différences entre deux versions d’un fichier.
1 Sélectionnez ~2~ dans la zone Depuis et Tampon dans la zone Vers.

JBuilder trouve les différences et les affiche dans le volet source :
Dans la zone d’état, en bas, la page Diff indique le nombre de blocs

différents issus de la comparaison.
Utilisateurs du contrôle Pour voir toutes les modifications effectuées dans le référentiel depuis
de versions que vous avez commencé à travailler, sélectionnez la version originelle
du référentiel dans la zone Depuis et la version du fichier ayant le plus
grand numéro de révision dans la zone Vers.
2 Cliquez sur le bouton Rafraîchir. Cela recherche toutes les nouvelles
versions du référentiel. Il n’en existe pas, votre liste de révisions ne
change donc pas.
3 Appuyez sur Alt + n pour aller au bloc différent suivant.
4 Cliquez sur les flèches diff, à gauche de la barre d’état, en bas de la page
Diff, pour aller d’un bloc à l’autre.
5 Cliquez sur le bouton Annuler les modifications. Une option intitulée
Annuler les modifications ci-dessus apparaît.
6 Cliquez sur l’option. La ligne 28 se lit désormais import java.applet.*;.
import java.applet.Applet; disparaît et le bloc de diff est résolu.
Dans la page Diff de l’historique, vous pouvez voir les différences existant
entre toutes les versions disponibles d’un fichier, trier les versions de
nombreuses manières, résoudre les différences entre le tampon et
n’importe quelle autre version, naviguer facilement de différence en
différence entre deux versions.
Ce tutoriel s’achève ici pour les utilisateurs de JBuilder Professionnel.
Pour plus d’informations sur la vue historique et les pages Historique,
voir Chapitre 9, “Comparaison des fichiers et versions”.

Etape 4 : Utilisation de la page Info
Etape 4 : Utilisation de la page Info

Fonctionnalité La page Info donne accès aux commentaires et aux libellés de toutes les
de JBuilder Entreprise. révisions d’un fichier. Vous pouvez la trier en utilisant n’importe laquelle
de ces six colonnes. Elle donne également accès aux boutons Restaurer et
Rafraîchir.
1 Choisissez l’onglet Info.
Sous la liste des révisions, vous voyez le libellé et le commentaire
correspondant à la version du fichier sélectionnée dans la liste.
2 Cliquez sur une version pour voir son libellé et son commentaire.
3 Cliquez sur l’en-tête de la colonne Commentaire dans la liste des
révisions pour trier les versions par commentaire.
4 Sélectionnez la version de sauvegarde locale numéro ~2~.
5 Cliquez sur le bouton Restaurer. La boîte de dialogue Confirmation
pour restaurer apparaît :
Restaurer une version précédente fait que celle-ci redevient la version

courante. Si le fichier est sous contrôle de versions ou si votre niveau de
sauvegarde est suffisamment élevé pour conserver toutes les versions,
toutes les versions intermédiaires sont conservées.
Utilisateurs du contrôle La restauration d’un fichier doit être vérifiée dans le contrôle de
de versions versions comme tout autre modification des fichiers.
6 Cliquez sur OK.
Vous avez utilisé les pages Sommaire, Info et Diff dans la vue historique.
Vous savez comment voir les diverses révisions d’un fichier, trouver et
voir les commentaires et les libellés des révisions d’un fichier, comment
examiner les différences entre les types de versions d’un fichier :
sauvegarde, tampon de mémoire, référentiel et espace de travail.
Pour plus d’informations sur la vue historique et les pages Historique,
voir Chapitre 9, “Comparaison des fichiers et versions”.

Index
A B
affectations de touches 5-22 balises todo 5-28
personnalisation 5-22 barre d’outils (fenêtre principale) 5-3
affichage barre de menus 5-3
fichiers projet 8-20 barre de séparation
aide AppBrowser 5-13
obtenir de l’aide 3-4 barres d’état
utilisation de l’aide en ligne 3-3 AppBrowser 5-16
ajout aux projets 7-14 bibliothèques
Voir aussi projets affichage de la liste 8-5
ajout d’un JDK 8-9 ajout au projet 7-4
ajout de bibliothèques 8-2 ajout et configuration 8-2
AppBrowser 5-1, 5-2 définition des chemins 8-11
barre d’outils 5-3 définitions 8-1
barre de menus 5-3 modification 8-5
barres d’état 5-16 Borland
débogueur 5-15 contacter 1-5
éditeur 5-20 Borland Online 1-5
icônes 5-16
navigation parmi les volets 5-19 C
ouverture de plusieurs AppBrowsers 5-2
recherche dans 5-19 champs Javadoc
redimensionnement du volet contenu 5-13 définition dans l’expert projet 7-6
volet contenu 5-11 chemin de la documentation 8-19
volet en plein écran 5-13 chemin de recherche 8-18
volet message 5-14 chemin de sauvegarde 8-19
volet projet 5-5 chemin de sortie 8-17
volet structure 5-9 chemin des classes 8-18
applets chemin des sources
tutoriel 11-1 fichiers classe 8-15
applications fichiers Java 8-14
tutoriel 10-1 chemins 8-1, 8-16
arborescences Voir aussi définition des chemins
navigation 5-19 compilation, exécution, débogage 8-20
raccourcis de navigation 5-19 emplacements des fichiers classe 8-15
recherche 5-20 emplacements des fichiers java 8-14
Audit d’expression 5-33 chemins des projets
Audit de classe 5-31 définition 7-4
Audit de code 5-29 chercher du texte 5-24
Audit de membre 5-45 codage
Audit de paramètre 5-45 éditeur, utilisation 5-20
configuration 5-34 code
définition des options 5-43 achèvement automatique 5-30, 5-31
échec 5-31 Audit de code 5-29
options d’affichage 5-46 automatisation 6-1
Options générales 5-44 forage dans 5-10
raccourcis clavier 5-30 raccourcis 5-29
Audit de membre 5-31 commandes de recherche 5-24
commentaires
Javadoc 5-27
commentaires Javadoc 5-27
Index I-1
compilation
comment JBuilder trouve les fichiers 8-20
E
concepteur d’interface utilisateur 6-1 EDI 5-1
conception visuelle options 5-51
outils 6-1 personnalisation 5-51
configuration éditeur 5-20
Audit de code 5-34 affectations de touches 5-22
JDK dans JBuilder 8-11 astuces Javadoc 5-27
configuration de bibliothèques 8-2 balises todo 5-28
conseils 5-33 codage 5-20
contacter Borland 1-5 Déplacer, commande 5-26
groupes de discussion 1-6 division de la vue 5-24
World Wide Web 1-5 impression du code source 5-29
contrôle de versions menu contextuel 5-23
comparaison des fichiers 9-1 modèles de code 5-36
conventions d’appellation optimisation des importations 5-34
paquets 8-16 personnalisation 5-37
conventions de la documentation 1-2 recherche 5-24
relatives au Macintosh 1-4 Renommer, commande 5-26
copie de texte Trouver la définition, commande 5-25
depuis le volet message 5-15 Trouver les références, commande 5-25
création des fichiers d’un projet 7-13 émulation d’éditeurs 5-22
encodage
D définition 7-6
enregistrement de plusieurs projets 7-18
débogage 5-33 environnement de développement intégré 5-1
utilisation de l’option -classic 8-9 Voir aussi EDI
Débogage, page (boîte de dialogue Propriétés du examen (forage)
projet) 5-15 de la structure des fichiers 5-9, 5-10
débogueur 5-15 expert Importation de projet 7-8
définition expert Projet
chemins des projets 7-4 création de nouveaux projets 7-2
définition des chemins Etape 1-définition d’une racine, d’un type et
bibliothèques nécessaires 8-11 d’un modèle 7-2
chemin de recherche 8-18 Etape 2-définition des chemins, des
chemin des classes 8-18 bibliothèques, du JDK 7-4
documentation 8-19 Etape 3-définition des propriétés générales du
fichiers source 8-17 projet 7-6
JDK 8-7 experts
Voir aussi JDK galerie d’objets 6-4
sauvegarde 8-19 expressions
sortie 8-17 auto-évaluation 5-33
définition des paquets source automatiques 7-6
définition des propriétés
projets 8-6
F
définition du JDK 8-9 fenêtre
Déplacer, commande 5-26 principale JBuilder 5-1
développement des arborescences de fenêtre principale 5-1, 5-2
l’AppBrowser 5-19 fichiers
diff comparaison 9-1, 9-2
comparaison de deux fichiers 9-2 emplacement 8-20
documentation Voir aussi fichiers projet
titres de JBuilder 3-1 ouverture hors du projet 7-16
renommer 7-17
visualisation des fichiers d’un projet 8-20
I-2 Introduction à JBuilder

fichiers classe 8-17 personnalisation de l’EDI 5-51
comment JBuilder les trouve 8-21 personnalisation de l’éditeur 5-37
emplacements des répertoires 8-15 JDK
fichiers JAR configuration dans JBuilder 8-11
ajout au projet 8-1 débogage avec -classic 8-9
fichiers Java modification 8-8
emplacements des répertoires 8-14 remplacement et définition 8-9
fichiers projet 7-1
chemins 8-20 L
Voir aussi définition des chemins
définition des chemins listes de paramètres 5-33
enregistrement 7-11 localisation de texte 5-24
visualisation 8-20
visualisation de la structure 5-9 M
fichiers source
Macintosh
chemin 8-17
support dans JBuilder 1-4
fichiers ZIP
Menu Chercher 5-24
ajout au projet 8-1
menus
commandes 5-3
G messages d’erreur
galerie d’objets 6-3 volet structure 5-11
experts 6-4 modèle de projet
groupes de discussion 1-6 définition 7-2
Borland 1-6 modèles
code 5-36
I modèles de code
création 5-36
icônes définition des options 5-48
AppBrowser 5-16 modification du JDK 8-8
types de fichiers 5-16 multiples projets 7-17
volet message 5-16 enregistrement 7-18
volet projet 5-16 passer de l’un à l’autre 7-17
volet structure 5-16
vue historique 9-4 N
identificateurs
Trouver la définition, commande 5-25 navigation
importation de projets existants 7-8 volets de l’AppBrowser 5-19
impression notification de syntaxe incorrecte 5-29
code source 5-29
depuis l’éditeur 5-29 O
insertion de classes
obtenir de l’aide 3-3
Audit de classe 5-31
onglets
instructions d’importation 8-15
volet contenu 5-11, 5-12
optimisation 5-34
Optimiser les imports 5-34
options
J affichage 5-41
Java 2-1 audio 5-56
ressources 4-1 concepteur EJB 5-59
Java, langage éditeur 5-38
support dans JBuilder 2-1 Exécuter/Déboguer 5-56
Javadoc navigateur 5-51
balises todo 5-28 structure Java 5-50
JBuilder types de fichiers 5-53
démarrage 5-1 UML 5-58
Index I-3
Web 5-54 référence aux classes dans 8-15
XML 5-55 personnalisation
options Audio EDI de JBuilder 5-51
définition 5-56 éditeur de JBuilder 5-37
options d’affichage 5-41 préférences de couleur
Audit de code 5-46 mise en évidence syntaxique 5-42
options d’importation programmation de l’éditeur 5-20
Audit de classe 5-31 projet par défaut
Options de l’audit de membre 5-45, 5-46 propriétés 5-8
Options de l’audit de paramètre 5-45, 5-47 Projet Welcome
options de l’EDI ouverture 5-1
audio 5-56 visualisation du fichier Remarques version 5-1
concepteur EJB 5-59 projets 7-1
Exécuter/Déboguer 5-56 ajout de dossiers 7-14
navigateur 5-51 ajout de fichiers ou de paquets 7-14, 7-15
types de fichiers 5-53 ajout de fichiers ZIP ou JAR 8-1
UML 5-58 création avec l’expert projet 7-2
Web 5-54 Voir aussi expert Projet
XML 5-55 création de nouveaux 7-2
options de l’éditeur création et ajout d’un fichier 7-13
affichage 5-41 définition des paramètres généraux 7-6
affichage de l’audit de code 5-46 définition des propriétés 5-8, 8-6
Audit de code 5-43 enregistrement 7-11
couleur 5-42 enregistrement de plusieurs 7-18
éditeur 5-38 fermeture 7-11
modèles de code 5-48 importation avec l’expert Importation de
structure Java 5-50 projet 7-8
options du concepteur EJB ouverture 7-12
définition 5-59 passer de l’un à l’autre 7-17
options du navigateur renommer 7-17
définition 5-51 retrait d’un élément 7-16
options Exécuter/Déboguer utilisation de plusieurs projets 7-17
définition 5-56 visualisation 7-10
options UML propriétés
définition 5-58 définition des propriétés d’un projet 5-8
Options Web propriétés des projets
définition 5-54 défaut 5-8
options XML
définition 5-55 R
organisation des projets 7-14
Voir aussi projets raccourcis
outils arborescences de l’AppBrowser 5-19
conception visuelle 6-1 codage 5-29
outils de conception 6-1 Javadoc 5-27
ouverture des fichiers raccourcis commande 5-3
hors du projet 7-16 raccourcis Javadoc 5-27
ouverture des fichiers d’un projet 7-12 raccourcis menu 5-3
recherche 5-20
P avec saisie incrémentale 5-20
avec Trouver les références 5-25
page Diff 9-6 dans l’AppBrowser 5-19
page Info 9-7 dans l’éditeur 5-25
page Sommaire 9-6 dans le volet projet 5-5
palette des composants 6-1 dans le volet structure 5-9
paquets 8-13 dans les arborescences 5-20
conventions d’appellation 8-16 utilisation de Trouver la définition 5-25

recherche de la définition des symboles 5-25
recherche de texte 5-24
U
recherche des références aux Usenet, groupes de discussion 1-6
symbole du code 5-25 utilisation de l’aide 3-3
redimensionnement
volet contenu 5-13 V
réduction des arborescences de l’AppBrowser 5-19
référence aux classes 8-15 version du JDK
références définition dans l’expert projet 7-4
provenant des bibliothèques 7-6 visualisation
remplacement du JDK 8-9 fichiers projet 8-20
Renommer, commande 5-26 visualisation des fichiers d’un projet 7-10
répertoire de travail 8-19 VM
ressources en ligne 1-5 débogage avec -classic 8-9
volet contenu 5-11
onglets 5-11, 5-12
S redimensionnement 5-13
structures des fichiers 5-9 volet en plein écran 5-13
Suivi, page 5-15 volet en plein écran dans l’AppBrowser 5-13
support aux développeurs 1-5 volet message 5-14
support technique 1-5 icônes 5-16
suppression 7-16 volet projet
symboles du code icônes 5-16
recherche de la définition 5-25 recherche 5-5
recherche des références aux 5-25 volet source
refactoring: 5-26 division de la vue 5-24
syntaxe volet structure 5-9
mise en évidence 5-42 icônes 5-16
messages d’erreur 5-11
T navigation dans la structure des fichiers 5-9
ordre de tri 5-9
Trouver la définition 5-33 organisation 5-50
Trouver la définition, commande 5-25 recherche 5-9
Trouver les références, commande 5-25 utilisation pour naviguer dans le code
tutoriels source 5-10
Comment utiliser la vue historique 12-1 vue historique
création d’une applet 11-1 icônes 9-4
création d’une application 10-1 page Diff 9-6
type de fichier page Info 9-7
icônes 5-16 page Sommaire 9-6
types de fichiers présentation 9-4
définition des options 5-53 vues hiérarchisées 5-9
navigation 5-19
vues multiples 5-1
Index I-5

Langue

Bienvenue sur Scribd !

Intro_jb6

Transféré par

Informations du document

Date du transfert

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Description :

Droits d'auteur :

Formats disponibles

Intro_jb6

Transféré par

Description :

Droits d'auteur :

Formats disponibles

Titres liés

Introduction à JBuilder

Introduction à JBuilder fournit des informations détaillées sur

• Chapitre 6, “Développement automatique du code”

1-2 Introduction à JBuilder

JBuilder est disponible sur plusieurs plates-formes. Le tableau ci-dessous

Tableau 1.2 Conventions pour les plates-formes et les répertoires

Remarque pour les utilisateurs du Macintosh

1-4 Introduction à JBuilder

on dit “dossier”. Pour plus d’informations sur les chemins, la terminologie

Comment contacter le support développeur de Borland

World Wide Web http://www.borland.fr/

World Wide Web

mises à jour du logiciel et informations sur les produits existants ou

Groupes de discussion Borland

Groupes de discussion Usenet

1-6 Introduction à JBuilder

Quand vous signalez un bogue, indiquez toutes les étapes nécessaires à la

Support du langage dans JBuilder 2-1

JBuilder vous permet de construire des applications et des applets pour

2-2 Introduction à JBuilder

Pour mieux connaître JBuilder

Pour mieux connaître JBuilder 3-1

3-2 Introduction à JBuilder

Utilisation de l’aide en ligne de JBuilder

Pour mieux connaître JBuilder 3-3

Comment obtenir de l’aide

3-4 Introduction à JBuilder

Pour mieux connaître Java

Manuels Auteurs Public

Pour mieux connaître Java 4-1

Manuels Auteurs Public

Manuels Auteurs Sujet

4-2 Introduction à JBuilder

Manuels Auteurs Sujet

Pour mieux connaître Java 4-3

L’environnement de JBuilder 5-1

• “Personnalisation de l’EDI de JBuilder”, page 5-51

5-2 Introduction à JBuilder

Vous pouvez ouvrir plusieurs AppBrowsers en sélectionnant Fenêtre|

La barre d’outils fournit des boutons de raccourci pour accéder aux

Tableau 5.1 Boutons de la barre d’outils

Fichier|Réouvrir Ouvre à nouveau un projet, un fichier ou un paquet.

L’environnement de JBuilder 5-3

Tableau 5.1 Boutons de la barre d’outils (suite)

Edition|Défaire Dans l’éditeur, réinsère tous les caractères que vous

5-4 Introduction à JBuilder

Tableau 5.1 Boutons de la barre d’outils (suite)

L’environnement de JBuilder 5-5

• L’arborescence de tous les fichiers composant le projet actif.

Pour créer un projet, choisissez Fichier|Nouveau projet dans le menu

5-6 Introduction à JBuilder

Figure 5.2 Menu contextuel du volet projet

L’environnement de JBuilder 5-7

Définition des propriétés d’un projet

Important Il est important de comprendre comment JBuilder utilise les chemins

Propriétés de projet par défaut

5-8 Introduction à JBuilder

Fonctionnalités Visualisation des informations Javadoc