Construction pas à pas d'une application graphique en Java

Etape N°1 : Le programme principal

Fichier " Main.java " :

    class Main { 
        private static Application application; 
    
        public static void main(String[] args) { 
            application = new Application(); 
        } 
    } 

         java Main

Etape N°2 : La classe Application

• JFrame : le composant fenêtre qui contiendra tous les autres objets graphiques
• JLabel : le composant zone d'affichage
• JTextField : le composant champ de saisie
• JButton : le composant bouton

    import javax.swing.*; 
    
    class Application { 
        private JFrame fenetre; 
        private JLabel affichage; 
        private JTextField champA; 
        private JTextField champB; 
        private JButton boutonPlus; 
        private JButton boutonQuitter; 
    
        public Application() { 
            ... 
        } 
    } 

Les objets graphiques sont créés dans le constructeur de la classe. Cela se fait comme suit :

    this.fenetre = new JFrame("Une application graphique"); 
    
    // Le constructeur de JFrame prend en argument le nom de 
    // la fenêtre 
    this.affichage = new JLabel(); 
    this.champA = new JTextField(20); 
    this.champB = new JTextField(20); 
    
    // Le constructeur de JTextField prend en argument la taille 
    // en caractères du champ de saisie 
    this.boutonPlus = new JButton("+"); 
    
    // Le constructeur de JButton prend en argument le nom du bouton 
    this.boutonQuitter = new JButton("Quitter"); 

Cela n'est cependant pas suffisant. En effet il ne suffit pas de dire quels sont les objets qui seront affichés dans la fenêtre, encore faut il dire comment ces objets seront disposés dans cette fenêtre (en colonnes, les uns à la suite des autres, en cercle, ...). La disposition de composants graphiques dans un objet de type Container est effectuée par des objets particuliers, qu'on appelle des gestionnaires de disposition ("layout managers"). Il faut associer un gestionnaire de disposition au conteneur de la fenêtre par l'intermédiaire de la méthode setLayout de la classe Container. Nous n'avons heureusement pas à écrire les gestionnaires de disposition (même si cela est possible)  car la bibliothèque standard Java fournit déjà un certain nombre de classes de gestionnaires de disposition qui correspondent aux situations les plus courantes. Nous utiliserons essentiellement deux types de gestionnaires de disposition :

• Le gestionnaire de type FlowLayout organise les objets graphiques dans la fenêtre de gauche à droite et de haut en bas suivant leur ordre d'insertion dans le conteneur à l'aide de la méthode add.
• Les gestionnaire de type GridLayout organise les objets graphiques dans la fenêtre suivant un quadrillage en lignes et colonnes dont les dimensions sont spécifiées par l'utilisateur au moment de la création du gestionnaire. Les objets sont insérés séquentiellement à partir de la case en haut à gauche de la fenêtre, de gauche à droite et de haut en bas, suivant l'ordre des appels à la méthode add.

    Container conteneur = fenetre.getContentPane(); 
    FlowLayout disposition = new FlowLayout(); 

    conteneur.setLayout(disposition); 
    conteneur.add(this.affichage); 
    conteneur.add(this.champA); 
    conteneur.add(this.champB); 
    conteneur.add(this.boutonPlus); 
    conteneur.add(this.boutonQuitter); 

    import java.awt.*; 

au début du fichier " Application.java " afin de pouvoir utiliser la classe Container sans la préfixer par le nom de son paquetage.

Si nous avions voulu organiser les éléments suivant un quadrillage de trois lignes et deux colonnes, nous aurions écrit :

    GridLayout disposition = new GridLayout(3, 2); 

les autres commandes restant inchangées.

Une fois les objets graphiques disposés à l'intérieur de la fenêtre, il reste deux dernières choses à faire :

• Ajuster la taille de la fenêtre de façon à ce qu'elle puisse afficher tous les objets qu'elle contient. Cela s'effectue à l'aide de la méthode pack de la classe JFrame.
• Rendre cette fenêtre visible car par défaut une fenêtre est invisible et elle peut être rendue arbitrairement visible ou invisible à l'aide de la méthode setVisible de la classe JFrame qui prend un booléen en argument.

    this.fenetre.pack(); 
    this.fenetre.setVisible(true); 

Ce qui termine l'écriture du constructeur de la classe Application.

NOTE : dès lors que l'on a un programme Java composé de plusieurs fichiers il vaut mieux utiliser la commande suivante :

    javac *.java

pour compiler tous les fichiers constituant le programme.

Etape N°3 : Association d'actions aux clics sur les boutons

    public void actionPerformed(ActionEvent contexte); 

L'environnement d'exécution Java scrute constamment les événements souris et clavier et lorsqu'il détecte un clic sur un bouton il invoque la méthode actionPerformed de tous les gestionnaires d'action qui ont été attachés au bouton. L'argument passé à cette méthode contient des informations sur le contexte dans lequel l'action a eu lieu (si par exemple une touche du clavier était enfoncée au moment du clic) qui peuvent être utilisées par le programme. En pratique nous n'en aurons pas besoin et nous n'utiliserons donc jamais cet argument.

Un gestionnaire d'action est une classe qui implémente l'interface ActionListener et qui gère le comportement d'un bouton. Etant donné que nous avons deux boutons nous devons définir deux classes GestionQuitter et GestionPlus implémentant cette interface dans deux fichiers " GestionQuitter.java " et " GestionPlus.java ".

Le gestionnaire d'action le plus simple à définir est celui qui correspond au bouton "quitter". Terminer l'exécution d'un programme se fait en appelant la fonction statique exit de la classe System du paquetage java.lang (importé par défaut par tout programme Java). Cette fonction est en tout point similaire à la fonction exit de C (un code de retour de 0 signifie une sortie normale du programme).

Le fichier " GestionQuitter.java " contient donc :

    import java.awt.event.*; 
    
    class GestionQuitter implements ActionListener { 
        public void actionPerformed(ActionEvent contexte) { 
            System.exit(0); 
        } 
    } 

Nous devons également affecter un gestionnaire d'action de cette classe au bouton "quitter" de la classe Application. Nous devons donc rajouter dans le constructeur, juste après la construction des objets graphiques, les lignes suivantes :

    GestionQuitter gestionQuitter = new GestionQuitter(); 

    this.boutonQuitter.addActionListener(gestionQuitter); 

Après recompilation de tous les fichiers et lancement du programme on s'aperçoit que le bouton "quitter" est bien actif.

Le gestionnaire d'action du bouton "+" pose problème car il doit interagir avec les autres composants graphiques de l'application : il doit récupérer le contenu des champs de saisie et modifier la zone d'affichage. Un moyen de résoudre ce problème est de créer dans la classe GestionPlus un champ application qui contient un pointeur sur l'objet Application qui utilise ce gestionnaire d'action. Ainsi le bouton peut avoir accès aux informations contenues dans les composants graphiques de l'application. Comme ceux-ci sont privés il y a deux solutions possibles :

• Les rendre publics et y accéder directement
• Ajouter à la classe Application des méthodes publiques qui interagissent avec ces objets

Les méthodes getText et setText définies dans les classes JLabel et JTextField permettent de lire et modifier le contenu de ces objets textuels. Nous ajoutons donc les méthodes suivantes à la classe Application :

    public String contenuChampA() { 
        return this.champA.getText(); 
    } 

    public String contenuChampB() { 
        return this.champB.getText(); 
    } 

    public void afficher(String texte) { 
        this.affichage.setText(texte); 
    } 

La classe GestionPlus s'écrit alors :

    import java.awt.event.*; 

    class GestionPlus implements ActionListener { 
        private Application application; 
    
        public GestionPlus(Application appli) { 
            this.application = appli; 
        } 
    
        public void actionPerformed(ActionEvent e) { 
            this.application.afficher(
                    this.application.contenuChampA()
                 +  this.application.contenuChampB()
            ); 
        } 
    } 

Le constructeur permet à l'application d'envoyer un pointeur sur elle-même au gestionnaire d'action du bouton. On ajoute donc au constructeur de la classe Application, juste après la construction des objets graphiques, les lignes suivantes :

    GestionPlus gestionPlus = new GestionPlus(this); 

    this.boutonPlus.addActionListener(gestionPlus); 

Nous obtenons ainsi une application entièrement opérationnelle. Les sources complets de l'application se trouvent dans l'archive Exemple1.tar.gz "Exemple1" au même niveau que ce document HTML.
 

Extension : amélioration de la disposition des composants graphiques

• La zone d'affichage sur une ligne
• Les deux zones de saisie sur les deux lignes suivantes
• Les deux boutons côte-à-côte sur la dernière ligne

    Container conteneur = fenetre.getContentPane(); 
    GridLayout disposition = new GridLayout(4, 1); 
    JPanel boutons = new JPanel(); 
    FlowLayout dispositionBoutons = new FlowLayout(); 

    boutons.setLayout(dispositionBoutons); 
    boutons.add(this.boutonPlus); 
    boutons.add(this.boutonQuitter); 

    conteneur.setLayout(disposition); 
    conteneur.add(this.affichage); 
    conteneur.add(this.champA); 
    conteneur.add(this.champB); 
    conteneur.add(boutons); 

Les sources de l'application ainsi modifiée sont disponible dans l'archive Exemple2.tar.gz