1. Tutoriel Java-Swing numéro 1
Graphismes en Java
Pré-requis : classe dérivée ; méthode main
Rechercher dans la documentation de Sun:
->Classes de composants graphiques conteneurs : JApplet,JFrame,JPanel
->La classe Graphics pour le dessin et la classe Color
->Pour les composants graphiques élémentaires :
JButton,JEdit,JLabel,JTextArea,JComboBox, JMenu,JMenuItem
1)Fenêtrage,la classe JFrame
Pour afficher une fenêtre, on peut employer la classe JFrame et redéfinir sa méthode
paint(Graphics g) :
Class Fenetre extends JFrame
{public void paint(Graphics g)
{g.drawString(20,20, « Bonjour ! ») ; //Ecrit un message
g.setColor(new Color(234,234,134)) ; //Couleur de remplissage :rouge,vert,bleu
g.fillRect(35,35,64,64) ; //dessine un rectangle plein
}
}
Dans votre main, écrivez :
JFrame jf=new Fenetre() ;
Jf.setSize(200,200) ;
Jf.setVisible(true) ; //Ne pas oublier ces deux instructions sinon rien ne s’affiche !
Les classes les plus usitées employant la méthode paint sont JFrame et JApplet ;
Toutefois, en général, on ne se contente pas de dessiner dans une fenêtre, la fenêtre doit
souvent contenir d’autres composants graphiques tels des panneaux , des boutons ;
2)Composants contenus dans d’autres
Intéressons-nous aux panneaux qui sont des conteneurs de composants. Les contenus peuvent
être élémentaires(JButton,etc) ou bien ils peuvent être eux-mêmes d’autres panneaux.
Un panneau désigne la classe JPanel et toute dérivation ; un JPanel est en principe intégré à
un conteneur ‘Fenêtre’ tel qu’un JFrame ou bien un autre panneau .
Trois cas d’utilisation peuvent se présenter :
->Si vous ne dessinez rien dans un panneau, il est un simple conteneur d’autres composants,
vous n’avez pas à redéfinir paint() ni paintComponent()
->Si votre panneau ne comprends que des instructions de dessin, redéfinissez paint ou
paintComponent qui sont équivalentes.
->Si votre panneau est un conteneur et que vous dessinez dedans, redéfinissez
paintComponent
Pour afficher ‘proprement’ un panneau de la classe JPanel, on redéfinit sa méthode :
paintComponent(Graphics g)
{super.paintComponent(g) ; <Instructions de dessins> ;}

2. paintComponent redessine tout le composant selon vos instructions et réaffiche en même
temps les composants qui lui sont contenus.
Il ne faut pas oublier l’appel à super, qui appelle la méthode mère de la classe mère(même
nom,mêmes paramètres) , sinon on a fréquemment des bugs d’affichage (J’en ai fait l’amère
expérience)
La méthode add :
On incorpore dans un panneau d’autres panneaux ou composants avec la méthode add :
Class MonPanneau extends JPanel
{public MonPanneau()
{add new JButton(« Hello ! ») ; }
}
public static void main(String[] args)
{JFrame jf=new JFrame() ;
jf.add(new MonPanneau() );
jf.setSize(200,200) ;
jf.setVisible(true) ;}
A noter qu’on ne redéfinira pas la méthode paintComponent d’un simple conteneur de
boutons .
Pour ajouter le panneau à notre fenêtre, nous pouvons également faire :
Jf.setContentPane(new MonPanneau()) ; qui nous signale qu’une fenêtre dispose toujours en
fait d’un panneau, accessible par la méthode getContentPane()
3)La méthode repaint()
Pour tout composant graphique,cette méthode appelle explicitement paintComponent()
Et tout le composant est réaffiché.
Il faut savoir que repaint peut être appelée implicitement, par exemple quand vous bougez la
fenêtre ou que vous la redimensionnez, ou qu’une fenêtre au-dessus est retirée.
Appelez repaint() (sans arguments !) quand votre graphique a été modifié . Attention
toutefois : si 2 ordres repaint sont très rapprochés, souvent un seul est pris en compte. Je pense
que la machine Java, une fois transmis l’ordre repaint, prépare cette action mais qu’elle est en
quelque sorte désynchronisée du reste du programme. Du coup, 2 repaint rapprochés sont
simplifiés en un seul ! Voici ce qui m’est arrivé quand j’appelai repaint () après tout
mouvement de pièce pour mon jeu d’échecs : Je jouais un coup ; l’ordinateur le sien, et
seulement à ce moment-là le repaint était effectué !
L’explication tient dans le fait que repaint est une méthode lourde et doit être employée avec
circonspection. Afin de procéder avec plus de légèreté, employez le ‘dessin en direct’ dans un
composant graphique :
Graphics g=getGraphics() ;
<Instructions graphiques employant g>
g.dispose() ; //Libère les ressources graphiques liées à g.
De cette manière, votre graphique n’est pas redessiné entièrement.

3. En cas de réaffichage, notez que des instructions ‘en direct’ disparaissent, à moins que
paintComponent() ne fasse rien.
4)Les Gestionnaires de positionnement de contenu
La méthode add, employable pour nos panneaux aussi bien que pour notre fenêtre,
ajoutera le composant en paramètre dans son conteneur un peu n’importe comment par
défaut(De gauche à droite,de haut en bas) : maFenetre.add(new MonPanneau())
On dit qu’on a le gestionnaire FlowLayout par défaut.
Pour modifier cela, d’autres gestionnaires existent :
BorderLayout
Les composants sont ajoutés au nord,au sud, au centre , etc… du conteneur.
Exemple : dans la méthode main : observer la méthode <conteneur>.setLayout(…)
Jf.setLayout(new BorderLayout()) ;
Jf.add(new MonPanneau(),BorderLayout.North) ;
Jf.add(new JButton(« okay »),BorderLayout.East) ;
Sans le deuxième paramètre, le contenu est ajouté au centre.
Attention, Si vous ajoutez deux composants au même endroit, un seul sera visible !Le
deuxième sera ignoré sans aucun message !
Si vous mettez beaucoup de composants, subdivisez-les car le panneau géré par BorderLayout
ne peut lui-même n’en contenir que 5.
Si vous dessinez dans votre panneau, je vous conseille de placer les composants contenus à
l’est et au sud , pour vous réserver le cadran ‘en haut,à gauche’ pour votre dessin. En effet,si
vous mettez un composant au nord,par exemple, vous devrez faire des calculs pour éviter de
dessiner au-dessus ; s’il est au sud, au pire, s’il cache le bas de votre dessin, un
redimensionnement adéquat de votre fenêtre rendra votre dessin visible.
En définitive,le plus simple est de faire des panneau conteneurs et d’autres des surfaces à
dessiner : on évite la cohabitation dessin/composants contenus.
Pour afficher une barre de boutons, on préfèrera…
Le gestionnaire GridLayout
Ce gestionnaire affiche les composants dans une grille rectangulaire , tous les composants
occupent le même espace.
Jf.setLayout(new GridLayout(5,3)) ;
Notre contenu sera disposé dans 5 lignes et 3 colonnes ;
A noter qu’on ne peut pas choisir l’emplacement d’un composant qu’on ajoute.
D’un point de vue ergonomique, observons que le composant Table du html s’en sort bien
mieux et permet plus de souplesse! Comme régler la largeur des colonnes, par exemple.

4. Un dernier gestionnaire existe, GridBagLayout, mais il est réputé pour être très compliqué.