Création d'une application Java GUI dans NetBeans. Interface utilisateur fenêtrée dans un programme Java

22.07.2019

Cet article explique comment créer l'application simple présentée dans la figure de droite, ainsi que son code source.

Pour placer des boutons, des étiquettes de texte et d'autres composants dans une fenêtre de programme, vous devez comprendre le fonctionnement de JPanel. C'est un peu comme un conteneur de composants qui occupe une zone rectangulaire de l'écran et affiche les composants alignés de manière simple. La manière exacte dont les composants sont alignés dépend du type de disposition que vous avez installé pour le panneau. Pour les tâches de programmation simples, vous devez connaître au minimum BorderLayout, qui place les composants sur les bords et un gros composant au milieu, puis FlowLayout, qui aligne généralement les composants horizontalement, et enfin GridLayout, qui organise les composants dans un tableau personnalisé n*. m. Il existe d'autres types, mais ils sont trop difficiles pour les débutants. L'idée clé est qu'un « composant » peut être autre chose qu'un bouton ou une case à cocher. JPanel. Vous pouvez obtenir une interface utilisateur assez complexe en empilant simplement les panneaux les uns sur les autres et en choisissant une disposition pour eux.

Si vous avez une instance d'objet PanneauJ appeler la méthode .setLayout pour définir le type de mise en page, puis la méthode.add pour ajouter des composants au panneau. Au cas où Disposition des bordures vous devrez passer la position comme deuxième paramètre. Par exemple, pour positionner le bouton en haut, appelez monPanel.add(monBouton, BorderLayout.North).

Le conteneur de niveau le plus élevé qui apparaît à l'écran représentant une application Java est une instance JFrame, pas PanneauJ. Pour ajouter votre panneau principal à une instance JFrame il suffit d'appeler myJFrame.getContentPane().add(myJPanel, BorderLayout.Center).

Pour que votre application fasse plus que simplement apparaître, vous devrez comprendre l'interface ActionListener. Tout non abstrait ActionListener il n'y a qu'une seule méthode actionEffectuée qui est appelé lorsque l'utilisateur effectue une "action" sur le composant dans lequel l'auditeur est enregistré (par exemple, l'action sur un bouton consiste évidemment à appuyer dessus). Pour enregistrer un écouteur d'action pour un bouton ou tout autre composant, appelez la méthode .addActionListener. .

Mesures

Création d'un cadre partagé

Créer une classe qui étend la classe JFrame. Cette classe contiendra tous les composants de votre interface graphique (GUI) tels que les boutons et les champs de texte.

Pensez à l’apparence générale de votre première application. Un bon point de départ serait avec un panneau central comme Disposition des bordures avec un autre panneau en bas ( BorderLayout.Sud). Ce deuxième panneau sera de type Disposition du flux et contiennent plusieurs boutons, cases à cocher et autres éléments de contrôle. Enfin, positionnez le gros composant JTextZone au milieu du composant central. Pour interagir avec l'utilisateur par texte, vous pourrez utiliser des méthodes obtenirTexte() Et setTexte().

Écrivez un constructeur pour votre classe. Ce concepteur doit créer tous les panneaux et composants que vous avez prévus, les disposer correctement et ajouter le panneau final qui « attache le tout » à votre cadre. (myFrame.getContentPane().add(myLargePanel, BorderLayout.Center).

Écrivez une méthode principale qui sera le point d'entrée du programme. Dans cette méthode, créez une instance du cadre, définissez sa taille et sa position initiales (utilisez. setSize(x,y) Et .setLocation (largeur, hauteur)), et faites-le apparaître à l'écran en appelant .setVisible(vrai).

Programmation des réponses aux actions des utilisateurs

Faites en sorte que votre cadre implémente une interface ActionListener. Cela permettra à votre classe « d'écouter » les actions des composants.

Pour chaque bouton, case à cocher ou autre contrôle que vous créez, appelez une méthode.addActionListener passer ton cadre ( ce) comme paramètre.

Remplacez la méthode abstraite de la classe ActionListener appelée actionPerformed (événement ActionEvent). Dans cette méthode, vous devez ajouter des instructions conditionnelles « if » pour vérifier d'où vient l'événement. Cette instruction conditionnelle « si » doit avoir une condition comme celle-ci : " if (event.getSource() == bouton1)". Cela vérifie d'où vient l'événement et s'il provient du bouton. Dans l'instruction "if", effectuez l'action dont vous avez besoin lorsque vous cliquez sur le bouton.

U JTextZone il y a une méthode .setText("monTexte"), ce qui est un bon moyen de programmer une sorte de réponse visible à votre action.

Ce n'est pas beaucoup plus difficile d'implémenter une interface Écouteur de souris et utiliser .addMouseListener pour l'enregistrer pour n'importe quel composant.
Si vous devez inviter l'utilisateur à saisir une chaîne, appelez la méthode statique J OptionPane.showInputDialog(this, "Mon message"). Le premier paramètre doit être votre cadre d'application ou une sorte de panneau (le champ de saisie apparaîtra au milieu de l'élément parent). La méthode renvoie la valeur que l'utilisateur a entrée dans la boîte de dialogue.
Il est tout à fait possible de placer tous les composants sur un seul panneau en utilisant le type GrilleBagLayout mais cette classe est plus difficile à contrôler.
Si vous souhaitez dessiner vos propres graphiques (comme un échiquier), renseignez-vous sur le composant Canvas. Il peut être placé dans votre application comme n'importe quel autre composant, mais vous devrez écrire une méthode .paint qui sera seule responsable de sa peinture.
Dans de nombreuses applications du monde réel, le composant Swing le plus utile est la JTable. Après avoir appris les bases, continuez à travailler avec.

Avertissements

Certains outils de développement offrent la possibilité de composer une interface graphique Swing de manière « conviviale ». Cependant, ils ne parviennent souvent pas à créer correctement un panneau doté de fonctionnalités avancées. Ces fonctionnalités incluent des arborescences, des tableaux, des listes et des zones de liste déroulante dont le contenu change au fur et à mesure de l'exécution du programme, des composants avec des modèles de données utilisateur, etc. Le code écrit de cette manière « conviviale » deviendra un véritable cauchemar si vous devez ensuite l'ajouter manuellement. Ne vous laissez donc pas trop emporter par ce type de "concepteurs d'interface graphique conviviaux", car cela limitera vos options en raison de leurs capacités limitées.
Swing est une application à thread unique. Si votre action prend trop de temps à traiter, elle sera bloquée jusqu'à la fin de la méthode. .actionPerformed. Apprenez et utilisez le multithreading Java pour maintenir Swing en vie pendant l'exécution d'un processus fastidieux.
La plupart des méthodes des composants Swing ne peuvent être appelées en toute sécurité qu'à partir du thread de répartition d'événements (méthode .actionPerformed et d'autres méthodes d'écoute similaires). Si vous devez les appeler depuis un autre thread (par exemple, pour mettre à jour une barre de progression ou afficher les résultats d'un processus de longue durée), lisez à propos de SwingUtils.invokeLater.

Sources

Code source

Importer java.awt.BorderLayout ; importer java.awt.FlowLayout ; importer java.awt.event.ActionEvent ; importer java.awt.event.ActionListener ; importer javax.swing.JButton ; importer javax.swing.JCheckBox ; importer javax.swing.JFrame ; importer javax.swing.JPanel ; importer javax.swing.JTextArea ; /** * Une application Java Swing très simple.*Contient un bouton et une case à cocher. Répond * aux modifications apportées à ces contrôles * en modifiant le texte dans le champ de texte principal. * * @auteur audriusa */ classe publique WikiHow étend JFrame implémente ActionListener ( /** * Button. */ JButton myButton = new JButton ("Button" ) ; /** * Checkbox. */ JCheckBox myCheckBox = new JCheckBox ( "Check" ) ; /** * Champ de texte.*/ JTextArea monTexte = new JTextArea ("Mon texte" ) ;/** * Le panneau inférieur contenant le bouton. */ JPanel bottomPanel = new JPanel();

/** * Le panneau parent contenant tout.

Les environnements qui vous permettent de placer de manière interactive des composants sur des formulaires et de définir leurs paramètres lors du développement d'applications sont appelés environnements RAD. RAD signifie Rapid Application Development - développement rapide d'applications.

Dans NetBeans et d'autres environnements de développement modernes, ce processus est basé sur le modèle objet composant, c'est pourquoi il est appelé conception orientée objet (OOD).

NetBeans est un environnement RAD qui vous permet de créer rapidement et facilement des applications avec une interface utilisateur graphique (GUI) riche. Bien que les constructions du langage Java qui vous permettent de le faire ne soient pas très simples, au stade initial du travail avec les formulaires d'écran et leurs éléments, il n'est pas nécessaire d'approfondir ces subtilités. Il suffit de connaître les principes de base du travail sur de tels projets.

Tout d'abord, dès le début, vous apprendrez à créer des applications à part entière pouvant être utilisées à des fins utiles. Il est difficile d'étudier des concepts abstraits pendant des mois et de devenir un professionnel uniquement pour pouvoir créer quelque chose qui puisse être montré aux autres. Il est beaucoup plus intéressant et utile de commencer immédiatement à mettre en pratique les connaissances acquises.

Deuxièmement, une telle interface, lors de la résolution d'un problème, vous permet de mieux formuler quels paramètres doivent être saisis, quelles actions doivent être effectuées et dans quel ordre, et ce qui est finalement obtenu. Et affichez tout cela à l'écran : les éléments de saisie de texte correspondront aux paramètres saisis, les boutons et éléments de menu correspondront aux actions, les éléments de sortie de texte correspondront aux résultats.

Un exemple d'ouverture d'un projet avec du code source existant.

NetBeans 5.0 avait un bon exemple d'application GUI, mais NetBeans 5.5 n'en a pas. Par conséquent, pour des travaux ultérieurs, vous devez copier un exemple similaire du site Web de l’auteur ou du site Web sur lequel cette formation est publiée. L'exemple s'appelle JavaApplicationGUI_example.

Tout d'abord, vous devez décompresser l'archive zip et extraire le dossier contenant les fichiers de projet qui s'y trouvent dans le dossier contenant vos projets (par exemple, C:\Documents and Settings\User). Démarrez ensuite l'environnement NetBeans s'il n'était pas déjà en cours d'exécution et fermez tous les projets ouverts pour les écarter. Sélectionnez ensuite Fichier/Ouvrir le projet dans le menu, ou l'icône avec un dossier violet d'ouverture dans la barre d'outils, ou appuyez sur la combinaison de touches ++O. Dans la boîte de dialogue qui s'ouvre, sélectionnez un dossier JavaApplicationGUI_example(il vaut mieux ne pas y entrer, mais simplement définir la sélection sur ce dossier), puis cliquer sur le bouton Ouvrir le dossier du projet.

Dans ce cas, si vous ne décochez pas la case « Ouvrir comme projet principal », le projet devient automatiquement le projet principal.

Le texte suivant apparaît dans la fenêtre de l'éditeur de code source :

* GUI_application.java

paquet java_gui_example ;

* @auteur Vadim Monakhov

la classe publique GUI_application étend javax.swing.JFrame (

* Crée un nouveau formulaire GUI_application

application_GUI publique() (

initComponents();

/** Cette méthode est appelée depuis le constructeur pour

* initialiser le formulaire.

* AVERTISSEMENT : Ne modifiez PAS ce code. Le contenu de cette méthode est

* toujours régénéré par l'éditeur de formulaire.

private void exitMenuItemActionPerformed(java.awt.event.ActionEvent evt)

* @param argumente les arguments de la ligne de commande

public static void main (arguments de chaîne) (

java.awt.EventQueue.invokeLater(new Runnable() (

public void run() (

new GUI_application().setVisible(true);

// Déclaration des variables - ne pas modifier

privé javax.swing.JMenuItem aboutMenuItem ;

private javax.swing.JMenuItem contentsMenuItem ;

privé javax.swing.JMenuItem copyMenuItem ;

privé javax.swing.JMenuItem cutMenuItem ;

privé javax.swing.JMenuItem deleteMenuItem ;

privé javax.swing.JMenu editMenu ;

privé javax.swing.JMenuItem exitMenuItem ;

privé javax.swing.JMenu fileMenu ;

privé javax.swing.JMenu helpMenu ;

privé javax.swing.JMenuBar menuBar ;

privé javax.swing.JMenuItem openMenuItem ;

privé javax.swing.JMenuItem pasteMenuItem ;

privé javax.swing.JMenuItem saveAsMenuItem ;

privé javax.swing.JMenuItem saveMenuItem ;

// Fin de la déclaration des variables

Expliquons certaines de ses parties. Nous sommes déjà familiers avec la spécification du package java_gui_example dans lequel se trouvera le code de la classe d'application. La déclaration de la classe GUI_application elle-même dans ce cas est un peu plus compliquée qu'auparavant :

la classe publique GUI_application étend javax.swing.JFrame

Cela signifie que la classe publique GUI_application est définie, qui est un descendant de la classe JFrame définie dans le package swing, imbriquée dans le package javax. Le mot extends est traduit par « étend » (une classe descendante étend toujours les capacités de la classe ancêtre).

Le constructeur public GUI_application() crée un objet d'application et initialise tous ses composants à l'aide de la méthode initComponents(), qui est automatiquement générée par l'environnement de développement et masquée dans le code source par le nœud +Generated Code.

En développant le nœud, vous pouvez voir l'implémentation de cette méthode, mais vous ne pouvez pas modifier le code. Nous ne nous attarderons pas sur ce qui y est fait.

sortie de vide privéMenuItemActionPerformed

On en discutera un peu plus tard. Méthode

public static void main (arguments de chaîne)

nous le savons déjà – c’est la méthode principale de l’application. C'est une méthode de notre classe d'application et est automatiquement exécutée par la machine Java au démarrage de l'application. Dans cet exemple, la méthode crée un formulaire d'écran d'application et le rend visible. Afin de comprendre comment cela se fait, vous devrez étudier de nombreux sujets dans le cadre de ce cours.

Application en cours d’exécution. Une application avec un menu étendu.

Au démarrage de l'application, le formulaire d'écran ressemble à celui illustré sur la figure. Il dispose déjà d'un modèle de menu qui peut être développé et réduit, et même l'élément Quitter fonctionne. En cliquant dessus, vous quittez l'application.

L'opérateur exitMenuItemActionPerformed est chargé de cliquer sur cet élément de menu. Lors de la conception d'un formulaire d'écran, il est affecté comme gestionnaire d'événements– un sous-programme exécuté lorsqu'un événement se produit. Dans notre cas, l'événement est la sélection de l'élément de menu Exit et le gestionnaire exitMenuItemActionPerformed est appelé. Il n'y a qu'une seule ligne à l'intérieur

Cela entraîne l’arrêt de l’exécution de la méthode principale et la sortie de l’application avec un code de sortie de zéro. En règle générale, un code de sortie différent de zéro est renvoyé lorsqu'une application se termine anormalement afin que sa valeur puisse être utilisée pour déterminer les raisons du crash du programme.

Éditeur d'écran

Cliquez sur l'onglet Conception dans la partie supérieure gauche de l'éditeur de code source. Dans le même temps, nous passerons du mode d'édition du code source (l'onglet Source est actif) au mode d'édition du formulaire écran, comme le montre la figure.

Modification d'un formulaire d'écran.

Au lieu du code source, l'apparence du formulaire d'écran et les composants qui s'y trouvent sont affichés. À droite de la fenêtre dans laquelle le masque est affiché en mode édition se trouvent les fenêtres Palette pour la palette des composants et la fenêtre Propriétés pour l'affichage et l'édition des propriétés du composant actuel.

Une propriété est un champ de données qui peut effectuer une action après avoir modifié sa valeur. Par exemple, lorsque vous modifiez la valeur de la largeur d'un composant, dessinez le composant avec la nouvelle largeur sur l'écran. Un champ de données « normal » n'en est pas capable. Ainsi, une propriété est un « champ de données intelligent ».

La palette de composants est conçue pour sélectionner le type de composant que le programmeur doit placer sur le formulaire d'écran. Par exemple, ajoutons un composant de type JButton (abréviation de Java Button - « bouton Java ») à notre formulaire. Pour ce faire, cliquez sur l'élément JButton de la palette et déplacez la souris à l'emplacement souhaité sur le masque. Lorsque la souris frappe une zone du formulaire d'écran, un bouton de taille standard apparaît dessus, qui se déplace avec la souris. En cliquant à l'emplacement souhaité sur le formulaire, le bouton reste à cet emplacement. Un cadre et des petits carrés apparaissent autour, indiquant que notre composant est sélectionné. Ses propriétés sont affichées et modifiées dans la fenêtre Propriétés.

De plus, des lignes émanent du composant sélectionné, sur lesquelles il y a un accrochage pour définir la position du composant sur le formulaire.

Par défaut, les étiquettes sur les composants sont spécifiées sous la forme du nom du type suivi du numéro du composant. Mais au lieu d'une lettre majuscule, contrairement au nom du type, une lettre minuscule est utilisée. Par conséquent, le premier bouton sera étiqueté jButton1, le second - jButton2, et ainsi de suite. Les variables correspondant aux boutons créés automatiquement dans le code source porteront les mêmes noms.

Il existe plusieurs façons de modifier l'étiquette d'un bouton. Tout d’abord, double-cliquez dessus et modifiez le texte. Deuxièmement, en allant dans la fenêtre Propriétés, en modifiant la valeur de la propriété Texte et en cliquant sur pour compléter l'entrée. Troisièmement, en modifiant la propriété label de la même manière. Enfin, dans la fenêtre Propriétés, vous pouvez modifier le texte non pas dans un champ de saisie de valeur sur une seule ligne pour les propriétés du texte ou de l'étiquette, mais en ouvrant un éditeur multiligne en cliquant sur le bouton à droite de l'élément d'édition de la valeur de la propriété. Cependant, la nature multiligne de l'éditeur ne permet pas de rendre l'étiquette du bouton multiligne.

Entrez « OK » sur le bouton – utilisez ce bouton pour quitter le programme.

Modification des propriétés des composants

La taille du composant est définie avec la souris en saisissant le cadre et en l'agrandissant ou en le contractant dans les directions appropriées. Installation vers un nouvel emplacement en faisant glisser le composant avec la souris.

Certaines propriétés du composant sélectionné (sa taille, sa position, son texte) peuvent être modifiées directement dans la zone d'affichage. Cependant, la plupart des propriétés sont affichées et modifiées dans la fenêtre Propriétés Modifier. Il se compose de deux colonnes : celle de gauche affiche les noms des propriétés, celle de droite affiche leurs valeurs. Les valeurs de la colonne de droite peuvent dans de nombreux cas être modifiées directement dans les cellules du tableau. Dans ce cas, la saisie se termine en appuyant sur ou quitter la cellule modifiée, et vous pouvez annuler les résultats d'une saisie inachevée en appuyant sur .

Sur le côté droit de chaque cellule se trouve un bouton intitulé «…» - dans les systèmes d'exploitation modernes, il est d'usage d'ajouter trois points dans les noms des éléments de menu et des boutons, après avoir cliqué sur lesquels une boîte de dialogue s'ouvre. Dans ce cas, une fenêtre d'édition spécialisée de la propriété correspondante s'ouvre, si elle existe.

Si vous devez afficher et modifier un grand nombre de propriétés de composants, il peut être plus pratique de cliquer avec le bouton droit sur le composant souhaité et de sélectionner « Propriétés » dans le menu contextuel qui apparaît. Dans ce cas, une fenêtre distincte pour modifier les propriétés du composant s'ouvrira. Vous pouvez garder un nombre arbitraire de ces fenêtres ouvertes en même temps.

Les propriétés booléennes dans la colonne de valeur de propriété sont affichées sous forme de boutons de sélection de cases à cocher - des carrés avec la possibilité de placer une coche à l'intérieur. S'il n'y a pas de coche, la valeur de la propriété est fausse ; s'il y a une coche, la valeur de la propriété est vraie.

En utilisant un bouton comme exemple, nous répertorions un certain nombre de propriétés parmi les plus importantes pouvant être définies pour les composants. Beaucoup d’entre eux s’appliquent également à d’autres composants.

Nom de la propriété	Que demande-t-il ?
arrière-plan	Couleur de fond
composantPopupMenu	Permet de désigner un menu contextuel qui apparaît lorsque vous cliquez avec le bouton droit dans la zone du composant.
fonte	La police utilisée pour écrire sur le composant.
premier plan	La couleur de la police utilisée pour l'inscription sur le composant.
icône	Une image dessinée sur le composant à côté du texte.
texte	Texte (étiquette) sur le composant.
outilTipText	Une info-bulle qui apparaît au bout d'un moment lorsque vous passez la souris sur un composant.
frontière	Le type de cadre autour du composant.
frontièrePeint	Indique si une bordure est dessinée autour du composant.
contentAreaFilled	Existe-t-il un remplissage de couleur pour la zone interne du composant (pour les boutons, cela crée un effet tridimensionnel ; sans remplissage, le bouton semble plat).
Capable par défaut	Le bouton est-il capable d’être un « bouton par défaut » : lorsqu’il est enfoncé Le « bouton par défaut » est automatiquement enfoncé (il devrait y avoir un de ces boutons sur le formulaire d'écran).
activé	Si le composant est disponible. Par défaut, tous les composants créés sur le formulaire sont disponibles. Les composants inaccessibles sont peints avec des couleurs plus ternes.

A titre d'exemple, ajoutons une info-bulle pour notre bouton : saisissez le texte « Ce bouton est destiné à quitter le programme » dans le champ correspondant à la propriété toolTipText. Malheureusement, l'indice ne peut être que sur une seule ligne - les caractères de nouvelle ligne sont ignorés lors de l'affichage de l'indice, même s'ils sont spécifiés dans la ligne par programme.

Enfin, définissons l'action qui sera effectuée lorsque vous cliquerez sur le bouton - gestionnaire d'événements(gestionnaire d'événements) clique sur le bouton. Pour cela, sélectionnez d'abord le bouton, puis faites un clic droit dessus, et dans le menu contextuel qui apparaît, sélectionnez Events/Action/actionPerformed.

Affectation d'un gestionnaire d'événements

Events signifie « Événements », Action signifie « Action », actionPerformed signifie « action effectuée ».

Après cela, une transition automatique vers l'éditeur de code source se produira et un gestionnaire d'événements de modèle y apparaîtra :

// TODO ajoutez votre code de gestion ici :

Un résultat similaire peut être obtenu de manière plus rapide - après avoir sélectionné un bouton dans la fenêtre d'édition du formulaire (Conception), le nom de ce bouton est affiché et mis en surbrillance dans la fenêtre du Navigateur. Un double-clic sur ce nom dans la fenêtre du navigateur entraîne la création d'un gestionnaire d'événements modèle.

À côté du gestionnaire jButton1ActionPerformed, il y aura un gestionnaire d'événements existant qui est déclenché lorsque l'on clique sur l'élément de menu « Quitter » :

private void exitMenuItemActionPerformed(java.awt.event.ActionEvent evt) (

Remplaçons la ligne par le commentaire dans notre gestionnaire d'événements par le code qui provoque la fermeture du programme :

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) (

Désormais, après avoir lancé notre application, déplacer le curseur de la souris sur le bouton fera apparaître une info-bulle et cliquer sur le bouton quittera le programme.

Un cas courant consiste à afficher un message lorsqu'un événement se produit, par exemple en appuyant sur un bouton. Dans ce cas, le panneau est appelé avec le message :

javax.swing.JOptionPane.showMessageDialog(null,"J'ai été cliqué");

Si les classes du package javax.swing sont importées, le préfixe javax.swing n'est pas nécessaire lors de leur appel.

Apparence de l'application

Au stade de l’édition de l’application, l’apparence de ses composants correspond à la plateforme. Cependant, une fois lancées, cela devient complètement différent, puisque par défaut, toutes les applications Java sont affichées indépendamment de la plate-forme :

Apparition d'une application en cours d'exécution avec une interface utilisateur indépendante de la plate-forme définie par défaut

De plus, notre application apparaît dans le coin supérieur gauche de l’écran, mais nous aimerions qu’elle apparaisse au centre.

Afin d'afficher l'application sous une forme spécifique à la plate-forme (c'est-à-dire sous une forme qui utilise les composants et les paramètres du système d'exploitation), vous devez modifier le code du constructeur de l'application en insérant un type d'interface utilisateur (Interface utilisateur, en abrégé UI) avant d'appeler la méthode initComponents :

importer javax.swing.* ;

importer java.awt.* ;

application_GUI publique() (

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());

)catch(Exception e)();

initComponents();

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

Dimension frameSize = getSize();

setLocation(nouveau Point((screenSize.width-frameSize.width)/2,

(screenSize.height-frameSize.width)/2)

Apparition d'une application en cours d'exécution avec une interface utilisateur orientée plateforme dans le système d'exploitation Windows ® XP

Le code qui suit l'appel à initComponents() consiste à placer la fenêtre de l'application au centre de l'écran.

Il est possible de spécifier un autre type d'application indépendant de la plate-forme - dans le style Motiff utilisé dans le système d'exploitation Solaris ®. Pour définir ce type au lieu d'appeler

UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()

Devrait être écrit

UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");

Apparition d'une application en cours d'exécution avec une interface utilisateur indépendante de la plate-forme dans le style Motiff

Les constructions utilisées deviendront claires pour le lecteur après avoir étudié d'autres sections du manuel.

Gestion de projet

Afin de ne pas vous tromper dans les différents projets et leurs versions, compte tenu notamment du fait que les projets éducatifs doivent souvent être transférés d'un ordinateur à un autre, vous devez prendre la gestion de projet au sérieux. L'auteur, grâce à de nombreuses années d'expérience de travail avec différents langages et environnements de programmation, a développé le système suivant (corrigé en application à l'environnement NetBeans) :

· Pour chaque projet, un dossier portant le nom du projet est créé. Nous l'appellerons le dossier d'archives de ce projet. Les noms des dossiers utilisés peuvent être en russe, ainsi que les noms des applications et des fichiers.

· Lors de la création d'un nouveau projet, l'environnement de développement vous invite à saisir un nom de dossier où le stocker - vous devez spécifier le nom du dossier d'archive. Vous êtes également invité à saisir un nom de projet. Ce nom sera utilisé par NetBeans pour créer à la fois le dossier du projet et le nom de votre application. Afin de faciliter le fonctionnement de votre candidature dans différents pays, il est recommandé de faire ce nom en anglais. Dans le dossier du projet, l'environnement de développement créera automatiquement un système de sous-dossiers pour le projet et tous ses fichiers. La structure des dossiers du projet NetBeans a été décrite précédemment.

· Si un projet avec du code source existant est pris, son dossier est copié dans notre dossier d'archives soit manuellement, soit en sélectionnant la séquence d'actions appropriée dans l'assistant de création de projet NetBeans.

· Lorsque vous recevez une version quelque peu exploitable du projet, vous devez en faire une copie d'archive. Pour ce faire, dans un projet ouvert dans la fenêtre « Projets », faites un clic droit sur le nom du projet et sélectionnez « Copier le projet » dans le menu contextuel qui apparaît. Un formulaire de dialogue s'ouvrira dans lequel un nom de copie généré automatiquement est proposé - un trait de soulignement et un numéro de copie sont ajoutés au nom du projet d'origine. Pour la première copie c'est _1, pour la seconde _2, et ainsi de suite. De plus, le dossier principal de l'archive reste par défaut le même que celui du projet d'origine. Ce qui est très pratique, car cela permet de créer une copie en seulement trois clics de souris sans rien taper au clavier.

Création d'une copie de travail du projet

Le projet copié apparaît automatiquement dans la fenêtre « Projets », mais ne devient pas le projet principal. Autrement dit, vous continuez à travailler avec le projet précédent et toutes ses fenêtres ouvertes sont enregistrées. Vous pouvez fermer immédiatement un nouveau projet en cliquant avec le bouton droit sur son nom et en sélectionnant « Fermer le projet » dans le menu contextuel qui apparaît.

Pourquoi un tel système de gestion de projet est-il nécessaire ? Le fait est que les programmeurs débutants ont l'habitude de détruire les résultats de leur propre travail. Ils développent le projet sans conserver d'archives. Ils l'amènent à un état presque fonctionnel, après quoi ils l'améliorent un peu plus, puis encore - et tout cesse de fonctionner. Et comme ils sont complètement confus, il n’existe aucun moyen de restaurer une version fonctionnelle. Et ils n’ont rien à montrer au professeur ou au patron !

Par conséquent, vous devez vous habituer à copier dans l'archive toutes les versions intermédiaires du projet qui sont plus efficaces que celles déjà enregistrées dans l'archive. Dans les projets réels, il est difficile de se souvenir de toutes les modifications apportées à une version particulière et, plus important encore, de toutes les relations qui ont provoqué ces modifications. Par conséquent, même les programmeurs expérimentés doivent de temps en temps admettre : « Rien ne fonctionne ! Et restaurer une version qui ne comportait pas encore ces innovations qui prêtaient à confusion. De plus, il arrive souvent que la nouvelle version ne fonctionne pas correctement dans certaines situations. Et il faut remonter des dizaines de versions à la recherche de celle où il n'y avait pas de tels "problèmes". Et puis comparez soigneusement le travail des deux versions, pour découvrir la raison du mauvais fonctionnement de la version ultérieure. Ou assurez-vous que toutes les versions précédentes ne fonctionnaient pas également correctement, elles n'ont tout simplement pas remarqué l'erreur.

Politique étrangère de l'URSS pendant les années de guerre. Prêt-bail. Conférence de Téhéran. Conférences de Yalta et Potsdam 1945 Création de l'ONU.

Politique étrangère de l'URSS pendant la guerre. Conférence de Téhéran. Conférence de Yalta et Potsdam 1945 Création de l'ONU.

Reprise des activités de BSG. Création des partis et organisations Belnats

Tout développeur commence une époque où créer des applications console n'est plus amusant, mais où vous voulez vraiment apprendre quelque chose de nouveau.
Ensuite il existe plusieurs chemins en Java, pour plusieurs OS. En fonction du système d'exploitation que vous utilisez ou des environnements qui y sont installés.

Une petite préface :
Je suis moi-même encore un programmeur débutant (je peux écrire des logiciels de complexité moyenne, mais j'utilise généralement un maigre ensemble de fonctions)
L'article s'adresse également aux débutants. Je travaille moi-même sur Debian avec Gnome, il y aura donc des bibliothèques multiplateformes)

Pour commencer, il conviendrait de prêter attention à la bibliothèque GTK+

Il est disponible non seulement pour Java, mais également pour de nombreux autres langages : C++, C, etc.

L'écriture d'applications de bureau à l'aide de GTK doit être utilisée si l'application est conçue pour s'exécuter dans l'environnement GNOME.

GTK+ lui-même est considéré comme l’une des bibliothèques les plus faciles à apprendre pour Java.

Bases du travail avec la bibliothèque :

Vous devez d'abord connecter la bibliothèque elle-même avec toutes ses conséquences :

importer org.gnome.gdk.Event ;
importer org.gnome.gtk.Gtk ;
importer org.gnome.gtk.Widget ;
importer org.gnome.gtk.Window ;
importer org.gnome.gtk.WindowPosition ;

Si une erreur se produit, il est fort probable que la bibliothèque ne soit tout simplement pas installée.

Si vous utilisez un système comme Debian ou Ubuntu, alors une simple commande du terminal vous aidera :
apt-get installer libjava-gnome-java

Après cela, il ne devrait y avoir aucun problème.

la classe publique DesktopExample étend la fenêtre (
public DesktopExample() (
DéfinirTitre( "Exemple de fenêtre sur GTK et Gnome") ; // Nom de l'application
Connecter(nouvelle fenêtre .DeleteEvent() (
public boolean onDeleteEvent (source du widget, événement d'événement) (
Gtk.mainQuit();
retourner faux ;
}
} ) ;
SetDefaultSize(250, 150);
// Taille setPosition(WindowPosition.CENTER) ;
//Position au lancement, dans ce cas au centre
}

montrer() ;
Gtk.init(args);
nouveauDesktopExample() ;
}
}

Gtk.main();

On se retrouve avec une fenêtre vide.
AWT est considéré comme le système original de développement d'interfaces graphiques, il est critiqué car il
Il ne fonctionne pas toujours de manière stable sur différentes plates-formes, mais il ne semble plus y avoir de tels problèmes et il est pratique de travailler avec.
À mon humble avis, c'est mon choix.
SWT est une idée originale d'IBM, un système perfectionné et remanié, généralement caractérisé par un fonctionnement stable et facile à apprendre.
Mais SWT est plus lourd qu’AWT, a plus de fonctionnalités et est donc plus complexe qu’AWT.

Mais je ne l’utiliserais pas souvent, même s’il est très populaire et tient sa place.

Voici un exemple de fenêtre sur AWT :
// Nous connectons toutes sortes de fonctionnalités, bien que le swing soit superflu ici, j'ai ajouté ceci dans mon application
// Ceci est juste un extrait de code
importer java.awt.EventQueue ;
importer javax.swing.* ;
importer java.awt.* ;
importer java.awt.event.* ;
importer javax.swing.JFrame ;
classe publique Principale (
/**
cadre JFrame privé ;
*/
* Lancement de l'application, quelque chose comme la configuration initiale, la création d'une fenêtre et quelque chose comme ça.
public static void main (arguments de chaîne) (
EventQueue.invokeLater(new Runnable() (
public void run() (
essayer (
Fenêtre principale = new Main() ;
window.frame.setVisible(true);
) attraper (Exception e) (
}
}
} ) ;
}
/**
e.printStackTrace();
*/
* Appeler l'initialisation elle-même
public principal() (
}
/**
Initialiser() ;
*/
* Initialisation de la fenêtre
private void initialize() ( cadre = nouveau JFrame () ; "Nettoyer la fenêtre générée via Eclipse"
// Crée une nouvelle fenêtre avec le nom
frame.setBounds(100, 100, 450, 300);
frame.setSize(800, 800);
}

//Dimensions

frame.setDefaultCloseOperation (JFrame .EXIT_ON_CLOSE ) ;
Voici un exemple de fenêtre sur SWT :
//Nous connectons toutes sortes de fonctionnalités pour une vie amusante importer org.eclipse.swt.SWT ;;
importer
org.eclipse.swt.widgets.Display
importer org.eclipse.swt.widgets.Shell ;
importer org.eclipse.swt.widgets.Text ;
classe publique ExempleApp (
public static void main (arguments de chaîne) (
Shell.pack(); //Préparation (primaire)
shell.open(); //Préparer
while (! shell.isDisposed () ) ( //Lancement
if (! display.readAndDispatch()) display.sleep(); //Dors pour le moment
}
display.dispose();
}
}

En principe, ce n’est pas non plus compliqué, multiplateforme. Il comporte un grand nombre de fonctionnalités et un petit nombre de plug-ins ajoutés.

Voici un exemple de fenêtre avec battante :

importer java.awt.event.* ;
importer javax.swing.SwingUtilities ;
public class L'exemple étend JFrame (
public Exemple() (
setTitre( "Exemple d'application avec Swinga") ;
setTaille(300, 200);
setLocationRelativeTo(null) ;
setDefaultCloseOperation(EXIT_ON_CLOSE) ;
}
* Lancement de l'application, quelque chose comme la configuration initiale, la création d'une fenêtre et quelque chose comme ça.
SwingUtilities.invokeLater(nouveau Runnable()(
EventQueue.invokeLater(new Runnable() (
Exemple ex = new Exemple() ;
ex.setVisible(true);
}
} ) ;
}
}

Il s'agissait de la liste principale des environnements graphiques en Java. Presque toutes les « choses » présentées ici sont multiplateformes
et travaillez sur n'importe quel ordinateur - Win, Linux, Mac.

Tags : java, bibliothèques java, interfaces graphiques java

Qu’est-ce que le Swing ?

Java Swing est une boîte à outils d'interface utilisateur graphique (GUI) légère qui comprend un riche ensemble de widgets. Il comprend un package vous permettant de créer des composants GUI pour vos applications Java et il s'agit d'une plate-forme indépendante.

La bibliothèque Swing est construite sur la boîte à outils Java Abstract Widget ( A.W.T.), une ancienne boîte à outils GUI dépendante de la plate-forme. Vous pouvez utiliser les composants de l'interface graphique Java tels que le bouton, la zone de texte, etc. à partir de la bibliothèque et vous n'avez pas besoin de créer les composants à partir de zéro.

Dans ce tutoriel, vous apprendrez-

Diagramme hiérarchique des classes Java Swing

Tous les composants swing sont des JComponent qui peuvent être ajoutés aux classes de conteneurs.

Qu’est-ce qu’une classe conteneur ?

Les classes conteneurs sont des classes qui peuvent contenir d’autres composants. Donc, pour créer une interface graphique, nous avons besoin d'au moins un objet conteneur. Il existe 3 types de conteneurs.

Panneau: C'est un pur conteneur et n'est pas une fenêtre en soi. Le seul but d'un Panel est d'organiser les composants sur une fenêtre.
Cadre: C'est une fenêtre entièrement fonctionnelle avec son titre et ses icônes.
Dialogue: Cela peut être considéré comme une fenêtre contextuelle qui apparaît lorsqu'un message doit être affiché. Ce n'est pas une fenêtre entièrement fonctionnelle comme le Frame.

Exemple d'interface graphique Java

Exemple: Pour apprendre à concevoir une interface graphique en Java
Étape 1) Copiez le code suivant dans un éditeur

Importer javax.swing.* ; class gui( public static void main(String args)( JFrame frame = new JFrame("Ma première interface graphique"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300,300); JButton bouton = new JButton("Appuyez" ); frame.getContentPane().add(button); // Ajoute un bouton au volet de contenu frame.setVisible(true) );

Étape 2) Enregistrez, compilez et exécutez le code.
Étape 3) Ajoutons maintenant un bouton à notre cadre. Copiez le code suivant dans un éditeur.

Importer javax.swing.* ;

class gui( public static void main(String args)( JFrame frame = new JFrame("Ma première interface graphique"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300,300); JButton bouton1 = new JButton("Appuyez" ); frame.getContentPane().add(button1); frame.setVisible(true);Étape 4)

Exécutez le code. Vous obtiendrez un gros boutonÉtape 5)

Et si vous ajoutiez deux boutons ? Copiez le code suivant dans un éditeur.

Importer javax.swing.* ; class gui( public static void main(String args)( JFrame frame = new JFrame("Ma première interface graphique"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(300,300); JButton bouton1 = nouveau JButton("Bouton 1 "); JButton bouton2 = new JButton("Bouton 2"); frame.getContentPane().add(button1); frame.getContentPane().add(button2); frame.setVisible(true); ) )Étape 6)
Enregistrez, compilez et exécutez le programme.Étape 7)

Sortie inattendue = ? Les boutons se chevauchent.

Gestionnaire de mise en page Java

Le gestionnaire de mise en page est utilisé pour disposer (ou organiser) les composants Java de l'interface graphique à l'intérieur d'un conteneur. Il existe de nombreux gestionnaires de mise en page, mais les plus fréquemment utilisés sont :

Disposition des bordures Java

Un BorderLayout place les composants dans cinq zones maximum : haut, bas, gauche, droite et centre. C'est le gestionnaire de mise en page par défaut pour chaque JFrame Java

Java FlowLayout

FlowLayout est le gestionnaire de mise en page par défaut pour chaque JPanel. Il dispose simplement les composants sur une seule ligne, les uns après les autres.

Java GridBagLayout

C’est la plus sophistiquée de toutes les mises en page. Il aligne les composants en les plaçant dans une grille de cellules, ce qui permet aux composants de s'étendre sur plusieurs cellules.Étape 8)

Que diriez-vous de créer un cadre de discussion comme ci-dessous ?

//Habituellement, vous aurez besoin des packages swing et awt //même si vous travaillez uniquement avec des swings. importer javax.swing.* ; importer java.awt.* ; class gui ( public static void main(String args) ( //Création du cadre JFrame frame = new JFrame("Chat Frame"); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(400, 400); //Création le MenuBar et l'ajout de composants JMenuBar(); m11 = new JMenuItem("Open"); // le panneau n'est pas visible dans la sortie JLabel label = new JLabel("Enter Text"); ); // accepte jusqu'à 10 caractères JButton send = new JButton("Send") ; JButton reset = new JButton("Reset"); // Composants ajoutés à l'aide de Flow Layout panel.add(label); add(reset); // Zone de texte au centre JTextArea ta = new JTextArea();

//Ajout de composants au cadre.

frame.getContentPane().add(BorderLayout.SOUTH, panneau);

frame.getContentPane().add(BorderLayout.NORTH, mb);

frame.getContentPane().add(BorderLayout.CENTER, ta);

frame.setVisible(true);

) )

Contribution de Saleem Gul et Tomas Pavek

Choisissez Fichier > Nouveau projet. Vous pouvez également cliquer sur l'icône Nouveau projet dans la barre d'outils de l'EDI.
Dans la zone Catégories, sélectionnez le nœud Java. Dans la zone « Projets », sélectionnez « Application Java ». Cliquez sur le bouton "Suivant".
Entrez NumberAddition dans le champ Nom du projet et spécifiez un chemin, tel que votre répertoire personnel, comme emplacement du projet.
Cochez la case "Utiliser un dossier séparé pour stocker les bibliothèques" et précisez l'emplacement du dossier des bibliothèques (facultatif). Pour plus d'informations, consultez Partager une bibliothèque avec d'autres personnes dans un document. Développement d'applications avec l'EDI NetBeans.
Supprimez la case "Créer une classe principale" si elle est cochée.
Cliquez sur le bouton "Terminé".

Exercice 2 : Création du frontal

Pour continuer le processus de création d'interface, vous devez créer un conteneur Java dans lequel les autres éléments GUI requis seront placés. Dans cette activité, un conteneur sera créé à l'aide d'un élément JFrame. Le conteneur sera placé dans un nouveau package, qui apparaîtra dans le nœud « Packages sources ».

Création d'un conteneur JFrame

Dans la fenêtre Projets, cliquez avec le bouton droit sur le nœud NumberAddition et sélectionnez Nouveau > Autre.
Dans la boîte de dialogue Créer un fichier, sélectionnez la catégorie Swing GUI Forms et le type de fichier JFrame Form. Cliquez sur le bouton "Suivant".
Entrez NumberAdditionUI comme nom de classe.
Sélectionnez le package my.numberaddition.
Cliquez sur le bouton "Terminé".

L'EDI crée le formulaire NumberAdditionUI et la classe NumberAdditionUI dans l'application NumberAddition et ouvre le formulaire NumberAdditionUI dans GUI Builder. Le package my.NumberAddition remplace le package par défaut.

Ajout d'éléments : création d'un frontal

Ensuite, à l'aide de la fenêtre "Palette", l'interface externe de l'application est remplie avec le JPanel. Après cela, trois éléments JLabel (étiquettes de texte), trois éléments JTextField (champs de texte) et trois éléments JButton (boutons) sont ajoutés. Si vous n'avez jamais travaillé avec le concepteur d'interface graphique, consultez Conception d'une interface graphique Swing dans l'EDI NetBeans pour plus d'informations sur le placement des composants.

Après avoir glissé et placé les éléments ci-dessus, l'élément JFrame devrait ressembler à l'image ci-dessous.

S'il n'y a pas de fenêtre Palette dans le coin supérieur droit de l'EDI, choisissez Fenêtre > Palette.

Pour commencer, sélectionnez un panneau dans la catégorie Swing Containers dans la palette et faites-le glisser sur le JFrame.
Le JPanel sera mis en surbrillance. Accédez à la fenêtre Propriétés et cliquez sur le bouton points de suspension (...) à côté du champ Bordure pour sélectionner un style de bordure.
Dans la boîte de dialogue Bordure, sélectionnez TitledBorder dans la liste et saisissez Ajout de numéros dans le champ Titre. Cliquez sur "OK" pour enregistrer vos modifications et fermer la boîte de dialogue.
L'écran devrait maintenant afficher un élément "JFrame" vide avec le titre "Ajout de numéro", comme indiqué dans l'image. Conformément à l'image, ajoutez-y trois JLabels, trois JTextFields et trois JButtons.

Renommer des éléments

Cette étape renommera les éléments qui ont été ajoutés à l'élément JFrame.

Double-cliquez sur jLabel1 et remplacez ntrcn (propriété "text") par First Number.
Double-cliquez sur jLabel2 et remplacez le texte par Second Number.
Double-cliquez sur jLabel3 et modifiez le texte en Résultat.
Supprimez le texte par défaut de jTextField1. Le texte affiché peut être converti en texte modifiable. Pour ce faire, cliquez avec le bouton droit sur le champ de texte et sélectionnez « Modifier le texte » dans le menu contextuel. Cela peut vous obliger à restaurer jTextField1 à sa taille d'origine. Répétez cette étape pour les champs jTextField2 et jTextField3.
Remplacez le texte affiché de jButton1 par Clear . (Pour modifier le texte d'un bouton, cliquez avec le bouton droit sur le bouton et sélectionnez Modifier le texte. Vous pouvez également cliquer sur le bouton, faire une pause et cliquer à nouveau.)
Remplacez le texte affiché de jButton2 par Add .
Modifiez le texte affiché de jButton3 en Exit .

Maintenant, l'interface graphique terminée devrait ressembler à l'image ci-dessous :

Exercice 3 : Ajout de fonctionnalités

Cet exercice ajoutera les fonctionnalités requises aux boutons Ajouter, Effacer et Quitter. Les champs jTextField1 et jTextField2 seront utilisés pour la saisie utilisateur, et jTextField3 sera utilisé pour afficher le résultat du programme. Le programme créé est une simple calculatrice. Alors commençons !

Ajout de fonctionnalités au bouton Quitter

Pour que les boutons deviennent fonctionnels, chacun d'eux doit se voir attribuer un gestionnaire d'événements, qui sera chargé de répondre aux événements. Dans notre cas, nous devons identifier l'événement de clic sur le bouton - soit en cliquant sur la souris, soit en utilisant le clavier. Par conséquent, l'interface "ActionListener" sera utilisée pour gérer les événements "ActionEvent".

Faites un clic droit sur le bouton "Quitter". Dans le menu contextuel, sélectionnez Événements > Action > actionPerformed. Veuillez noter que le menu contient de nombreux autres événements auxquels le programme peut répondre ! Lorsque vous sélectionnez l'événement actionPerformed, l'EDI ajoute automatiquement un ActionListener au bouton Quitter et crée une méthode de gestionnaire pour gérer la méthode d'écoute actionPerformed.
L'EDI ouvre automatiquement la fenêtre "Code source", vous indiquant où insérer l'action que vous souhaitez que le bouton effectue lorsque vous cliquez dessus (avec votre souris ou votre clavier). La fenêtre "Code source" doit contenir les lignes suivantes : private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO ajoutez votre code de gestion ici : )
Ajoutons maintenant le code de l'action que le bouton "Quitter" doit effectuer. Remplacez la ligne TODO par System.exit(0); . Le code terminé pour le bouton "Quitter" devrait ressembler à ceci : private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

Ajout de fonctionnalités au bouton "Effacer"

Cliquez avec le bouton droit sur le bouton "Effacer" (jButton1). Dans le menu qui apparaît, sélectionnez « Événements > Action > actionPerformed ».
En cliquant sur le bouton "Effacer", tout le texte devrait être supprimé de tous les champs de texte "jTextField". Pour ce faire, ajoutez un code similaire à celui ci-dessus. Le code source terminé devrait ressembler à ceci : private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

Ce code supprime le texte des trois JTextFields, les laissant vides.

Ajout de fonctionnalités au bouton "Ajouter"

Le bouton "Ajouter" devrait faire trois choses.

Il prend d'abord la saisie de l'utilisateur dans les champs jTextField1 et jTextField2 et les convertit d'un type "String" en un type "Float".
Il effectuera alors l'addition des deux nombres.
Enfin, il convertira la somme en String et la placera dans jTextField3 .

Commençons !

Cliquez sur l'onglet Conception en haut de l'espace de travail pour revenir à l'écran Conception de formulaire.
Cliquez avec le bouton droit sur le bouton "Ajouter" (jButton2). Dans le menu contextuel, sélectionnez Événements > Action > actionPerformed.
Ajoutez du code pour les actions que le bouton "Ajouter" doit effectuer. Le code source terminé devrait ressembler à ceci : private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Nous définissons d'abord les variables float. float num1, num2, result; // Nous devons analyser le texte en un type float . num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Nous pouvons maintenant effectuer l'addition = num1+num2; , nous allons // changer la valeur du résultat d'un float en une chaîne jTextField3.setText(String.valueOf(result));

Le programme est maintenant complètement prêt et vous pouvez commencer à l'assembler et à l'exécuter.

Exercice 4 : Exécuter le programme

Pour exécuter le programme dans l'EDI, procédez comme suit :

Sélectionnez Exécuter > Exécuter le projet principal (vous pouvez également appuyer sur F6).
Note. Si vous ouvrez une fenêtre indiquant que Project NumberAddition n’a pas de classe principale spécifiée, vous devez sélectionner my.NumberAddition.NumberAdditionUI comme classe principale dans la même fenêtre et cliquer sur OK.

Pour exécuter le programme en dehors de l'EDI, procédez comme suit :

Après quelques secondes, l'application se lancera.

Note. Si un double-clic sur un fichier JAR ne lance pas l'application, consultez les associations de fichiers JAR sur votre système d'exploitation pour plus d'informations.

Vous pouvez également exécuter l'application à partir de la ligne de commande.

Pour exécuter l'application à partir de la ligne de commande, procédez comme suit :

Ouvrez une invite de commande ou une fenêtre de terminal.
À l'invite de commande, remplacez le répertoire actuel par le répertoire NumberAddition/dist.
À l'invite de commande, entrez l'instruction suivante : java -jar NumberAddition.jar
Note. Assurez-vous que my.NumberAddition.NumberAdditionUI est défini comme classe principale avant d'exécuter l'application. Pour vérifier cela, cliquez avec le bouton droit sur le nœud du projet NumberAddition dans le panneau Projets, choisissez Propriétés dans le menu contextuel et sélectionnez la catégorie Exécuter dans la boîte de dialogue Propriétés du projet. Le champ Classe principale doit afficher my.numberaddition.NumberAdditionUI .

Moteur de traitement des événements

Ce didacticiel visait à répondre à un simple événement de clic sur un bouton. Il existe de nombreux événements auxquels une application peut répondre. Dans l'EDI, vous pouvez afficher la liste des événements disponibles qui peuvent être traités par les éléments de l'interface graphique comme suit :

Revenez au fichier NumberAdditionUI.java dans l'éditeur. Cliquez sur l'onglet "Conception" pour afficher la structure de l'interface graphique dans GUI Builder.
Cliquez avec le bouton droit sur n'importe quel élément de l'interface graphique et sélectionnez "Événements" dans le menu qui apparaît. Vous pouvez désormais simplement explorer le contenu du menu sans sélectionner aucun élément.
Alternativement, vous pouvez sélectionner « Propriétés » dans le menu « Fenêtre ». Dans la fenêtre Propriétés, cliquez sur l'onglet Événements. L'onglet "Événements" vous permet d'afficher et de modifier les gestionnaires d'événements associés à l'élément GUI actuellement actif.
L'application peut également répondre aux pressions sur des touches, aux clics simples, doubles ou triples, aux mouvements du pointeur de la souris, au redimensionnement de la fenêtre et aux mouvements de focus d'entrée. Le menu "Événements" permet de créer automatiquement des gestionnaires d'événements pour tous ces événements. Le plus courant d'entre eux est l'événement « Action ». (Pour plus d'informations, découvrez comment gérer les événements dans le didacticiel Sun Java Events.)

Comment sont traités les événements ? Chaque fois que vous sélectionnez un événement dans le menu des événements, l'IDE crée automatiquement ce qu'on appelle un écouteur d'événement et l'associe au composant développeur. Pour en savoir plus sur le traitement des événements, procédez comme suit :

Revenez au fichier NumberAdditionUI.java dans l’éditeur. Cliquez sur l'onglet "Source" pour afficher le code source de l'interface graphique.
Faites défiler vers le bas pour voir les méthodes jButton1ActionPerformed() , jButton2ActionPerformed() et jButton3ActionPerformed() implémentées. Ces méthodes sont appelées gestionnaires d'événements.
Accédez maintenant à la méthode initComponents(). Si cette méthode est manquante, recherchez la ligne Code généré et cliquez sur le signe + à côté de cette ligne pour afficher la méthode initComponents() cachée.
Notez le bloc bleu entourant la méthode initComponents(). Ce code a été généré automatiquement par l'IDE et ne peut pas être modifié par l'utilisateur.
Regardez maintenant la méthode initComponents() elle-même. Entre autres choses, il contient du code qui initialise les éléments de l'interface graphique et les place sur le formulaire. Ce code est généré et mis à jour automatiquement lorsque vous placez et modifiez des éléments en mode conception.
Dans la méthode initComponents(), recherchez l'extrait suivant : jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));
À ce stade, un objet écouteur d'événement "ActionListener" est ajouté à l'élément GUI, dans ce cas jButton3 . L'interface "ActionListener" possède une méthode "actionPerformed" sur l'objet "ActionEvent", qui est implémentée en appelant simplement le gestionnaire d'événements jButton3ActionPerformed. Ce bouton répond désormais aux événements d'action. Chaque fois que vous cliquez sur le bouton, un "ActionEvent" est généré et transmis à la méthode "actionPerformed" de l'interface d'écoute d'événement, qui exécute le code fourni par le développeur pour cet événement dans le gestionnaire d'événements.
Carte d'apprentissage des applications GUI Java