Peinture avec Swing Java

Il y a des choses que vous ne faites pas dans le bon sens.

1. Tout d'abord, vous définissez la propriété visible du JFrame sur visible bien avant d'y ajouter tous les composants et de lui faire réaliser sa taille.
2. Deuxièmement, vous utilisez un Absolute Layout, que l'on devrait éviter dans la plupart des situations.
3. Troisièmement, vous créez explicitement un objet Graphics, que l'on devrait éviter et utiliser à la place celui fourni par la méthode paintComponent ( ... ) de Java par par défaut

Regardez cet exemple:

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

public class DrawingCircleExample {

    private JPanel drawingBoard;
    private JButton button;

    private static final int GAP = 5;

    private void displayGUI () {
        JFrame frame = new JFrame ( "" );
        frame.setDefaultCloseOperation ( JFrame.DISPOSE_ON_CLOSE );

        JPanel contentPane = new JPanel ();
        contentPane.setLayout ( new BorderLayout ( GAP, GAP ) );
        drawingBoard = new DrawingBoard ();
        contentPane.add ( drawingBoard, BorderLayout.CENTER );

        button = new JButton ( "Draw" );
        button.addActionListener ( new ActionListener () {
            @Override
            public void actionPerformed ( ActionEvent ae ) {
                 DrawingBoard board = ( DrawingBoard ) drawingBoard;
                 board.setState ();
            }
        } );
        contentPane.add ( button, BorderLayout.PAGE_END );

        frame.setContentPane ( contentPane );
        frame.pack ();
        frame.setLocationByPlatform ( true );
        frame.setVisible ( true );
    }

    public static void main ( String [] args ) {
        Runnable runnable = new Runnable () {
            @Override
            public void run () {
                new DrawingCircleExample ().displayGUI ();
            }
        };
        EventQueue.invokeLater ( runnable );
    }
}

class DrawingBoard extends JPanel {

    private static final int TOTAL_RECTANGLES = 5;
    private static final int WIDTH = 400;
    private static final int HEIGHT = 300;
    private static final int RADIUS = 50;
    private static final int X = 50;
    private static final int Y = 50;
    private int counter;
    private int moveXBy;
    private boolean isActive;
    private int count;

    public DrawingBoard () {
        setOpaque ( true );
        counter = 0;
        count = 0;
        isActive = false;
        moveXBy = ( RADIUS + ( counter ) * RADIUS );
    }

    public boolean setState () {        
        isActive = true;
        System.out.println ( "Outside MoveXBy: " + moveXBy );
        ++counter;
        counter %= TOTAL_RECTANGLES;
        int x = ( RADIUS + ( counter ) * RADIUS );
        if ( moveXBy != x ) {
            System.out.println ( "Inside First MoveXBy: " + moveXBy );
            repaint ( moveXBy, RADIUS, X, Y );
            moveXBy = x;
            System.out.println ( "Inside Second MoveXBy: " + moveXBy );
            repaint ( moveXBy, RADIUS, X, Y );          
        }       

        return isActive;
    }

    @Override
    public Dimension getPreferredSize () {
        return new Dimension ( WIDTH, HEIGHT );
    }

    @Override
    protected void paintComponent ( Graphics g ) {
        super.paintComponent ( g );
        g.drawRect ( 50, RADIUS, X, Y );
        g.drawRect ( 100, RADIUS, X, Y );
        g.drawRect ( 150, RADIUS, X, Y );
        g.drawRect ( 200, RADIUS, X, Y );
        g.drawRect ( 250, RADIUS, X, Y );

        g.setColor ( Color.RED );
        g.fillOval ( moveXBy, RADIUS, X, Y ) ;
    }
}

MODIFIER concernant le commentaire:

Toutes lesInterfaces utilisateur graphiques nécessitent une sorte de cadre d'application principal dans lequel s'afficher. Dans Swing, c'est une instance de javax.swing.JFrame. Par conséquent, notre première étape consiste à instancier cette classe et à nous assurer que tout fonctionne comme prévu. Notez que lors de la programmation dans Swing , votre code de création d'interface graphique doit être placé sur l'événement Dispatch Thread (EDT), plus d'informations sur Concurrence dans Swing. Cela permettra d'éviter des conditions de course potentielles qui pourraient conduire à l'impasse.

DrawingBoard remplace également les getPreferredSize, qui retourne la hauteur et la largeur du panneau (dans ce cas - 400 est l'width, 300 est à la hauteur.) Pour cette raison, la classe DrawingCircleExample n'a plus besoin de spécifier la taille du cadre en pixels. Il ajoute simplement le panneau au cadre, puis appelle pack.

Le paintComponent la méthode est l'endroit où toute votre peinture personnalisée a lieu. Cette méthode est définie par javax.swing.JComponent, puis remplacée par vos sous-classes pour fournir leur comportement personnalisé. Son seul paramètre, un java.awt.Graphics object, expose un certain nombre de méthodes pour dessiner des formes 2D et obtenir des informations sur l'environnement graphique de l'application. Dans la plupart des cas, l'objet réellement reçu par cette méthode sera une instance de java.awt.Graphics2D (une sous-classe graphique), qui prend en charge le rendu graphique 2D sophistiqué.

La plupart des composants Swing standard ont leur apparence implémentée par des objets "UI Delegate" séparés. L'invocation de super.paintComponent (g) transmet le contexte graphique au délégué de l'interface utilisateur du composant, qui peint l'arrière-plan du panneau.

Pour garder notre peinture personnalisée aussi efficace que possible, nous suivrons les coordonnées X ( moveXBy variable dans notre cas) et repeindre seulement le les zones de l'écran qui ont changé. C'est une pratique recommandée qui gardera votre application de fonctionner aussi efficacement que possible.

L'invocation de la méthode repaint. Cette méthode est définie par java.awt.Component et est le mécanisme qui vous permet de repeindre par programme la surface d'un composant donné. Il a une version no-arg (qui repeint tout le composant) et une version multi-arg (qui repeint uniquement la zone spécifiée.) Cette zone est également connue sous le nom de clip. Invoquer la version multi-arg de repaint demande un petit effort supplémentaire, mais garantit que votre code de peinture ne gaspillera pas les cycles repeindre les zones de l'écran qui n'ont pas changé.

Parce que nous définissons manuellement le clip, notre méthode setState appelle la méthode repaint pas une fois, mais deux fois. La première invocation indique à Swing de repeindre la zone du composant où se trouvait précédemment l'ovale (le comportement hérité utilise le délégué de l'interface utilisateur pour remplir cette zone avec l'arrière-plan actuel couleur.) La deuxième invocation peint la zone du composant où se trouve actuellement l'ovale. Un point important à noter est que bien que nous ayons invoqué repaintdeux fois de suite dans le même gestionnaire d'événements, Swing est assez intelligent pour prendre ces informations et repeindre ces sections de l'écran en une seule opération de peinture. En d'autres termes, Swing ne repeindra pas le composant deux fois de suite, même si c'est ce que le code semble faire.

Se référer plus loin sur le sujet à effectuer une peinture personnalisée