Corrections des exercices du livre "Java pour les enfants, les parents et les grand-parents"

VII. Chapitre 8▲

VII-A. Application commande de vélos▲

On dispose déjà des classes EcranCommande et TropDeVelosException. Utilisez la fonction rechercher/remplacer de l'éditeur, pour "retirer" tous les accents dans les deux classes.

La classe EcranCommande doit être complétée :

pour y déclarer les composants (variables de classe) et les construire (dans le constructeur) ;
pour vérifier, dans la méthode actionPerformed(), que la quantité commandée ne dépasse pas la quantité disponible.

VII-A-1. Nouvelle version de TropDeVelosException▲

Mais avant cela, il faut d'abord remarquer que l'on a besoin d'un constructeur prenant un paramètre de type String, dans la classe TropDeVelosException. Pourquoi ? À cause de la ligne suivante de la classe EcranCommande (cherchez dans la méthode verifierCommande()) :

Sélectionnez

        throw new TropDeVelosException ("Impossible de livrer " + quantite + " velos du modele " + modeleVelo + " en une fois.");

On remarque que:

c'est un appel au constructeur de la classe TropDeVelosException. En effet, on utilise le mot-clé new ;
le paramètre passé est une chaine de caractères (obtenue par une concaténation : pour rappel, une chaine construite avec un mélange de chaines et de types primitifs. Et ce grâce à l'opérateur "+"). Or ce constructeur n'existe pas encore dans la classe TropDeVelosException.

De plus, la classe mère Exception de TropDeVelosException dispose d'un constructeur acceptant un String.

Voici donc une nouvelle version de la classe TropDeVelosException :

Nouvelle version de TropDeVelosException

Cacher/Afficher le codeSélectionnez

class TropDeVelosException extends Exception {
    // Constructeur
    TropDeVelosException() {
        // Appelle simplement le constructeur de la superclasse
        // et lui passe le message d'erreur a afficher
        super("Impossible de livrer autant de velos en une fois.");
    }
    
    TropDeVelosException(String message){
        /*
         * Initialise l'objet avec le message desire,
         * grace au constructeur de la classe mere.
         */
        super(message);
    }
}

VII-A-2. Correction d'une légère anomalie dans le code original de EcranCommande▲

Dans la classe EcranCommande, méthode actionPerformed(), cette ligne comporte encore deux légères erreurs :

Sélectionnez

commandeVelos.verifierCommande(modeleChoisi, quantiteChoisie);

En effet :

=> la méthode verfierCommande est déjà présente dans la classe EcranCommande. Aussi on n'a pas besoin d'appeler :

Sélectionnez

commandeVelos.verifierCommande(modeleChoisi, quantiteChoisie);

mais on peut tout simplement se contenter de :

Sélectionnez

verifierCommande(modeleChoisi, quantiteChoisie);

=> le deuxième paramètre de la méthode verifierCommande devant être un int, ce n'est pas la valeur de quantiteChoisie (String) qui doit être passée, mais le paramètre quantite (int).

On corrige donc par la simple ligne :

Sélectionnez

verifierCommande(modeleChoisi, quantite);

VII-A-3. EcranCommande sera une fenêtre Swing▲

Il nous est demandé de réaliser une application Swing. On peut faire hériter la classe EcranCommande de javax.swing.JFrame et procéder à quelques réglages (modification du constructeur sans arguments) :

Première ébauche pour EcranCommandes

Cacher/Afficher le codeSélectionnez

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

import javax.swing.JFrame;

class EcranCommande extends JFrame implements ActionListener {
    
    public EcranCommande(){
        // titre
        setTitle("Commande de velos");
        // taille
        setSize(400,300);
        // centrer la fenetre sur l'ecran
        setLocationRelativeTo(null);
        // on quitte l'application si la fenetre est fermee
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
    
    public void actionPerformed(ActionEvent evt) {
        // L'utilisateur a clique sur le bouton Commander
        String modeleChoisi = champTexteModele.getText();
        String quantiteChoisie = champTexteQuantite.getText();
        int quantite = Integer.parseInt(quantiteChoisie);
        try {
            commandeVelos.verifierCommande(modeleChoisi,
                    quantiteChoisie);
            // Cette ligne sera sautee en cas d'exception
            champTexteConfirmationCommande.setText(
                    "Votre commande est prete.");
        } catch(TropDeVelosException e) {
            champTexteConfirmationCommande.setText(e.getMessage());
        }
    }
    void verifierCommande(String modeleVelo, int quantite)
            throws TropDeVelosException {
        // Ecris le code qui verifie que la quantite demandee
        // du modele selectionne entre bien dans la camionnette.
        // Si ça n'entre pas, faire ce qui suit :
        throw new TropDeVelosException ("Impossible de livrer " +
                quantite + " velos du modele " + modeleVelo +
                " en une fois.");
    }
}

N'oubliez pas que la définition des interfaces implémentées vient après la définition de l'éventuelle classe mère. Donc, lorsque l'on déclare une classe, on précise toujours d'abord la classe mère (par le mot-clé extends) avant les interfaces implémentées (par le mot-clé implements).

VII-A-4. Déclaration et construction des composants de la classe EcranCommande▲

On devine aisément, d'après le code EcranCommande, quels sont les composants à déclarer :

un JTextField nommé champTexteModele et donc également un JLabel identifiant le champ ;
un JTextField nommé champTexteQuantite et donc un JLabel l'identifiant ;
un JTextField nommé champTexteConfirmationCommande et donc un JLabel l'identifiant.

Mais il faudra également créer un bouton permettant à l'utilisateur de soumettre sa commande.

On ajoutera l'ensemble de ces composants à un JPanel, qui sera intégré à la fenêtre. Pour agencer les composants, j'ai choisi un GridLayout de quatre lignes par deux colonnes ; avec un espacement de cinq pixels entre les composants (en largeur : troisième paramètre du constructeur et en hauteur : quatrième paramètre du constructeur).

Enfin, il faut donner au bouton son écouteur d'évènements : on peut lui attribuer l'instance courante de EcranCommande, à savoir this. La classe EcranCommande implémente déjà l'interface ActionListener et sa méthode ActionPerformed est déjà prévue pour exécuter le code de validation/annulation de commande.

VII-A-5. Vérification de la commande et la nouvelle classe ModeleVelo▲

La méthode verifierCommande est incomplète : elle se contente de renvoyer une exception TropDeVelosException, sans même vérifier si la commande est valable.

À chaque commande, il faut vérifier :

si le modèle existe ;
si la quantité commandée pour ce modèle n'excède pas la quantité maximale autorisée.

Pour procéder, on peut créer une classe ModeleVelo. Elle servira à nous renseigner à la fois sur le nom et la quantité maximale d'un modèle :

Premiere ébauche de ModeleVelo

Sélectionnez

public class ModeleVelo {

    String model;
    int quantiteMaximumCommandable;
    
    public ModeleVelo(String model,    int quantiteMaximumCommandable) {
        this.model = model;
        this.quantiteMaximumCommandable = quantiteMaximumCommandable;
    }
    
}

On crée alors un tableau de type ModeleVelo (eh oui, vous en avez le droit car maintenant ModeleVelo est un type reconnu pour votre programme.) dans la classe EcranCommande :

Sélectionnez

    ModeleVelo modelesDisponibles[] = {
            new ModeleVelo("BikeMike 500", 5),
            new ModeleVelo("RideAMax 130", 2),
            new ModeleVelo("BigRace 200", 8),
            new ModeleVelo("TrickyCourt 820", 7),
            new ModeleVelo("MaxiRide 20", 3),
            new ModeleVelo("RidersHeaven 760", 9),
    };

Cette construction vous semble bizarre ? Pourtant elle est correcte : souvenez-vous que vous n'êtes pas obligés de conserver une référence sur l'objet créé avec new. Ici le tableau, dont on a conservé une référence, s'en chargera pour nous.

Pour tester si un modèle fait partie de la liste, il suffira donc d'exécuter une boucle for (ou for each) sur tout le tableau :

Sélectionnez

        String modeleRecherche = "BikeMike 500";
        for (ModeleVelo modeleCourant : modelesDisponibles){
            if (modeleRecherche.equals(modeleCourant.modele)){
                /* 
                 * Faire ce que l'on veut faire avec modeleCourant :
                 * c'est l'objet ModeleVelo correspondant au nom
                 * de modele recherche.
                 */
            }
        }

Enfin, il ne faut pas oublier d'ajouter une méthode main(). On y créera une instance d'EcranCommande et on l'affichera.

VII-A-6. Code complet de la classe EcranCommande▲

CommandeVelosPremiereVersion

Cacher/Afficher le codeSélectionnez

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

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

class EcranCommandePremiereVersion extends JFrame implements ActionListener {
    
    JTextField champTexteModele, champTexteQuantite,
    champTexteConfirmationCommande;
    JLabel labelModele, labelQuantite, labelConfirmationCommande;
    JButton boutonValidation;
    ModeleVelo modelesDisponibles[] = {
            /*
             * Nul besoin de stocker la reference
             * sur chaque objet du tableau.
             */
            new ModeleVelo("BikeMike 500", 5),
            new ModeleVelo("RideAMax 130", 2),
            new ModeleVelo("BigRace 200", 8),
            new ModeleVelo("TrickyCourt 820", 7),
            new ModeleVelo("MaxiRide 20", 3),
            new ModeleVelo("RidersHeaven 760", 9),
    };
    
    public EcranCommandePremiereVersion(){
        // titre
        setTitle("Commande de velos");
        // centrer la fenetre sur l'ecran
        setLocationRelativeTo(null);
        // on quitte l'application si la fenetre est fermee
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel panneauInterne = new JPanel();
        // La couleur de fond du panneau sera rose.
        panneauInterne.setBackground(Color.PINK);
        /*
         * Il y aura toujours 5 pixels d'espaces entre
         * les composants : que ce soit en largeur ou
         * en hauteur.
         */
        panneauInterne.setLayout(new GridLayout(4,2, 5,5));
        // Un JTextField avec 30 colonnes affichees.
        labelModele = new JLabel("Modele de velo : ");
        panneauInterne.add(labelModele);
        champTexteModele = new JTextField(30);
        panneauInterne.add(champTexteModele);
        labelQuantite = new JLabel("Quantite : ");
        panneauInterne.add(labelQuantite);
        champTexteQuantite = new JTextField(30);
        panneauInterne.add(champTexteQuantite);
        labelConfirmationCommande = new JLabel("Commande confirmee ? ");
        panneauInterne.add(labelConfirmationCommande);
        champTexteConfirmationCommande = new JTextField(30);
        panneauInterne.add(champTexteConfirmationCommande);
        boutonValidation = new JButton("Passer la commande");
        panneauInterne.add(boutonValidation);
        
        boutonValidation.addActionListener(this);
        
        add(panneauInterne);
        /*
         *  La fenetre aura juste la taille
         *  qui lui laisse placer tous ses composants :
         *  donc la taille qui laisse le panneauInterne
         *  placer tous ses composants.
         */
        pack();
    }
    
    public void actionPerformed(ActionEvent evt) {
        // L'utilisateur a clique sur le bouton Commander
        String modeleChoisi = champTexteModele.getText();
        String quantiteChoisie = champTexteQuantite.getText();
        int quantite = Integer.parseInt(quantiteChoisie);
        try {
            verifierCommande(modeleChoisi, quantite);
            // Cette ligne sera sautee en cas d'exception
            champTexteConfirmationCommande.setText(
                    "Votre commande est prete.");
        } catch(TropDeVelosException e) {
            champTexteConfirmationCommande.setText(e.getMessage());
        } catch(Exception e){
            champTexteConfirmationCommande.setText(e.getMessage());
        }
    }
    void verifierCommande(String modeleVelo, int quantite)
            throws TropDeVelosException,Exception {
        ModeleVelo modeleCorrepondant = null;
        for (ModeleVelo modeleCourant : modelesDisponibles){
            if (modeleVelo.equals(modeleCourant.model)){
                modeleCorrepondant = modeleCourant;
                break;
            }
        }
        if (modeleCorrepondant == null)
            throw new Exception("Le modele "+modeleVelo+" n'existe pas.");
        if (quantite > modeleCorrepondant.quantiteMaximumCommandable)
            throw new TropDeVelosException ("Impossible de livrer " + quantite + " velos du modele " + modeleVelo + " en une fois.");
    }
    
    public static void main(String[] args) {
        /*
         *  Pas besoin de stocker une reference
         *  sur la fenetre cree : elle sera automatiquement
         *  detruite en quittant l'application.
         */
        new EcranCommandePremiereVersion().setVisible(true);
    }
}

Voici un aperçu de la nouvelle interface :

Si le modèle de vélo entré n'est pas reconnu, le champ "Commande confirmée ?" indique "Le modèle de vélo n'existe pas.".

Si le modèle de vélo entré est reconnu et la quantité commandée acceptable, l'interface renvoie le message : "Votre commande est prête.".

Toutefois, si la commande excède la limite autorisée pour le modèle, un message d'erreur sera affiché. Un message du genre : " Impossible de livrer six vélos du modèle BikeMike 500 en une seule commande. ".

VII-B. Exercices pour les petits malins : liste déroulante▲

VII-B-1. Construire l'objet JComboBox▲

Il y a plusieurs manières pour initialiser et remplir un JComboBox. On peut utiliser le constructeur par défaut et ensuite, remplir la liste en ajoutant les éléments un par un.

Mais il y a un moyen de réutiliser, presque directement, le tableau de ModeleVelo que nous avons employé précédemment. Pour cela j'utilise le constructeur :

Sélectionnez

JComboBox(ComboBoxModel aModel)

Ce constructeur va nous permettre de lui passer un DefaultComboBoxModel. Cette dernière classe nous permet simplement d'initialiser la liste avec un tableau d'Object (c'est-à-dire avec toute classe existante, car toute classe hérite de Object). Voici son constructeur :

Sélectionnez

DefaultComboBoxModel(Object[] items)

Pour créer et initialiser notre liste en même temps, il nous suffira donc d'écrire :

Sélectionnez

new JComboBox(new DefaultComboBoxModel(modelesDisponibles));

VII-B-2. La méthode toString() de tout objet et nouvelle version de la classe ModeleVelo▲

Toute classe hérite de la classe Object. Et la classe Object définit un certain nombre de méthodes, qui peuvent donc être surchargées (souvenez-vous de la méthode dire() créée dans la classe Poisson du chapitre 3 : elle surcharge celle de la classe AnimalFamilier).

Parmi elles, la méthode toString(), destinée à donner une description de l'objet en question. Si pour certaines classes cette méthode donne une indication précise sur la valeur de l'objet (et éventuellement sa classe), cela ne sera pas le cas pour la majorité. Au contraire, on obtiendra quelque chose contenant beaucoup de caractères étranges.

Et quand le JComboBox stocke des objets (et non de simples types primitifs), il se base sur le texte renvoyé par la méthode toString() de ces objets. C'est pourquoi vous obtiendrez un texte bizarre en lieu et place des différentes possibilités de la liste, si vous lancez l'application.

Néanmoins, on a la possibilité, si on le désire, de remplacer cette description rébarbative, par une chaine beaucoup plus élégante. Pour cela, il suffit de surcharger la méthode toString().

Vous l'aurez certainement compris, nous allons surcharger la méthode toString() de la classe ModeleVelo afin qu'elle renvoie le modèle du vélo.

ModeleVelo (nouvelle version)

Sélectionnez

public class NouveauModeleVelo {

    String modele;
    int quantiteMaximumCommandable;
    
    public NouveauModeleVelo(String modele,    int quantiteMaximumCommandable) {
        this.modele = modele;
        this.quantiteMaximumCommandable = quantiteMaximumCommandable;
    }
    
    public String toString(){
        return modele;
    }
    
}

C'est aussi simple que cela.

Maintenant il faut savoir comment réagir quand l'utilisateur change l'élément sélectionné dans la liste.

VII-B-3. L'interface ItemListener et la nouvelle version de EcranCommande▲

L'interface ItemListener est l'interface à utiliser pour tout objet devant être informé quand la sélection d'un JComboBox est modifiée. Elle ne comporte qu'une méthode de signature :

Sélectionnez

void itemStateChanged(ItemEvent e)

On obtient alors un objet ItemEvent, qui nous renseigne sur différents aspects de l'évènement. Notamment sur l'objet qui a été sélectionné. Pour cela on fera appel à la méthode getItem() de la classe ItemEvent :

Sélectionnez

Object getItem()

On obtient une instance de Object, un cast sera donc nécessaire.

On peut donc :

créer une variable de classe qui servira à renseigner sur le dernier modèle sélectionné : modeleCourant. On l'initialisera avec le modèle qui sera affiché au lancement de l'application : c'est-à-dire le 1er modèle de la liste ;
mettre à jour cette variable dans l'écouteur de type ItemListener ;
définir la classe EcranCommande elle-même comme écouteur de type ItemListener.

Évidemment, il y a encore de petits ajustements à faire dans EcranCommande :

dans la méthode actionPerformed(), la variable modeleChoisi ne sert plus ;
on n'a plus besoin de la version verifierCommande() à deux paramètres : mais on peut la surcharger avec une version ne prenant que la quantité demandée.

Ce qui nous donne donc :

EcranCommande (nouvelle version)

Cacher/Afficher le codeSélectionnez

import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

class EcranCommandeDeuxiemeVersion extends JFrame implements ActionListener, ItemListener {
    
    JComboBox champListeModele;
    JTextField champTexteQuantite, champTexteConfirmationCommande;
    JLabel labelModele, labelQuantite, labelConfirmationCommande;
    JButton boutonValidation;
    NouveauModeleVelo modelesDisponibles[] = {
            /*
             * Nul besoin de stocker la reference
             * sur chaque objet du tableau.
             */
            new NouveauModeleVelo("BikeMike 500", 5),
            new NouveauModeleVelo("RideAMax 130", 2),
            new NouveauModeleVelo("BigRace 200", 8),
            new NouveauModeleVelo("TrickyCourt 820", 7),
            new NouveauModeleVelo("MaxiRide 20", 3),
            new NouveauModeleVelo("RidersHeaven 760", 9),
    };
    NouveauModeleVelo modeleCourant = modelesDisponibles[0];
    
    public EcranCommandeDeuxiemeVersion(){
        // titre
        setTitle("Commande de velos");
        // centrer la fenetre sur l'ecran
        setLocationRelativeTo(null);
        // on quitte l'application si la fenetre est fermee
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        JPanel panneauInterne = new JPanel();
        // La couleur de fond du panneau sera rose.
        panneauInterne.setBackground(Color.PINK);
        /*
         * Il y aura toujours 5 pixels d'espaces entre
         * les composants : que ce soit en largeur ou
         * en hauteur.
         */
        panneauInterne.setLayout(new GridLayout(4,2, 5,5));
        // Un JTextField avec 30 colonnes affichees.
        labelModele = new JLabel("Modele de velo : ");
        panneauInterne.add(labelModele);
        champListeModele = new JComboBox(new DefaultComboBoxModel(modelesDisponibles));
        panneauInterne.add(champListeModele);
        labelQuantite = new JLabel("Quantite : ");
        panneauInterne.add(labelQuantite);
        champTexteQuantite = new JTextField(30);
        panneauInterne.add(champTexteQuantite);
        labelConfirmationCommande = new JLabel("Commande confirmee ? ");
        panneauInterne.add(labelConfirmationCommande);
        champTexteConfirmationCommande = new JTextField(30);
        panneauInterne.add(champTexteConfirmationCommande);
        boutonValidation = new JButton("Passer la commande");
        panneauInterne.add(boutonValidation);
        
        boutonValidation.addActionListener(this);
        champListeModele.addItemListener(this);
        
        add(panneauInterne);
        /*
         *  La fenetre aura juste la taille
         *  qui lui laisse placer tous ses composants :
         *  donc la taille qui laisse le panneauInterne
         *  placer tous ses composants.
         */
        pack();
    }
    
    public void actionPerformed(ActionEvent evt) {
        // L'utilisateur a clique sur le bouton Commander
        String quantiteChoisie = champTexteQuantite.getText();
        int quantite = Integer.parseInt(quantiteChoisie);
        try {
            verifierCommandeDuModeleCourant(quantite);
            // Cette ligne sera sautee en cas d'exception
            champTexteConfirmationCommande.setText(
                    "Votre commande est prete.");
        } catch(TropDeVelosException e) {
            champTexteConfirmationCommande.setText(e.getMessage());
        } catch(Exception e){
            champTexteConfirmationCommande.setText(e.getMessage());
        }
    }
    
    public void itemStateChanged(ItemEvent evt) {
        Object objetSelectionne = evt.getItem();
        if (objetSelectionne instanceof NouveauModeleVelo)
            modeleCourant = (NouveauModeleVelo) objetSelectionne;
    }
    
    /*
     * Cette version est devenue inutile
     */
    void verifierCommande(String modeleVelo, int quantite)
            throws TropDeVelosException,Exception {
        NouveauModeleVelo modeleCorrepondant = null;
        for (NouveauModeleVelo modeleCourant : modelesDisponibles){
            if (modeleVelo.equals(modeleCourant.modele)){
                modeleCorrepondant = modeleCourant;
                break;
            }
        }
        if (modeleCorrepondant == null)
            throw new Exception("Le modele "+modeleVelo+" n'existe pas.");
        if (quantite > modeleCorrepondant.quantiteMaximumCommandable)
            throw new TropDeVelosException ("Impossible de livrer " +
                quantite + " velos du modele " + modeleVelo +
                " en une fois.");
    }
    
    void verifierCommandeDuModeleCourant(int quantite)
            throws TropDeVelosException, Exception{
        if (modeleCourant == null)
            throw new Exception("Erreur : aucun modele choisi.");
        if (quantite > modeleCourant.quantiteMaximumCommandable)
            throw new TropDeVelosException ("Impossible de livrer " +
                quantite + " velos du modele " + modeleCourant.modele +
                " en une fois.");
    }
    
    public static void main(String[] args) {
        /*
         *  Pas besoin de stocker une reference
         *  sur la fenetre cree : elle sera automatiquement
         *  detruite en quittant l'application.
         */
        new EcranCommandeDeuxiemeVersion().setVisible(true);
    }
}

Voici un aperçu de la nouvelle interface (le comportement reste le même).

VII-C. Synthèse▲

Les exercices de ce chapitre vous ont permis :

de construire votre propre exception, en héritant de la classe Exception ;
de créer un tableau contenant vos propres objets ;
de construire une liste déroulante, la remplir et réagir quand l'utilisateur en change l'élément choisit ;
de profiter du potentiel offert par la méthode toString(), en la redéfinissant.

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 Laurent Bernabé. 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.