Discutez en sur les forums

Approche
Notre programme est simple : il ne fait qu'afficher des éléments graphiques, accepter le clic d'un bouton et se fermer en conséquence. L'ensemble de notre code tient dans un fichier, FenetreSimpleExec.java .
Les package importés sont donc peu nombreux : java.awt.* et javax.swing.* pour la gestion graphique, et java.awt.event.* pour les évènements. Pour les lecteurs qui ne savent pas à quoi correspond un package, sachez qu'il s'agit d'un ensemble de classes fournissant des fonctions élaborées. AWT est la package de gestion d'interface historique, Swing est son successeur, mais AWT est encore utile en bien des domaines...

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

Notre classe principale, celle avec laquelle nous lancerons l'affichage de notre interface, s'appelle FenetreSimpleExec, et sert de lanceur à la classe FenetreSimple...

public class FenetreSimpleExec
  {
  public static void main(String[] args)
    {
    FenetreSimple fenetre = new FenetreSimple();
    fenetre.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    fenetre.show();
    }
  }

Ici, après avoir défini l'objet fenetre, nous lui définissons un comportement de fermeture par défaut, et l'affichons avec show().

class FenetreSimple extends JFrame
  {
  public FenetreSimple()
    {
    Toolkit k = Toolkit.getDefaultToolkit();
    Dimension tailleEcran = k.getScreenSize();
    int largeurEcran = tailleEcran.width;
    int hauteurEcran = tailleEcran.height;

    setTitle("Un programme Java");
    setSize(largeurEcran/4, hauteurEcran/4);
    setLocation(largeurEcran*3/8, hauteurEcran*3/8);

    Contenu monContenu = new Contenu(this);
    Container leContenant = getContentPane();
    leContenant.add(monContenu);
    }
  }

C'est ici que nous construisons physiquement notre fenêtre. Notre classe est ici une extension de JFrame, une classe Swing permettant de construire, donc des fenêtres de haut niveau (le bas niveau correspondant au contenu même), ayant une bordure et un titre.
Ce titre est facilement définit : setTitle() permet de lui donner n'importe quelle chaîne.
Il faut ensuite lui donner une taille, et la place au centre de l'écran. Nous avons choisi de partir de la taille de l'écran pour ces deux informations, que nous pouvons obtenir au moyen de Toolkit. Celui-ci nous donne la taille de l'écran dans un objet de type Dimension, qui contient la largeur et la hauteur.
Nous décidons de donner à notre fenêtre une taille égale au quart de la taille de l'écran. Pour la centrer, nous calculons qu'il nous faut placer les points de départ du dessin de la fenêtre, en haut à gauche, au 3/8 des dimensions de l'écran.
Ceci fait, il nous reste à remplir notre fenêtre : cela sera fait au moyen de la classe Contenu., à laquelle nous envoyons la référence à notre fenêtre (à l'aide de this) pour pouvoir l'utiliser depuis cette autre classe.

class Contenu extends JPanel
  {
  private FenetreSimple maFenetre = null;
  public Contenu(FenetreSimple maFenetre)
    {
    setLayout(new BorderLayout());

    JButton boutonFermer = new JButton("Fermer");
    add(boutonFermer, BorderLayout.SOUTH);

    MyListener myListener = new MyListener();
    this.maFenetre = maFenetre;
    boutonFermer.addActionListener(myListener);
    }

  public void paintComponent(Graphics g)
    {
    super.paintComponent(g);
    g.drawString("Mon Texte", 25, 25);
    }

  class MyListener implements ActionListener
    {
    public void actionPerformed(ActionEvent event)
      {
      maFenetre.dispose();
      }
    }
  }

La classe Contenu est donc une extension de JPanel, encore une classe Swing, cette fois permettant le construction de "panneau" (le contenu même). Le constructeur de cette classe, comme prévu, reçoit en argument un objet de type FenetreSimple. Nous y créons un bouton, appelé boutonFermer et avec un texte idoine, et l'ajoutons à l'interface, en le plaçant au "sud" de notre interface, par l'entremise du gestionnaire BorderLayout, qui se charge plus particulièrement de la mise en forme de notre interface.
Notre petit texte est ensuite placé, via les méthodes paintComponent() et drawString().

Il nous faut ensuite gérer les évènements. Pour cela, nous ferons appel à l'interface ActionListener pour créer un "écouteur d'évènement". Celle-ci comprend ici une simple méthode, actionPerformed, qui appelle la méthode dispose() de notre objet maFenetre, transmis depuis FenetreSimple. Cet écouteur est ensuite attaché au bouton boutonFermer à l'aide de la méthode addActionListener...

Ceci fait, notre projet est prêt à être compilé et lancé.