Exercices en Java (11-Graphisme et Java2D)

Ce onzième chapitre porte sur le graphisme et Java2D.
Le premier exercice propose de dessiner un histogramme. Le deuxième exercice montre l'utilisation du JColorChooser. Le troisième exercice illustre les différentes formes de base que l'on peut dessiner et le quatrième exercice concerne les styles de formes. Le sixième exercice a pour but de dessiner des formes ovales de différentes tailles et de différentes couleurs à intervalle de temps régulier. Et, le septième exercice est une implémentation d'un labyrinthe en version graphique.

Les principales notions abordées sont les suivantes :

contexte graphique et objets graphiques ;
les couleurs ;
les polices de caractères ;
tracé de formes.

Pour faire et comprendre ces exercices, vous aurez besoin d'un certain nombre de notions sur le langage Java en rapport avec le chapitre. Pour cela, vous pouvez consulter les tutoriels Java de developpez.com à l'adresse suivante : https://java.developpez.com/cours/Cours en Java

La documentation de l'API sur le site de Sun est aussi une mine d'or : http://docs.oracle.com/javase/6/docs/api/Doc API Java

6 commentaires ♪

Article lu fois.

L'auteur

Sébastien ESTIENNE

L'article

Publié le 17 mars 2012 - Mis à jour le 17 avril 2012

Version PDF Version hors-ligne

ePub, Azw et Mobi

Liens sociaux

I. Histogramme▲

I-1. Énoncé▲

Écrivez un programme qui représente un histogramme. Celui-ci doit contenir six valeurs donc six barres (représentées par des rectangles) de couleurs différentes. Affichez aussi les axes (lignes) et la valeur au-dessus de chaque barre de l'histogramme.

Classes de l'API utilisées :

I-2. Aperçu▲

I-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

I-4. Solution▲

Histogramme.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier : Histogramme.java
 * Créé le : 7 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.Color;
import java.awt.Graphics;

import javax.swing.JFrame;



/**
 * <p>Classe représentant un histogramme.</p>
 * @author Sébastien ESTIENNE.
 */
public class Histogramme extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** Valeurs de l'histogramme. */
   private int[] valeurs;

   /** Valeur maximum. */
   private int max;

   /** Couleurs de barres de l'histogramme. */
   private Color[] couleurs;

   /** Décalage en X du graphique par rapport à la gauche de la fenêtre. */
   private static final int DEC_X = 40;
   
   /** Décalage en Y du graphique par rapport au bas de la fenêtre. */
   private static final int DEC_Y = 40;
   
   /** Décalage en X du texte au-dessus des barres de l'histogramme. */
   private static final int DEC_TX = DEC_X + 5;
   
   /** Décalage en Y du texte au-dessus des barres de l'histogramme. */
   private static final int DEC_TY = DEC_Y + 2;
   
   /** Décalage en hauteur de la ligne permettant de créer la flèche. */
   private static final int DEC_FH = 4;
   
   /** Décalage en longueur de la ligne permettant de créer la flèche. */
   private static final int DEC_FL = 8;
   
   /** Largeur d'une barre de l'histogramme. */
   private static final int LG_B = 30;
   
   /** Incrément pour calculer la hauteur des barres de l'histogramme en fonction de la valeur. */
   private static final int INCR = 10;

   /**
    * <p>Constructeur pour l'histogramme.</p>
    */
   public Histogramme()
   {
      super("Histogramme");

      // Initialisation des valeurs.
      this.valeurs = new int[6];
      this.valeurs[0] = 12;
      this.valeurs[1] = 10;
      this.valeurs[2] = 17;
      this.valeurs[3] = 5;
      this.valeurs[4] = 13;
      this.valeurs[5] = 8;
      this.max = 20;

      // Initialisation des couleurs.
      this.couleurs = new Color[6];
      this.couleurs[0] = Color.RED;
      this.couleurs[1] = Color.GREEN;
      this.couleurs[2] = Color.BLUE;
      this.couleurs[3] = Color.YELLOW;
      this.couleurs[4] = Color.MAGENTA;
      this.couleurs[5] = new Color(255, 102, 0);

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(350, 300);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Dessine la fenêtre.</p>
    * @param g Le contexte graphique utilisé pour dessiner.
    */
   @Override
   public void paint(Graphics g)
   {
      // Déclaration des variables utiles pour les calculs de l'histogramme.
      int x, y, x1, y1, x2, y2, largeur, hauteur;
      
      // Affichage des barres.
      for(int i = 0; i < this.valeurs.length; i++)
      {
         // Barre.
         x = DEC_X + i * (LG_B + 1);
         y = getHeight() - DEC_Y - this.valeurs[i] * INCR;
         largeur = LG_B;
         hauteur = this.valeurs[i] * INCR;
         g.setColor(this.couleurs[i]);
         g.fillRect(x, y, largeur, hauteur);
         
         // Valeur.
         x = DEC_TX + i * (LG_B + 1);
         y = getHeight() - DEC_TY - this.valeurs[i] * INCR;
         g.setColor(Color.BLACK);
         g.drawString("" + this.valeurs[i], x, y);
      }

      // Affichage de l'axe X.
      g.setColor(Color.BLACK);
      x1 = DEC_X;
      y1 = getHeight() - DEC_Y;
      x2 = x1 + this.valeurs.length * LG_B + LG_B;
      y2 = y1;
      g.drawLine(x1, y1, x2, y2);
      g.drawLine(x2, y2, x2 - DEC_FL, y2 - DEC_FH);
      g.drawLine(x2, y2, x2 - DEC_FL, y2 + DEC_FH);
      
      // Affichage de l'axe Y.
      x1 = DEC_X;
      y1 = getHeight() - DEC_Y;
      x2 = x1;
      y2 = y1 - this.max * INCR;
      g.drawLine(x1, y1, x2, y2);
      g.drawLine(x2, y2, x2 - DEC_FH, y2 + DEC_FL);
      g.drawLine(x2, y2, x2 + DEC_FH, y2 + DEC_FL);
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new Histogramme();
   }
}

II. Choix de couleurs▲

II-1. Énoncé▲

Écrivez un programme avec un bouton qui ouvre une fenêtre de sélection de couleur : JColorChooser et qui permet ainsi de changer la couleur de fond de la fenêtre.

Classes de l'API utilisées :

II-2. Aperçu▲

II-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

II-4. Solution▲

ColorChooser.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier : ColorChooser.java
 * Créé le : 8 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.Color;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JColorChooser;
import javax.swing.JFrame;



/**
 * <p>Classe utilisant un JColorChooser.</p>
 * @author Sébastien ESTIENNE.
 */
public class ColorChooser extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** Bouton pour changer la couleur de fond. */
   private JButton boutonCouleur;


   /**
    * <p>Constructeur initialisant la fenêtre.</p>
    */
   public ColorChooser()
   {
      super("ColorChooser");

      // Change le gestionnaire de canvas.
      getContentPane().setLayout(new FlowLayout());

      // Crée le bouton.
      this.boutonCouleur = new JButton("Changer couleur");
      this.boutonCouleur.addActionListener(
      /** L'interface écouteur permettant de recevoir des événements d'actions. */
      new ActionListener()
      {
         // Invoqué quand une action se produit.
         public void actionPerformed(ActionEvent e)
         {
            // Demander à l'utilisateur de choisir une couleur grâce au JColorChooser.
            Color c = JColorChooser.showDialog(ColorChooser.this, "Choisissez une couleur de fond",
                  ColorChooser.this.getContentPane().getBackground());
            // Change la couleur de fond.
            if(c != null)
            {
               ColorChooser.this.getContentPane().setBackground(c);
            }
         }
      });

      // Ajoute le bouton.
      getContentPane().add(this.boutonCouleur);

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(400, 200);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new ColorChooser();
   }
}

III. Polices de caractères▲

III-1. Énoncé▲

Écrivez un programme avec une fenêtre contenant trois chaînes de caractères de styles, polices et couleurs différents :

Monospaced 10 pt normal bleu ;
Serif 12 pt gras rouge ;
Sans Serif 14 pt italique vert.

Classes de l'API utilisées :

III-2. Aperçu▲

III-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

III-4. Solution▲

PolicesCaracteres.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier : PolicesCaracteres.java
 * Créé le : 8 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics;

import javax.swing.JFrame;



/**
 * <p>Classe utilisant les polices de caractères.</p>
 * @author Sébastien ESTIENNE.
 */
public class PolicesCaracteres extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;


   /**
    * <p>Constructeur initialisant la fenêtre.</p>
    */
   public PolicesCaracteres()
   {
      super("Polices de caractères");

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(300, 150);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Dessine la fenêtre.</p>
    * @param g Le contexte graphique utilisé pour dessiner.
    */
   @Override
   public void paint(Graphics g)
   {
      // Monospaced 10 pt normal bleu.
      g.setColor(Color.BLUE);
      g.setFont(new Font("Monospaced", Font.PLAIN, 10));
      g.drawString("Monospaced 10 pt normal bleu.", 40, 60);

      // Serif 12 pt gras rouge.
      g.setColor(Color.RED);
      g.setFont(new Font("Serif", Font.BOLD, 12));
      g.drawString("Serif 12 pt gras rouge.", 40, 90);

      // Sans Serif 14 pt italique vert.
      g.setColor(Color.GREEN);
      g.setFont(new Font("Sans Serif", Font.ITALIC, 14));
      g.drawString("Sans Serif 14 pt italique vert.", 40, 120);
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new PolicesCaracteres();
   }
}

IV. Formes graphiques▲

IV-1. Énoncé▲

Écrivez un programme avec une fenêtre contenant les formes graphiques suivantes :

un rectangle bleu ;
un rectangle plein bleu ;
un rectangle arrondi magenta ;
un rectangle arrondi plein magenta ;
un ovale vert ;
un ovale plein vert ;
un arc orange ;
un arc plein orange ;
une ligne rouge ;
une polyligne noire ;
un polygone noir.

Classes de l'API utilisées :

IV-2. Aperçu▲

IV-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

IV-4. Solution▲

FormesGraphiques.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier : FormesGraphiques.java
 * Créé le : 8 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.Color;
import java.awt.Graphics;
import java.awt.Polygon;

import javax.swing.JFrame;



/**
 * <p>Classe utilisant différentes formes graphiques de base.</p>
 * @author Sébastien ESTIENNE.
 */
public class FormesGraphiques extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;


   /**
    * <p>Constructeur initialisant la fenêtre.</p>
    */
   public FormesGraphiques()
   {
      super("Formes graphiques");

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(350, 250);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Dessine la fenêtre.</p>
    * @param g Le contexte graphique utilisé pour dessiner.
    */
   @Override
   public void paint(Graphics g)
   {
      // Un rectangle bleu.
      g.setColor(Color.BLUE);
      g.drawRect(20, 40, 60, 40);

      // Un rectangle plein bleu.
      g.fillRect(90, 40, 60, 40);

      // Un rectangle arrondi magenta.
      g.setColor(Color.MAGENTA);
      g.drawRoundRect(180, 40, 60, 40, 12, 12);

      // Un rectangle arrondi plein magenta.
      g.fillRoundRect(250, 40, 60, 40, 12, 12);

      // Un ovale vert.
      g.setColor(Color.GREEN);
      g.drawOval(20, 100, 60, 40);

      // Un ovale plein vert.
      g.fillOval(90, 100, 60, 40);

      // Un arc orange.
      g.setColor(Color.ORANGE);
      g.drawArc(180, 100, 40, 40, 90, 270);

      // Un arc plein orange.
      g.fillArc(250, 100, 40, 40, 0, 270);

      // Une ligne rouge.
      g.setColor(Color.RED);
      g.drawLine(20, 160, 80, 200);

      // Une polyligne noire.
      g.setColor(Color.BLACK);
      int nbPoints = 3;
      int[] xPoints = {180, 210, 240};
      int[] yPoints = {200, 160, 200};
      g.drawPolygon(xPoints, yPoints, nbPoints);

      // Un polygone noire.
      Polygon p = new Polygon();
      p.addPoint(250, 160);
      p.addPoint(310, 160);
      p.addPoint(310, 200);
      p.addPoint(280, 200);
      p.addPoint(280, 180);
      p.addPoint(250, 180);
      g.fillPolygon(p);
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new FormesGraphiques();
   }
}

V. Style des formes▲

V-1. Énoncé▲

Écrivez un programme avec une fenêtre contenant les formes graphiques suivantes :

un rectangle vert avec traits épais ;
un rectangle arrondi avec un dégradé bleu-rouge comme couleur de remplissage ;
un ovale avec un motif à l'intérieur ;
un trait fort orange en pointillé.

Classes de l'API utilisées :

V-2. Aperçu▲

V-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

V-4. Solution▲

StylesFormes.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier : StylesFormes.java
 * Créé le : 8 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.TexturePaint;
import java.awt.geom.Ellipse2D;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.geom.RoundRectangle2D;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;



/**
 * <p>Classe utilisant différents styles des formes.</p>
 * @author Sébastien ESTIENNE.
 */
public class StylesFormes extends JFrame
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;


   /**
    * <p>Constructeur initialisant la fenêtre.</p>
    */
   public StylesFormes()
   {
      super("Styles des formes");

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(350, 250);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Dessine la fenêtre.</p>
    * @param g Le contexte graphique utilisé pour dessiner.
    */
   @Override
   public void paint(Graphics g)
   {
      // Passage à la 2D.
      Graphics2D g2d = (Graphics2D) g;

      // Un rectangle vert avec une épaisseur de trait.
      g2d.setPaint(Color.GREEN);
      g2d.setStroke(new BasicStroke(5.0f));
      g2d.draw(new Rectangle2D.Double(20, 40, 80, 50));

      // Un rectangle arrondi avec un dégradé bleu-rouge.
      g2d.setPaint(new GradientPaint(0, 0, Color.BLUE, 0, 40, Color.RED, true));
      g2d.fill(new RoundRectangle2D.Double(140, 40, 80, 50, 15, 15));

      // Un ovale avec un motif à l'intérieur.
      BufferedImage motif = new BufferedImage(9, 9, BufferedImage.TYPE_INT_RGB);
      Graphics2D gm = motif.createGraphics();
      gm.setColor(Color.RED);
      gm.fillRect(0, 0, 9, 9);
      gm.setColor(Color.GREEN);
      gm.fillRect(2, 2, 7, 7);
      gm.setColor(Color.BLUE);
      gm.fillRect(4, 4, 3, 3);
      g2d.setPaint(new TexturePaint(motif, new Rectangle(9, 9)));
      g2d.fill(new Ellipse2D.Double(20, 110, 80, 50));

      // Un trait fort orange en pointillé.
      g2d.setPaint(Color.ORANGE);
      float[] tirets = {10, 5, 2, 5};
      g2d.setStroke(new BasicStroke(2, BasicStroke.CAP_SQUARE, BasicStroke.JOIN_BEVEL, 10, tirets,
            0));
      g2d.draw(new Line2D.Double(140, 110, 220, 160));
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new StylesFormes();
   }
}

VI. Disques aléatoires▲

VI-1. Énoncé▲

Écrivez un programme qui affiche de manière aléatoire des disques de tailles et de couleurs différentes dans une fenêtre. Utilisez un Timer (javax.swing) permettant d'afficher les disques à intervalle de temps régulier.

Sélectionnez

    Timer minuterie = new Timer(int delai, ActionListener tache);
    minuterie.start();

Classes de l'API utilisées :

VI-2. Aperçu▲

VI-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VI-4. Solution▲

DisquesAleatoires.java

Cacher/Afficher le codeSélectionnez

/*
 * Fichier : DisquesAleatoires.java
 * Créé le : 9 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.Timer;



/**
 * <p>Classe affichant des disques de manière aléatoire.</p>
 * @author Sébastien ESTIENNE.
 */
public class DisquesAleatoires extends JFrame implements ActionListener
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** La minuterie pour l'affichage des disques. */
   private Timer minuterie;


   /**
    * <p>Constructeur initialisant la fenêtre.</p>
    */
   public DisquesAleatoires()
   {
      super("Disques aléatoires");

      // Initialisation du timer.
      this.minuterie = new Timer(50, this);
      this.minuterie.start();

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(400, 300);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Dessine la fenêtre.</p>
    * @param g Le contexte graphique utilisé pour dessiner.
    */
   @Override
   public void paint(Graphics g)
   {
      // Trois nombres aléatoires entre 0 et 255 pour la couleur.
      int r = (int) (Math.random() * 256);
      int v = (int) (Math.random() * 256);
      int b = (int) (Math.random() * 256);

      // Coordonnées et taille de l'ovale.
      int x = (int) (Math.random() * getWidth());
      int y = (int) (Math.random() * getHeight());
      int taille = 10 + (int) (Math.random() * 65);

      // Dessine le disque.
      g.setColor(new Color(r, v, b));
      g.fillOval(x, y, taille, taille);
   }


   /**
    * Invoqué quand une action se produit.
    * @param e L'événement qui indique qu'une action s'est produite.
    */
   public void actionPerformed(ActionEvent e)
   {
      repaint();
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new DisquesAleatoires();
   }
}

VII. Labyrinthe graphique▲

VII-1. Énoncé▲

Écrivez une version graphique du parcours de labyrinthe (chapitre 6).
L'algorithme le plus simple qui permet de trouver la sortie d'un labyrinthe (si elle existe), est de garder toujours sa main droite le long du mur en suivant les changements de direction avec cette même main. Évidemment ce n'est certainement pas le plus court… mais on trouve la sortie ainsi.
Écrivez une méthode récursive qui implémente cet algorithme. Utilisez aussi un JTextArea pour afficher une représentation du labyrinthe et ajoutez un bouton permettant de suivre étape par étape le parcours dans le labyrinthe.

Sélectionnez

                    # # # # # # # # # # # # 
                    # . . . # . . . . . . # 
                    . . # . # . # # # # . # 
                    # # # . # . . . . # . # 
                    # . . . . # # # . # . . 
                    # # # # . # . # . # . # 
                    # . . # . # . # . # . # 
                    # # . # . # . # . # . # 
                    # . . . . . . . . # . # 
                    # # # # # # . # # # . # 
                    # . . . . . . # . . . # 
                    # # # # # # # # # # # #

Classes de l'API utilisées :

VII-2. Aperçu▲

VII-3. Démonstration▲

Lancer avec Java Web Start

Note : javaws -viewer (accessible également depuis le panneau de configuration Java) permet de voir les différentes applications JWS en cache et de les gérer.

VII-4. Solution▲

LabyrintheGraphique.java

Cacher/Afficher le codeSélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.
114.
115.
116.
117.
118.
119.
120.
121.
122.
123.
124.
125.
126.
127.
128.
129.
130.
131.
132.
133.
134.
135.
136.
137.
138.
139.
140.
141.
142.
143.
144.
145.
146.
147.
148.
149.
150.
151.
152.
153.
154.
155.
156.
157.
158.
159.
160.
161.
162.
163.
164.
165.
166.
167.
168.
169.
170.
171.
172.
173.
174.
175.
176.
177.
178.
179.
180.
181.
182.
183.
184.
185.
186.
187.
188.
189.
190.
191.
192.
193.
194.
195.
196.
197.
198.
199.
200.
201.
202.
203.
204.
205.
206.
207.
208.
209.
210.
211.
212.
213.
214.
215.
216.
217.
218.
219.
220.
221.
222.
223.
224.
225.
226.
227.
228.
229.
230.
231.
232.
233.
234.
235.
236.
237.
238.
239.
240.
241.
242.
243.
244.
245.
246.
247.
248.
249.
250.
251.
252.
253.
254.
255.
256.
257.
258.
259.
260.
261.
262.
263.
264.
265.
266.
267.
268.
269.
270.
271.
272.
273.
274.
275.
276.
277.
278.
279.
280.
281.
282.
283.
284.
285.
286.
287.
288.
289.
290.
291.
292.
293.
294.
295.
296.
297.
298.
299.
300.
301.
302.
303.
304.
305.
306.
307.
308.
309.
310.
311.
312.
313.
314.
315.
316.
317.
318.
319.
320.
321.
322.
323.
324.
325.
326.
327.
328.
329.
330.
331.
332.
333.
334.
335.
336.
337.
338.
339.
340.
341.
342.
343.
344.

/*
 * Fichier : LabyrintheGraphique.java
 * Créé le : 10 février 2007.
 * Modifié : 15 avril 2012.
 * Auteurs : Sébastien ESTIENNE.
 * SiteWeb : http://www.prog-info.org/
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

package chapitre11;



import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JFrame;
import javax.swing.Timer;



/**
 * <p>Classe affichant le parcours de labyrinthes.</p>
 * @author Sébastien ESTIENNE.
 */
public class LabyrintheGraphique extends JFrame implements ActionListener
{
   /**
    * <p>Serial version UID.</p>
    */
   private static final long serialVersionUID = 1L;

   /** La minuterie pour l'affichage des disques. */
   private Timer minuterie;

   /** Le labyrinthe. */
   private boolean[][] labyrinthe = {
         {false, false, false, false, false, false, false, false, false, false, false, false},
         {false, true, true, true, false, true, true, true, true, true, true, false},
         {true, true, false, true, false, true, false, false, false, false, true, false},
         {false, false, false, true, false, true, true, true, true, false, true, false},
         {false, true, true, true, true, false, false, false, true, false, true, true},
         {false, false, false, false, true, false, true, false, true, false, true, false},
         {false, true, true, false, true, false, true, false, true, false, true, false},
         {false, false, true, false, true, false, true, false, true, false, true, false},
         {false, true, true, true, true, true, true, true, true, false, true, false},
         {false, false, false, false, false, false, true, false, false, false, true, false},
         {false, true, true, true, true, true, true, false, true, true, true, false},
         {false, false, false, false, false, false, false, false, false, false, false, false}};

   /** Position courante en x dans le labyrinthe. */
   private int x;

   /** Position courante en y dans le labyrinthe. */
   private int y;

   /** Position de départ en x dans le labyrinthe. */
   private final int xd = 0;

   /** Position de départ en y dans le labyrinthe. */
   private final int yd = 2;

   /** Énumération pour la direction. */
   private enum Direction
   {
      /** Direction : vers la droite. */
      DROITE,
      /** Direction : vers le bas. */
      BAS,
      /** Direction : vers la gauche. */
      GAUCHE,
      /** Direction : vers le haut. */
      HAUT
   }

   /** La direction courante. */
   private Direction direction;

   /** Taille du pion se déplaçant dans le labyrinthe. */
   private static final int TAILLE_PION = 18;

   /** Taille des cases du labyrinthe. */
   private static final int TAILLE_CASE = 20;

   /** Taille du décalage à gauche du labyrinthe. */
   private static final int DEC_GAUCHE = 25;

   /** Taille du décalage en haut du labyrinthe. */
   private static final int DEC_HAUT = 50;


   /**
    * <p>Constructeur initialisant la fenêtre.</p>
    */
   public LabyrintheGraphique()
   {
      super("Labyrinthe graphique");

      // Initialisation du labyrinthe.
      this.x = 0;
      this.y = 2;
      this.direction = Direction.DROITE;

      // Initialisation du timer.
      this.minuterie = new Timer(500, this);
      this.minuterie.start();

      // Propriétés de la fenêtre.
      setLocation(50, 50);
      setSize(295, 315);
      setVisible(true);
      setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
   }


   /**
    * <p>Algorithme permettant d'avancer dans le labyrinthe.</p>
    */
   public void avancer()
   {
      // Vérification de terminaison.
      if(this.x == this.xd && this.y == this.yd || this.x > 0 && this.y > 0
            && this.x < this.labyrinthe[0].length && this.y < this.labyrinthe.length)
      {
         switch(this.direction)
         {
         // Direction de déplacement : Droite.
         case DROITE:
            // Pas de mur sur la droite : dans un angle.
            if(this.y + 1 < this.labyrinthe.length && this.labyrinthe[this.y + 1][this.x])
            {
               this.direction = Direction.BAS;
               this.y++;
            }
            // Un mur selon la direction de déplacement.
            else if(this.x + 1 < this.labyrinthe[0].length && !this.labyrinthe[this.y][this.x + 1])
            {
               // Changement de direction suivant le mur.
               if(this.y - 1 >= 0 && this.labyrinthe[this.y - 1][this.x])
               {
                  this.direction = Direction.HAUT;
                  this.y--;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = Direction.GAUCHE;
                  this.x--;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.x + 1 < this.labyrinthe[0].length)
            {
               this.x++;
            }
            else
            {
               this.minuterie.stop();
            }
            break;
         // Direction de déplacement : Bas.
         case BAS:
            // Pas de mur sur la droite : dans un angle.
            if(this.x - 1 >= 0 && this.labyrinthe[this.y][this.x - 1])
            {
               this.direction = Direction.GAUCHE;
               this.x--;
            }
            // Un mur selon la direction de déplacement.
            else if(this.y + 1 < this.labyrinthe.length && !this.labyrinthe[this.y + 1][this.x])
            {
               // Changement de direction suivant le mur.
               if(this.x + 1 < this.labyrinthe[0].length && this.labyrinthe[this.y][this.x + 1])
               {
                  this.direction = Direction.DROITE;
                  this.x++;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = Direction.HAUT;
                  this.y--;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.y + 1 < this.labyrinthe.length)
            {
               this.y++;
            }
            else
            {
               this.minuterie.stop();
            }
            break;
         // Direction de déplacement : Gauche.
         case GAUCHE:
            // Pas de mur sur la droite : dans un angle.
            if(this.y - 1 >= 0 && this.labyrinthe[this.y - 1][this.x])
            {
               this.direction = Direction.HAUT;
               this.y--;
            }
            // Un mur selon la direction de déplacement.
            else if(this.x - 1 >= 0 && !this.labyrinthe[this.y][this.x - 1])
            {
               // Changement de direction suivant le mur.
               if(this.y + 1 < this.labyrinthe[0].length && this.labyrinthe[this.y + 1][this.x])
               {
                  this.direction = Direction.BAS;
                  this.y++;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = Direction.DROITE;
                  this.x++;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.x - 1 >= 0)
            {
               this.x--;
            }
            else
            {
               this.minuterie.stop();
            }
            break;
         // Direction de déplacement : Haut.
         case HAUT:
            // Pas de mur sur la droite : dans un angle.
            if(this.x + 1 < this.labyrinthe.length && this.labyrinthe[this.y][this.x + 1])
            {
               this.direction = Direction.DROITE;
               this.x++;
            }
            // Un mur selon la direction de déplacement.
            else if(this.y - 1 >= 0 && !this.labyrinthe[this.y - 1][this.x])
            {
               // Changement de direction suivant le mur.
               if(this.x - 1 >= 0 && this.labyrinthe[this.y][this.x - 1])
               {
                  this.direction = Direction.GAUCHE;
                  this.x--;
               }
               // Impasse : demi-tour.
               else
               {
                  this.direction = Direction.BAS;
                  this.y++;
               }
            }
            // Case libre devant : déplacement selon la direction.
            else if(this.y - 1 >= 0)
            {
               this.y--;
            }
            else
            {
               this.minuterie.stop();
            }
            break;
         default:
            break;
         }
      }
   }


   /**
    * <p>Dessine la fenêtre.</p>
    * @param g Le contexte graphique utilisé pour dessiner.
    */
   @Override
   public void paint(Graphics g)
   {
      // Parcourt le labyrinthe.
      for(int i = 0; i < this.labyrinthe.length; i++)
      {
         for(int j = 0; j < this.labyrinthe.length; j++)
         {
            // Case libre.
            if(this.labyrinthe[i][j])
            {
               g.setColor(Color.WHITE);
               g.fillRect(DEC_GAUCHE + j * TAILLE_CASE, DEC_HAUT + i * TAILLE_CASE, 
                     TAILLE_CASE, TAILLE_CASE);
               g.setColor(Color.LIGHT_GRAY);
               g.drawRect(DEC_GAUCHE + j * TAILLE_CASE, DEC_HAUT + i * TAILLE_CASE, 
                     TAILLE_CASE, TAILLE_CASE);
            }
            // Mur.
            else
            {
               g.setColor(Color.BLUE);
               g.fillRect(DEC_GAUCHE + j * TAILLE_CASE, DEC_HAUT + i * TAILLE_CASE, 
                     TAILLE_CASE, TAILLE_CASE);
            }
         }
      }

      // Position courante dans le labyrinthe.
      g.setColor(Color.RED);
      g.fillOval(DEC_GAUCHE + 1 + this.x * TAILLE_CASE, DEC_HAUT + 1 + this.y * TAILLE_CASE, 
            TAILLE_PION, TAILLE_PION);
   }


   /**
    * Invoqué quand une action se produit.
    * @param e L'événement qui indique qu'une action s'est produite.
    */
   public void actionPerformed(ActionEvent e)
   {
      avancer();
      repaint(DEC_GAUCHE + (this.x - 1) * TAILLE_CASE, DEC_HAUT + (this.y - 1) * TAILLE_CASE,
            3 * TAILLE_CASE, 3 * TAILLE_CASE);
   }


   /**
    * <p>Commence l'exécution du programme.</p>
    * @param args Les paramètres de la ligne de commande.
    */
   public static void main(String[] args)
   {
      new LabyrintheGraphique();
   }
}

VIII. Remerciements▲

Je tiens à remercier keulkeul et kdmbella pour les conseils, remarques et relectures.
Je remercie aussi www.developpez.com me permettant de publier cet article et Nono40 pour ses outils.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants :

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2012 Sébastien ESTIENNE. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.