LECON 301

Votre première fenêtre

Dans ce chapitre, nous allons apprendre à nous servir de l'objet JFrame, présent dans le package Swing.

À la fin du chapitre, vous serez à même de créer une fenêtre, de choisir sa taille...
Trêve de bavardage inutile, commençons tout de suite !

Sommaire du chapitre :

L'objet JFrame
Votre fenêtre héritée
Des méthodes et encore des méthodes
Ce que vous cache votre fenêtre
Ce qu'il faut retenir

L'objet JFrame

Nous y voilà... Avant de nous lancer à corps perdu, vous devez savoir ce que nous allons utiliser...
Vu que nous allons développer des interfaces avec swing, vous devez savoir que toutes les classes swing se trouvent dans le package javax.swing. Mais ne vous y trompez pas, nous allons utiliser aussi des objets awt (java.awt), mais pas de composants !
Pour faire simple, un composant peut être un bouton, une zône de texte, une case à cocher... Bref, tout ce qui peut interagir avec vous !

Il est très fortement recommandé de ne pas mélanger les composants swing et awt ! ! Ceci pour cause de conflit ! Si vous faites ceci vous aurez de très grandes difficultés à faire une IHM stable et valide ! En effet, pour faire simple, swing et awt se basent sur les mêmes fondements mais diffèrent sur l'utilisation de ces fondements...

Pourquoi ?
Tout simplement car les objets de ces deux packages ne sont pas construits de la même façon et que des conflits peuvent survenir (superposition de composants...).

Je ne vous demande pas de créer un projet avec une classe main, celui-ci doit être prêt depuis des lustres, facile !

Pour utiliser une fenêtre de type JFrame, vous devez instancier celui-ci. Comme ceci :

Code : Java -

import javax.swing.JFrame;

public class Test {

        public static void main(String[] args){

                JFrame fenetre = new JFrame();

Eh ! Lorsque j'exécute mon code, rien ne s'affiche !

Oui, parce que par défaut, votre JFrame n'est pas visible...
Pour pouvoir l'afficher à l'écran, vous devez lui dire "sois visible", comme ça :

Code : Java -

import javax.swing.JFrame;

public class Test {

        public static void main(String[] args){

                JFrame fenetre = new JFrame();

                fenetre.setVisible(true);

Et lorsque vous exécuterez votre code, vous pourrez voir ceci :

Eh, mais tu te moques de nous ! Elle est minuscule !

Bienvenue dans le monde de la programmation événementielle ! Il faut que vous vous y fassiez... Vos composants ne sont pas intelligents : il va falloir leur dire tout ce qu'ils doivent faire !

Bon, pour avoir une fenêtre plus conséquente, il faudrait :

qu'elle soit plus grande ; en effet, c'est mieux ;
qu'elle ait un titre (c'est pas du luxe !) ;
si elle pouvait être centrée au milieu de mon écran, ce serait parfait !

Par contre, vous ne l'avez peut-être pas remarqué mais, lorsque vous cliquez sur la croix rouge (pour fermer votre fenêtre), cette action ne termine pas le processus dans Eclipse !

Pour réellement terminer le processus de l'application, vous devrez ajouter une autre instruction.

Pour chacune des choses que je viens d'énumérer, il y a aura une méthode à appeler pour que votre JFrame sache à quoi s'en tenir !
Voici un code qui reprend toutes nos doléances :

Code : Java -

import javax.swing.JFrame;

public class Test {

        public static void main(String[] args){

                JFrame fenetre = new JFrame();

                //Définit un titre pour votre fenêtre

                fenetre.setTitle("Ma première fenêtre java");

                //Définit une taille pour celle-ci ; ici, 400 px de large et 500 px de haut

                fenetre.setSize(400, 500);

                //Nous allons maintenant dire à notre objet de se positionner au centre

                fenetre.setLocationRelativeTo(null);

                //Terminer le processus lorsqu'on clique sur "Fermer"

                fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

                fenetre.setVisible(true);

Et voici le résultat :

Par contre, je pense qu'il vaudrait mieux que nous ayons notre propre objet. Comme ça, on n'aura pas à redéfinir les attributs à chaque fois... Donc créons notre propre classe !

Votre fenêtre héritée

Pour commencer, effacez tout le code que vous avez écrit dans votre méthode main. Ensuite, créez une classe que nous appellerons "Fenetre", et faites-la hériter de JFrame.
Voilà le code de cette classe pour le moment :

Code : Java -

import javax.swing.JFrame;

public class Fenetre extends JFrame{

Nous allons maintenant créer notre constructeur et, dans celui-ci, nous mettrons nos instructions à l'intérieur.
Ce qui nous donne :

Code : Java -

import javax.swing.JFrame;

public class Fenetre extends JFrame{

     public Fenetre(){

         //Définit un titre pour votre fenêtre

         this.setTitle("Ma première fenêtre java");

         //Définit une taille pour celle-ci ; ici, 400 px de large et 500 px de haut

         this.setSize(400, 500);

         //Nous allons maintenant dire à notre objet de se positionner au centre

         this.setLocationRelativeTo(null);

         //Ferme-toi lorsqu'on clique sur "Fermer" !

         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

         this.setVisible(true);

Ensuite, vous avez le choix, soit :

vous conservez votre classe contenant la méthode main et vous créez une instance de Fenetre
vous effacez cette classe, et vous mettez votre méthode main dans votre classe Fenetre. Vous devez tout de même créer une instance de votre Fenetre...

Personnellement, je préfère sortir ma méthode main dans une classe à part... Mais je ne vous force à rien !
Quelque soit l'emplacement de votre main, la ligne de code qui suit doit y figurer :

Code : Java -

1	Fenetre fen = new Fenetre();

Exécutez votre nouveau code et... vous avez exactement la même chose que précédemment !
Vous conviendrez que c'est tout de même plus pratique de ne plus écrire les même choses à chaque fois... Comme ça, vous avez une classe qui va se charger de l'affichage de votre programme futur !
Faisons un léger tour d'horizon de cette classe.

Des méthodes et encore des méthodes

Je vais vous faire une petite liste des méthodes que vous serez susceptibles d'utiliser.

Positionner sa fenêtre à l'écran

Déjà, nous avons centré notre fenêtre, mais vous auriez peut-être voulu la positionner ailleurs. Pour faire ceci, vous avez la méthode setLocation(int x, int y).
Avec cette méthode, vous pouvez spécifier où doit se situer votre fenêtre sur votre écran. Les coordonnées, exprimées en pixels, sont basées sur un repère prenant le coin supérieur gauche comme origine.

La première valeur de la méthode vous positionne sur l'axe X, 0 correspondant à l'origine ; les valeurs positives déplacent la fenêtre vers la droite, et les valeurs négatives vous font sortir de l'écran vers la gauche. La même règle s'applique pour les valeurs Y, excepté que les valeurs positives font descendre la fenêtre en commençant par l'origine, et les valeurs négatives font sortir la fenêtre par le haut !

Empêcher le redimensionnement de la fenêtre

Pour faire ceci, il vous suffit d'invoquer la méthode setResizable(false);, et de le repasser à setResizable(true) pour le rendre actif !

Faire que votre fenêtre soit toujours au premier plan

Il s'agit là encore d'une méthode qui prend un booléen en paramètre. Passer true mettra votre fenêtre au premier plan quoi qu'il advienne, et passer false annulera le statut. Cette méthode est setAlwaysOnTop(boolean b).

Retirer les contours et les boutons de contrôles

Pour ce faire, il vous suffit d'utiliser la méthode setUndecorated(Boolean b).

Je ne vais pas faire le tour de toutes les méthodes maintenant... De toute façon, nous allons nous servir de pas mal d'autres dans un futur très proche...

C'est bien joli tout ça, mais on aimerait bien pouvoir mettre des trucs dans notre fenêtre !

Bien sûr : mais avant, il vous faut encore apprendre une bricole... En fait votre fenêtre, telle qu'elle apparaît, vous cache quelques petites choses...

Ce que vous cache votre fenêtre

Vous pensez, et c'est légitime, que votre fenêtre est toute simple, dépourvue de tout composant (hormis les contours).
Eh bien vous vous trompez !
Une JFrame est découpée en plusieurs parties :

la fenêtre,
le RootPane, le container (conteneur) principal qui contient les autres composants,
le LayeredPane, qui forme juste un panneau composé du ContentPane et de la barre de menu (MenuBar),
la MenuBar, la barre de menu quand il y en a une...
le ContentPane ; c'est dans celui-ci que nous mettrons nos composants,
et le GlassPane, couche utilisée pour intercepter les actions de l'utilisateur avant qu'elles ne parviennent aux composants.

Pas de panique... Nous n'allons nous servir que du contentPane et, pour le récupérer, nous n'avons qu'à utiliser la méthode getContentPane() de la classe JFrame.

Cependant, nous allons utiliser un composant autre que le contentPane. Nous utiliserons un JPanel.

Il existe d'autres types de fenêtres. La JWindow, une JFrame sans bord et non draggable (déplaçable), et la JDialog, une fenêtre non redimensionnable. Mais nous n'en parlerons pas ici...

Ce qu'il faut retenir

Les composants swing se trouvent dans javax.swing, et les awt dans java.awt.
Il ne faut pas mélanger les composants swing et awt ! !
Une JFrame est constituée de plusieurs composants.
Par défaut, une fenêtre a une taille minimale, et n'est pas visible.
Un composant doit être bien paramétré pour qu'il fonctionne à notre convenance.

J'ose espérer que ce premier chapitre était à votre goût...
Il n'était pas trop difficile pour commencer. Mais les choses vont vite se compliquer...

Continuons avec les conteneurs.

// // 0 comments //

java du zéro