NetBeans



NetBeans.jpg, 27kB

NetBeans est un environnement de développement intégré permettant de développer des applications en Java, C ou Php. Dans ce cours, nous verrons comment utiliser NetBeans pour le développement de projets Java, en attaquant directement le développement d'applications avec interfaces graphiques (c'est à dire possédant une fenêtre).


Fenêtre et composants de bases

Voici par exemple, une fenêtre d'application réalisée avec NetBeans:

Fenetre-Addition.jpg, 14kB

Il s'agit de la fenêtre du projet Addition que vous aurez à réaliser en exercice.

Cette fenêtre comporte sept composants : trois étiquettes, trois champs de texte et un bouton.

Etiquette-ChampTexte-Bouton.jpg, 41kB

Nous avons vu que les champs de texte permettent à l'utilisateur de saisir des données. En fait, ils servent également à afficher des résultats.

Fenetre-Addition-Donnee-Resultat-odg.jpg, 31kB

Dans notre exemple, les deux champs de texte étiquetés X et Y servent à saisir les deux nombres à additionner. Ce sont les données du programme. Le champ texte étiqueté X+Y sert à afficher la somme de ces deux nombres. C'est le résultat du programme produit par l'ordinateur.

Les étiquettes servent donc en principe à indiquer à l'utilisateur quelle donnée il doit introduire dans le champ de texte situé juste à coté ou bien quel résultat y sera affiché.

Lorsque l'utilisateur clique sur le bouton Additionner après avoir saisi les deux nombres dans les champs de texte prévus à cet effet, le programme affiche le résultat dans le champ de texte étiqueté X+Y.

Un bouton sert donc à déclencher un traitement d'information particulier (dans notre cas l'addition de deux nombres).

Nous utiliserons également dans ce cours les zones de texte. Une zone de texte est un composant qui permet d'afficher du texte sur plusieurs lignes. Voici par exemple une fenêtre comportant une zone de texte:

ZoneDeTexte.jpg, 46kB

Organisation d'un projet

Il existe de nombreuses manières d'organiser les fichiers sources d'un projet java réalisé avec NetBeans. Avant d'aborder la programmation objet, nous nous contenterons d'une organisation simplifiée, qui sera la même pour tous les exercices et tous les exemples.

Nous supposerons que l'interface graphique du projet comporte une seule fenêtre et que tout le code est contenu dans un seul fichier source java.

Si votre projet s'appelle Toto, le code source sera contenu dans le fichier Toto.java du dossier Toto.

Code initial

Dans certains exercices, vous aurez à réaliser le projet de A à Z, interface graphique incluse. Vous allez alors démarrer avec une fenêtre vide, c'est à dire que la fenêtre de votre application sera dépourvue de tout composants (champ de texte, bouton, etc ..).

Par contre, le fichier source de votre projet contiendra du code dès le départ. Ce code est généré automatiquement par NetBeans. Pour l'instant, il n'est pas important que vous en compreniez la signification, mais vous aurez besoin d'en connaitre l'organisation afin de savoir où vous allez pouvoir insérer votre code java.

Par exemple, lorsque vous allez créer le projet Addition, vous constaterez que le fichier Addition.java contient le code suivant (les commentaires ont été supprimés pour plus de clarté):

CodeInitial.jpg, 48kB

Ce code généré automatiquement est la déclaration d'une classe nommée Addition, qui représente la fenêtre de l'application. Nous aborderons la notion de classe beaucoup plus tard dans une partie entièrement consacrée à la programmation objet. Les détails de ce code généré automatiquement par NetBeans vous échapperons donc encore pendant un bon moment. Mais soyez patient ...

Le nom en jaune est le nom de la fenêtre. Dans les projets de ce cours, ce nom sera toujours identique au nom du projet, mais sachez que ceci n'est pas obligatoire.

Ajout de composants

De manière générale, la réalisation d'un projet démarre avec une fenêtre vide. Au fur et à mesure que le programmeur y ajoute des composants, leurs noms générés automatiquement apparaissent dans le code source.

Par exemple dans le projet Addition, NetBeans va générer les noms suivants pour les composants:

Composants-Noms-Par-Defaut.jpg, 53kB

Vous constaterez que ces nom apparaissent dans le code au fur et à mesure que vous ajouter des composants sur la fenêtre de votre application.

Avant même d'avoir écrit une seule ligne de code vous aurez le code suivant dans votre fichier source (les noms des composants sont en blanc).

Ces noms permettrons d'accéder aux composants par programme. Il ne faut pas les confondre avec leurs libellés. Les libellés apparaissent sur l'interface graphique. Les noms quand à eux sont invisibles.

Par exemple, le nom du bouton est jButton1, mais son libellé est Additionner.

Pour pouvoir plus facilement identifier les composants dans le programme, le développeur peut leur donner des noms plus significatifs que ceux générés automatiquement par NetBeans. Par exemple BoutonAdditionner au lieu de Button1 pour le bouton, ChampTexteX et ChampTexteY pour les champs de texte contenant les deux nombres à additionner ...

La modifications des noms des composants se fait via l'interface graphique de NetBeans. Ils sont alors automatiquement modifiés dans le code.

Programmation évènementielle

L'interface graphique de NetBeans est concue pour faciliter la programmation évènementielle.

Rappelons que la programmation évènementielle consiste à associer des gestionnaires d'évènement à des évènements de l'interface graphique. Un évènement est définit par un composant de l'interface et un type d'interruption. Par exemple, un bouton (composant) et un clic sur ce bouton (interruption). Lorsque cet évènement a effectivement lieu, les instructions contenues dans le gestionnaire d'évènement associé sont automatiquement exécutées.

En programmation, un gestionnaire d'évènement s'appelle également procédure évènementielle. Dans ce cours, nous utiliserons indifféremment ces deux appellations.

Pour associer une procédure évènementielle à un composant, le développeur n'a besoin de taper aucune ligne de code. Il lui suffit en gros de cliquer sur le composant et éventuellement de sélectionner le type d'évènement. Un double clic sur un composant sélectionne l'évènement par défaut. La déclaration de la procédure évènementielle est alors automatiquement générée dans le code avec un nom formé à partir du nom du composant et du nom de l'évènement.

Reprenons l'exemple de notre programme d'addition.

Supposons que le dévoppeur souhaite associer une procédure évènementielle au bouton Additionner qui serait activée lorsque l'utilisateur clique sur ce bouton.

Pour cela, il lui suffit de faire un double clic sur ce bouton (schéma) et la déclaration de cette procédure évènementielle sera automatiquement générée dans le code source, avec aucune instruction à l'intérieur.

Le nom de cette procédure est BoutonAdditionnerActionPerformed. Il est formé à partir du nom du composant (ici BoutonAdditionner) et du nom de l'évènement (ActionPerformed = clic de souris sur le bouton).

Le développeur complètera ensuite ce gestionnaire d'évènement en placant des instructions à l'intérieur (c'est à dire entre les deux accolades), qui seront automatiquement exécutées lorsque l'utilisateur cliquera sur ce bouton.

Ordre d'exécution des instructions

En général, un programme ne s'exécute pas dans l'ordre des lignes du code source, c'est à dire de la première à la dernière ligne du fichier.

Considérons un programme dont l'interface graphique possède trois boutons A,B et C (figure).

Dans le code source, on a d'abord la procédure évènementielle du bouton B, puis celle du bouton A, puis celle du bouton C. Mais, l'ordre d'exécution de ces procédures est totalement indépendant de l'ordre dans lequel elles figurent dans le fichier source. Cela dépend évidemment de l'ordre dans lequel l'utilisateur cliquera sur les boutons A, B et C. Une même procédure peut même être exécutée plusieurs fois.

Lorsqu'une procédure évènementielle a fini de s'exécuter, le programme retourne dans un état d'attente d'évènement.