Chapitre 6  Programmation (un peu) plus avancée

Amis, ne creusez pas vos chères rêveries ;
Ne fouillez pas le sol de vos plaines fleuries ;
Et, quand s'offre à vos yeux un océan qui dort,
Nagez à la surface ou jouez sur le bord.
Car la pensée est sombre ! Une pente insensible
Va du monde réel à la sphère invisible ;
La spirale est profonde, et quand on y descend
Sans cesse se prolonge et va s'élargissant,
Et pour avoir touché quelque énigme fatale,
De ce voyage obscur souvent on revient pâle ! Victor Hugo

6.1  Portée

    public void supprimer(CompteBancaire c) {
        boolean trouvé = false;  // rien trouvé pour l'instant
        int indice = 0;
        for (int i = 0 ; i < nbComptes ; i++) {
            if (tabComptes[i] == c) { // attention comparaison de références
                trouvé = true; // j'ai trouvé
                indice = i;    // mémoriser l'indice
                break;         // plus besoin de continuer la recherche
            }
        }
        if (trouvé) {
            // Décaler le reste du tableau vers la gauche
            // On "écrase" ainsi le compte à supprimer
            for (int i = indice+1 ; i < nbComptes ; i++) {
                tabComptes[i-1] = tabComptes[i];
            }
            // Mettre à jour le nombre de comptes
            nbComptes--;
        }
        else {
            // Message d'erreur si on n'a rien trouvé
            System.out.println("Je n'ai pas trouvé ce compte");
        }
    }

• La variable booléenne trouvé existe tout au long de cette méthode ; elle est donc créée quand la méthode est lancée, et détruite à la sortie de la méthode.
• Il y a deux variables entières nommées i, qui sont créées chacune à un moment différent et qui n'existent qu'au sein du bloc dans lequel elles ont été déclarées. Les deux blocs correspondants sont :

          for (int i = 0 ; i < nbComptes ; i++) {
              if (tabComptes[i] == c) { // attention comparaison de références
                  trouvé = true; // j'ai trouvé
                  indice = i;    // mémoriser l'indice
                  break;         // plus besoin de continuer la recherche
              }
          }
    

  et

              for (int i = indice+1 ; i < nbComptes ; i++) {
                  tabComptes[i-1] = tabComptes[i];
              }
    

6.2  Espaces de nommage : les packages

package fr.inpl-nancy.mines.tombre.ens.cours1A.banque;

public class Banque {
    ...

fr/inpl-nancy/mines/tombre/ens/cours/cours1A/banque/

import java.io.*;

public class Utils {
    public static String lireChaine(String question) {
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ir);
        ...

6.3  Entrées/sorties

• On peut lire au clavier et écrire sur l'écran, mais aussi sur une imprimante ; on peut lire et écrire à partir d'un fichier, ou d'une adresse mémoire correspondant à un flux de données en provenance d'un réseau par exemple, etc.
• On peut avoir envie de lire ou écrire des caractères (en Java, souvenez-vous qu'ils sont représentés sur 2 octets), ou un flot d'octets, ou des objets plus structurés.
• On peut avoir des entrées et sorties "bufferisées", c'est-à-dire gérées ligne par ligne. C'est typiquement le cas dans des programmes interactifs simples, où vous saisissez vos réponses au programme au clavier, en souhaitant qu'elles ne soient prises en compte qu'une fois que vous tapez "Entrée". Jusque là, vous êtes libres de revenir en arrière, d'effacer un caractère, etc. Les caractères que vous saisissez sont stockés dans une zone tampon (un buffer -- d'où le nom). Dans d'autres cas, au contraire, on ne veut surtout pas que le caractère "Entrée" ait une signification particulière ; dans les flots à partir de fichiers, par exemple, on veut prendre en compte et traiter immédiatement chaque caractère entré (imaginez qu'on vous demande d'écrire un traitement de texte...)

6.3.1  L'explication d'un mystère

• println pour écrire une chaîne de caractères (String) en vidant le buffer, et passer à la ligne,
• print qui fait la même chose sans passer à la ligne, c'est-à-dire en écrivant dans le buffer,
• flush qui force l'affichage du buffer de sortie sans qu'il y ait eu de retour à la ligne.

    public static String lireChaine(String question) {
        InputStreamReader ir = new InputStreamReader(System.in);

        BufferedReader br = new BufferedReader(ir);

        System.out.print(question);
        System.out.flush();

        String reponse = "";
        try {
            reponse = br.readLine();
        } catch (IOException ioe) {}
        return reponse;
    }

6.3.2  Les fichiers

1. Les considérations générales de la gestion des entrées-sorties, dans la mesure où la lecture ou l'écriture dans un fichier n'est en fait qu'un flot parmi d'autres. Nous avons déjà vu que nous disposons dans la hiérarchie des classes du package java.io des classes FileReader et FileWriter pour lire et écrire des flots de caractères dans des fichiers, et de FileInputStream et FileOutputStream pour les flots d'octets.
2. L'établissement d'un lien avec le système de fichiers sous-jacent, tout en restant indépendant de la plateforme. Cet aspect est pris en compte par la classe File.

File fich = new File("comptes.dat");

if (!fich.exists()) {
    FileOutputStream fp = new FileOutputStream("comptes.dat");
    fich = new File("comptes.dat");
}

BufferedWriter bw = null;
try {
    if (fich.canWrite()) {
        FileWriter fw = new FileWriter(f);
        bw = new BufferedWriter(fw);
    }
}
catch (IOException ioe) {}

try {
    bw.write("Karl Tombre");
    bw.newLine();
    bw.write("Sornéville");
    bw.newLine();
}
catch (IOException ioe) {}

try {
    Integer i = new Integer(numéro);
    bw.write(i.toString());
    bw.newLine();
    i = new Integer(solde);
    bw.write(i.toString());
    bw.newLine();
}
catch (IOException ioe) {}

bw.close();

// Classe Utils - version 2.0

/**
 *  Classe regroupant les utilitaires disponibles pour les exercices
 * de 1ere année du tronc commun informatique.
 * @author Karl Tombre
 */

import java.io.*;

public class Utils {
    // Les fonctions lireChaine et lireEntier
    // Exemple d'utilisation dans une autre classe :
    // String nom = Utils.lireChaine("Entrez votre nom : ");
    public static String lireChaine(String question) {
        InputStreamReader ir = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(ir);
        
        System.out.print(question);
        System.out.flush();
        return loadString(br);
    }

    // La lecture d'un entier n'est qu'un parseInt de plus !!
    public static int lireEntier(String question) {
        return Integer.parseInt(lireChaine(question));
    }

    // écriture d'une chaîne dans un BufferedWriter
    public static void saveString(BufferedWriter bw, String s) {
        try {
            bw.write(s);
            bw.newLine();
        }
        catch (IOException ioe) {}
    }

    // écriture d'un entier : on convertit en chaîne et on se ramène
    // à la procédure précédente
    public static void saveInt(BufferedWriter bw, int i) {
        Integer q = new Integer(i);
        saveString(bw, q.toString());
    }

    // ouverture en écriture d'un fichier
    // rend un BufferedWriter -- null si pas possible de l'ouvrir
    public static BufferedWriter openWriteFile(File f) {
        BufferedWriter bw = null;
        try {
            if (f.canWrite()) {
                FileWriter fw = new FileWriter(f);
                bw = new BufferedWriter(fw);
            }
        }
        catch (IOException ioe) {}
        return bw;
    }

    // ouverture en lecture d'un fichier
    // rend un BufferedReader -- null si pas possible de l'ouvrir
    public static BufferedReader openReadFile(File f) {
        BufferedReader br = null;
        try {
            if (f.canRead()) {
                FileReader fr = new FileReader(f);
                br = new BufferedReader(fr);
            }
        }
        catch (IOException ioe) {}
        return br;
    }

    // lecture dans un BufferedReader d'une chaîne de caractères
    public static String loadString(BufferedReader br) {
        String s = "";
        try {
            s = br.readLine();
        }
        catch (IOException ioe) {}
        return s;
    }

    // lecture d'un entier dans un BufferedReader
    public static int loadInt(BufferedReader br) {
        return Integer.parseInt(loadString(br));
    }
}

// Classe CompteBancaire - version 3.1

import java.io.*;

/**
 * Classe abstraite représentant un compte bancaire et les méthodes qui lui
 * sont associées.
 * @author Karl Tombre
 */

public abstract class CompteBancaire {
    private String nom;       // le nom du client
    private String adresse;   // son adresse
    private int numéro;       // numéro du compte
    protected int solde;      // solde du compte

    // Variable de classe
    public static int premierNuméroDisponible = 1;
    
    // Constructeur : on reçoit en paramètres les valeurs du nom et
    // de l'adresse, on met le solde à 0 par défaut, et on récupère
    // automatiquement un numéro de compte
    CompteBancaire(String unNom, String uneAdresse) {
        nom = unNom;
        adresse = uneAdresse;
        numéro = premierNuméroDisponible;
        solde = 0;
        // Incrémenter la variable de classe
        premierNuméroDisponible++;
    }

    // Constructeur par défaut, sans paramètres
    CompteBancaire() {
        nom = "";
        adresse = "";
        numéro = 0;
        solde = 0;
    }

    // Les méthodes
    public void créditer(int montant) {
        solde += montant;
    }
    public void débiter(int montant) {
        solde -= montant;
    }
    public void afficherEtat() {
        System.out.println("Compte numéro " + numéro + 
                           " ouvert au nom de " + nom);
        System.out.println("Adresse du titulaire : " + adresse);
        System.out.println("Le solde actuel du compte est de " +
                           solde + " euros.");
        System.out.println("************************************************");
    }
    // Accès en lecture
    public String nom() {
        return this.nom;
    }
    public String adresse() {
        return this.adresse;
    }

    // méthode abstraite, doit être implantée dans les sous-classes
    // traitement quotidien appliqué au compte par un gestionnaire de comptes
    public abstract void traitementQuotidien();

    // sauvegarde du compte dans un BufferedWriter
    public void save(BufferedWriter bw) {
        Utils.saveString(bw, nom);
        Utils.saveString(bw, adresse);
        Utils.saveInt(bw, numéro);
        Utils.saveInt(bw, solde);
    }

    // chargement du compte à partir d'un BufferedReader
    public void load(BufferedReader br) {
        nom = Utils.loadString(br);
        adresse = Utils.loadString(br);
        numéro = Utils.loadInt(br);
        solde = Utils.loadInt(br);
    }
}

// Classe CompteDepot - version 1.1

import java.io.*;

/**
 * Classe représentant un compte de dépôt, sous-classe de CompteBancaire.
 * @author Karl Tombre
 */

public class CompteDepot extends CompteBancaire {
    private double tauxAgios;   // taux quotidien des agios

    // Constructeur
    CompteDepot(String unNom, String uneAdresse, double unTaux) {
        // on crée déjà la partie commune
        super(unNom, uneAdresse);
        // puis on initialise le taux des agios
        tauxAgios = unTaux;
    }

    // Constructeur par défaut
    CompteDepot() {
        super();
        tauxAgios = 0.0;
    }

    // Méthode redéfinie : l'affichage
    public void afficherEtat() {
        System.out.println("Compte de dépôts");
        super.afficherEtat(); // appeler la méthode de même nom dans la superclasse
    }
    
    // Définition de la méthode de traitementQuotidien
    public void traitementQuotidien() {
        if (solde < 0) {
            débiter((int) (-1.0 * (double) solde * tauxAgios));
        }
    }
    // sauvegarde du compte dans un BufferedWriter
    public void save(BufferedWriter bw) {
        super.save(bw);
        Double d = new Double(tauxAgios);
        Utils.saveString(bw, d.toString());
    }

    // chargement du compte à partir d'un BufferedReader
    public void load(BufferedReader br) {
        super.load(br);
        tauxAgios = Double.valueOf(Utils.loadString(br)).doubleValue();
    }
}

// Classe CompteEpargne - version 1.1

import java.io.*;

/**
 * Classe représentant un compte d'épargne, sous-classe de CompteBancaire.
 * @author Karl Tombre
 */

public class CompteEpargne extends CompteBancaire {
    private double tauxIntérêts;   // taux d'intérêts par jour

    // Constructeur
    CompteEpargne(String unNom, String uneAdresse, double unTaux) {
        // on crée déjà la partie commune
        super(unNom, uneAdresse);
        // puis on initialise le taux d'intérêt
        tauxIntérêts = unTaux;
    }

    // Constructeur par défaut
    CompteEpargne() {
        super();
        tauxIntérêts = 0.0;
    }

    // Méthode redéfinie : l'affichage
    public void afficherEtat() {
        System.out.println("Compte d'épargne");
        super.afficherEtat(); // appeler la méthode de même nom dans la superclasse
    }

    // Méthode redéfinie : débiter -- interdit de passer en-dessous de 0
    public void débiter(int montant) {
        if (montant <= solde) {
            solde -= montant;
        }
        else {
            System.out.println("Débit non autorisé");
        }
    }
    
    // Définition de la méthode de traitementQuotidien
    public void traitementQuotidien() {
        créditer((int) ((double) solde * tauxIntérêts));
    }
    // sauvegarde du compte dans un BufferedWriter
    public void save(BufferedWriter bw) {
        super.save(bw);
        Double d = new Double(tauxIntérêts);
        Utils.saveString(bw, d.toString());
    }

    // chargement du compte à partir d'un BufferedReader
    public void load(BufferedReader br) {
        super.load(br);
        tauxIntérêts = Double.valueOf(Utils.loadString(br)).doubleValue();
    }
}

// Interface ListeDeComptes - version 1.1

import java.io.*;

/**
 * Interface représentant une liste de comptes et les opérations
 * que l'on souhaite effectuer sur cette liste
 * @author Karl Tombre
 */

public interface ListeDeComptes {
    // Récupérer un compte à partir d'un nom donné
    public CompteBancaire trouverCompte(String nom);
    // Ajout d'un nouveau compte
    public void ajout(CompteBancaire c);
    // Suppression d'un compte 
    public void supprimer(CompteBancaire c);
    // Afficher l'état de tous les comptes
    public void afficherEtat();
    // Traitement quotidien de tous les comptes
    public void traitementQuotidien();
    // Sauvegarder dans un fichier
    public void sauvegarder(File f);
    // Charger à partir d'un fichier
    public void charger(File f);
}

// Classe AgenceBancaire - version 1.3

import java.io.*;

/**
 * Classe représentant une agence bancaire et les méthodes qui lui
 * sont associées.
 * @author Karl Tombre
 */

public class AgenceBancaire implements ListeDeComptes {
    private CompteBancaire[] tabComptes;  // le tableau des comptes
    private int capacitéCourante;         // la capacité du tableau
    private int nbComptes;                // le nombre effectif de comptes

    // Constructeur -- au moment de créer une agence, on crée un tableau
    // de capacité initiale 10, mais qui ne contient encore aucun compte
    AgenceBancaire() {
        tabComptes = new CompteBancaire[10];
        capacitéCourante = 10;
        nbComptes = 0;
    }

    // Méthode privée utilisée pour incrémenter la capacité
    private void augmenterCapacité() {
        // Incrémenter la capacité de 10
        capacitéCourante += 10;
        // Créer un nouveau tableau plus grand que l'ancien
        CompteBancaire[] tab = new CompteBancaire[capacitéCourante];
        // Recopier les comptes existants dans ce nouveau tableau
        for (int i = 0 ; i < nbComptes ; i++) {
            tab[i] = tabComptes[i];
        }
        // C'est le nouveau tableau qui devient le tableau des comptes
        // (l'ancien sera récupéré par le ramasse-miettes)
        tabComptes = tab;
    }

    // Les méthodes de l'interface
    // Ajout d'un nouveau compte
    public void ajout(CompteBancaire c) {
        if (nbComptes == capacitéCourante) { // on a atteint la capacité max
            augmenterCapacité();
        }
        // Maintenant je suis sûr que j'ai de la place
        // Ajouter le nouveau compte dans la première case vide
        // qui porte le numéro nbComptes !
        tabComptes[nbComptes] = c;
        // On prend note qu'il y a un compte de plus
        nbComptes++;
    }
    // Récupérer un compte à partir d'un nom donné
    public CompteBancaire trouverCompte(String nom) {
        boolean trouvé = false;  // rien trouvé pour l'instant
        int indice = 0;
        for (int i = 0 ; i < nbComptes ; i++) {
            if (nom.equalsIgnoreCase(tabComptes[i].nom())) {
                trouvé = true; // j'ai trouvé
                indice = i;    // mémoriser l'indice
                break;         // plus besoin de continuer la recherche
            }
        }
        if (trouvé) {
            return tabComptes[indice];
        }
        else {
            return null;  // si rien trouvé, je rend la référence nulle
        }
    }
    // Afficher l'état de tous les comptes
    public void afficherEtat() {
        // Il suffit d'afficher l'état de tous les comptes de l'agence
        for (int i = 0 ; i < nbComptes ; i++) { 
            tabComptes[i].afficherEtat();
        }
    }

    // Traitement quotidien de tous les comptes
    public void traitementQuotidien() {
        for (int i = 0 ; i < nbComptes ;i++) {
            tabComptes[i].traitementQuotidien();
        }
    }

    // Suppression d'un compte
    public void supprimer(CompteBancaire c) {
        boolean trouvé = false;  // rien trouvé pour l'instant
        int indice = 0;
        for (int i = 0 ; i < nbComptes ; i++) {
            if (tabComptes[i] == c) { // attention comparaison de références
                trouvé = true; // j'ai trouvé
                indice = i;    // mémoriser l'indice
                break;         // plus besoin de continuer la recherche
            }
        }
        if (trouvé) {
            // Décaler le reste du tableau vers la gauche
            // On "écrase" ainsi le compte à supprimer
            for (int i = indice+1 ; i < nbComptes ; i++) {
                tabComptes[i-1] = tabComptes[i];
            }
            // Mettre à jour le nombre de comptes
            nbComptes--;
        }
        else {
            // Message d'erreur si on n'a rien trouvé
            System.out.println("Je n'ai pas trouvé ce compte");
        }
    }

    public void sauvegarder(File f) {
        BufferedWriter bw = Utils.openWriteFile(f);

        if (bw != null) {
            Utils.saveInt(bw, nbComptes);

            // Sauvegarder la variable de classe
            Utils.saveInt(bw, CompteBancaire.premierNuméroDisponible);

            for (int i = 0 ; i < nbComptes ; i++) {
                Class typeDeCompte = tabComptes[i].getClass();
                Utils.saveString(bw, typeDeCompte.getName());
                tabComptes[i].save(bw);
            }

            try {
                bw.close();
            }
            catch (IOException ioe) {}
            System.out.println("Sauvegarde effectuée");
        }
        else {
            System.out.println("Impossible de sauvegarder");
        }
    }

    public void charger(File f) {
        BufferedReader br = Utils.openReadFile(f);
        if (br != null) {
            nbComptes = Utils.loadInt(br);
            CompteBancaire.premierNuméroDisponible = Utils.loadInt(br);

            for (int i = 0 ; i < nbComptes ; i++) {
                try {
                    Class typeDeCompte = Class.forName(Utils.loadString(br));
                    tabComptes[i] = (CompteBancaire) typeDeCompte.newInstance();
                    tabComptes[i].load(br);
                }
                catch(ClassNotFoundException cnfe) {}
                catch(IllegalAccessException iae) {}
                catch(InstantiationException ie) {}
            }
            try {
                br.close();
            }
            catch (IOException ioe) {}
            System.out.println("Comptes chargés");
        }
        else {
            System.out.println("Impossible de charger la sauvegarde");
        }
    }
}

// Classe Banque - version 4.3

import java.io.*;
/**
 * Classe contenant un programme de gestion bancaire, utilisant
 * un objet de type AgenceBancaire
 * @author Karl Tombre
 * @see    ListeDeComptes, CompteBancaire, Utils
 */

public class Banque {
    public static void main(String[] args) {
        ListeDeComptes monAgence = new AgenceBancaire();
        File fich = new File("comptes.dat");
        // On commence par charger le fichier de sauvegarde éventuel
        monAgence.charger(fich);

        while (true) { // boucle infinie dont on sort par un break
          // ... la même chose qu'avant
        }
        // Quand on sort de la boucle, afficher l'état global de l'agence
        System.out.println("Voici le nouvel état des comptes de l'agence");
        monAgence.afficherEtat();
        System.out.println("-----------------------------------");
        System.out.println("On applique un traitement quotidien");
        System.out.println("-----------------------------------");
        monAgence.traitementQuotidien();
        monAgence.afficherEtat();

        // Et on termine par une sauvegarde
        try {
            fich = new File("comptes.dat");
            if (!fich.exists()) {
                // Si le fichier n'existe pas, le créer
                FileOutputStream fp = new FileOutputStream("comptes.dat");
                fich = new File("comptes.dat");
            }
            monAgence.sauvegarder(fich);
        }
        catch (IOException ioe) {}
    }
}

Impossible de charger la sauvegarde
Donnez le nom du client (rien=exit) : \emph{Karl Tombre}
Ce compte n'existe pas, nous allons le créer
Adresse = \emph{Sornéville}
Compte de [D]épôt (défaut) ou d'[E]pargne ? \emph{E}
Votre choix : [D]ébit, [C]rédit, [S]upprimer ? \emph{C}
Montant à créditer = \emph{10000}
Compte d'épargne
Compte numéro 1 ouvert au nom de Karl Tombre
Adresse du titulaire : Sornéville
Le solde actuel du compte est de 10000 euros.
************************************************
Donnez le nom du client (rien=exit) : \emph{Luigi Liquori}
Ce compte n'existe pas, nous allons le créer
Adresse = \emph{Bari}
Compte de [D]épôt (défaut) ou d'[E]pargne ? \emph{D}
Votre choix : [D]ébit, [C]rédit, [S]upprimer ? \emph{D}
Montant à débiter = \emph{20000}
Compte de dépôts
Compte numéro 2 ouvert au nom de Luigi Liquori
Adresse du titulaire : Bari
Le solde actuel du compte est de -20000 euros.
************************************************
Donnez le nom du client (rien=exit) : 
Voici le nouvel état des comptes de l'agence
Compte d'épargne
Compte numéro 1 ouvert au nom de Karl Tombre
Adresse du titulaire : Sornéville
Le solde actuel du compte est de 10000 euros.
************************************************
Compte de dépôts
Compte numéro 2 ouvert au nom de Luigi Liquori
Adresse du titulaire : Bari
Le solde actuel du compte est de -20000 euros.
************************************************
-----------------------------------
On applique un traitement quotidien
-----------------------------------
Compte d'épargne
Compte numéro 1 ouvert au nom de Karl Tombre
Adresse du titulaire : Sornéville
Le solde actuel du compte est de 10001 euros.
************************************************
Compte de dépôts
Compte numéro 2 ouvert au nom de Luigi Liquori
Adresse du titulaire : Bari
Le solde actuel du compte est de -20008 euros.
************************************************
Sauvegarde effectuée

2
3
CompteEpargne
Karl Tombre
Sornéville
1
10001
1.5E-4
CompteDepot
Luigi Liquori
Bari
2
-20008
4.1E-4

Comptes chargés
Donnez le nom du client (rien=exit) : \emph{Karl tOmbre}
Votre choix : [D]ébit, [C]rédit, [S]upprimer ? \emph{d}
Montant à débiter = \emph{10000}
Compte d'épargne
Compte numéro 1 ouvert au nom de Karl Tombre
Adresse du titulaire : Sornéville
Le solde actuel du compte est de 1 euros.
************************************************
Donnez le nom du client (rien=exit) : \emph{Jacques Jaray}
Ce compte n'existe pas, nous allons le créer
Adresse = \emph{Laxou}
Compte de [D]épôt (défaut) ou d'[E]pargne ? \emph{E}
Votre choix : [D]ébit, [C]rédit, [S]upprimer ? \emph{C}
Montant à créditer = \emph{100}
Compte d'épargne
Compte numéro 1 ouvert au nom de Jacques Jaray
Adresse du titulaire : Laxou
Le solde actuel du compte est de 100 euros.
************************************************
Donnez le nom du client (rien=exit) : 
Voici le nouvel état des comptes de l'agence
Compte d'épargne
Compte numéro 1 ouvert au nom de Karl Tombre
Adresse du titulaire : Sornéville
Le solde actuel du compte est de 1 euros.
************************************************
Compte de dépôts
Compte numéro 2 ouvert au nom de Luigi Liquori
Adresse du titulaire : Bari
Le solde actuel du compte est de -20008 euros.
************************************************
Compte d'épargne
Compte numéro 1 ouvert au nom de Jacques Jaray
Adresse du titulaire : Laxou
Le solde actuel du compte est de 100 euros.
************************************************
-----------------------------------
On applique un traitement quotidien
-----------------------------------
Compte d'épargne
Compte numéro 1 ouvert au nom de Karl Tombre
Adresse du titulaire : Sornéville
Le solde actuel du compte est de 1 euros.
************************************************
Compte de dépôts
Compte numéro 2 ouvert au nom de Luigi Liquori
Adresse du titulaire : Bari
Le solde actuel du compte est de -20016 euros.
************************************************
Compte d'épargne
Compte numéro 3 ouvert au nom de Jacques Jaray
Adresse du titulaire : Laxou
Le solde actuel du compte est de 100 euros.
************************************************
Sauvegarde effectuée

3
4
CompteEpargne
Karl Tombre
Sornéville
1
1
1.5E-4
CompteDepot
Luigi Liquori
Bari
2
-20016
4.1E-4
CompteEpargne
Jacques Jaray
Laxou
3
100
1.5E-4

6.4  Exceptions

try {
    \emph{// Code qui peut provoquer des exceptions}
}
catch (UneException e1) {
    \emph{// Traitement de ce type d'exception}
}
catch (UneAutreException e2) {
    \emph{// Traitement de l'autre type d'exception}
}
finally {
    \emph{// Choses à faire dans tous les cas, même après une exception}
}

6.4.1  Les derniers éléments du mystère

public class BufferedWriter extends Writer {
    // ... plein de choses que je passe
    public void readLine() throws IOException {
        // ... le corps de la méthode readLine
    }
    // ... etc.
}

        String reponse = "";
        try {
            reponse = br.readLine();
        } catch (IOException ioe) {}
        return reponse;

6.4.2  Exemple : une méthode qui provoque une exception

    public int depiler() throws EmptyStackException {
        if (! pileVide()) {
            --premierLibre; 
            return tab[premierLibre]; 
        }
        else {
            throw new EmptyStackException();
        }
    }

import java.util.*;

public class TestPile {
    public static void main(String[] args) {
        PileEntiers maPile = new PileEntiers();
        maPile.empiler(3);
        maPile.empiler(4);
        try {
            System.out.println("Je dépile " + maPile.depiler());
        } 
        catch(EmptyStackException ese) {
            System.out.println("Attention, la pile est vide");
        }
        try {
            System.out.println("Je dépile " + maPile.depiler());
        } 
        catch(EmptyStackException ese) {
            System.out.println("Attention, la pile est vide");
        }
        try {
            System.out.println("Je dépile " + maPile.depiler());
        } 
        catch(EmptyStackException ese) {
            System.out.println("Attention, la pile est vide");
        }
    }
}

Je dépile 4
Je dépile 3
Attention, la pile est vide

6.5  La récursivité

static int factorielle(int n) {
    /* n négatif non traité ici */
    if (n <= 1) {
        return 1;
    }
    else {
        return n * factorielle(n-1);
    }
}

1. Tous les cas ont été pris en compte (on n'a pas "perdu des bouts" dans le processus de division).
2. La division ne part jamais dans une boucle infinie (cas par exemple d'une récursivité mal analysée ou mal mise en oeuvre).
3. Les sous-problèmes sont effectivement plus simples que le problème de départ !

6.5.1  Exemple : représentation d'un ensemble par un arbre

public class ArbreBinaire  {
    private NoeudArbre racine;

    // Constructeur à partir de rien
    ArbreBinaire() {
        racine = null;
    }

    // Constructeur à partir d'un noeud donné
    ArbreBinaire(NoeudArbre n) {
        racine = n;
    }

    public boolean vide() {
        return racine == null;
    }

    public ArbreBinaire filsGauche() {
        if (racine == null) {
            return null;
        }
        else {
            return new ArbreBinaire(racine.filsGauche);
        }
    }

    public ArbreBinaire filsDroit() {
        if (racine == null) {
            return null;
        }
        else {
            return new ArbreBinaire(racine.filsDroit);
        }
    }

    public boolean contient(int x) {
        if (racine == null) {
            return false;
        }
        else if (racine.val == x) {
            return true;
        }
        else if (x > racine.val) {
            return filsDroit().contient(x);
        }
        else {
            return filsGauche().contient(x);
        }
    }

    public ArbreBinaire ajouter(int x) {
        if (racine == null) {
            // créer un nouveau n{\oe}ud
            NoeudArbre nouveau = new NoeudArbre(x); 
            racine = nouveau;
        }
        else if (x < racine.val) {
            racine.filsGauche = filsGauche().ajouter(x).racine;
        }
        else if (x > racine.val) {
            racine.filsDroit = filsDroit().ajouter(x).racine;
        }
        else {
            // dernier cas : il y est déjà : rien à faire
        }
        // Dans tous les cas, rendre l'arbre créé
        return this;
    }

• imprimer le sous-arbre gauche (appel récursif),
• imprimer la valeur de la racine,
• imprimer le sous-arbre droit (appel récursif).

    public void print() {
        if (racine != null) {
            filsGauche().print();
            System.out.print(racine.val + ", ");
            filsDroit().print();
        }
    }
}

import java.util.*;

public class TestArbre {
    public static void main(String[] args) {
        ArbreBinaire monArbre = new ArbreBinaire();
        monArbre.ajouter(3);
        monArbre.ajouter(4);
        monArbre.ajouter(18);
        monArbre.ajouter(9);
        monArbre.ajouter(1);
        monArbre.ajouter(20);
        monArbre.ajouter(87);
        monArbre.ajouter(9);
        monArbre.ajouter(11);
        monArbre.ajouter(65);
        monArbre.ajouter(41);
        monArbre.ajouter(19);
        if (monArbre.contient(19)) {
            System.out.println("19 y est");
        }
        else {
            System.out.println("19 n'y est pas");
        }
        monArbre.print();
        System.out.println("");
    }
}

19 y est
1, 3, 4, 9, 11, 18, 19, 20, 41, 65, 87, 

6.6  Interface homme--machine et programmation événementielle

// Classe CompteBancaire - version 3.2

import java.io.*;

/**
 * Classe abstraite représentant un compte bancaire et les méthodes qui lui
 * sont associées.
 * @author Karl Tombre
 */

public abstract class CompteBancaire {
    private String nom;       // le nom du client
    private String adresse;   // son adresse
    private int numéro;       // numéro du compte
    protected int solde;      // solde du compte

    // Variable de classe
    public static int premierNuméroDisponible = 1;
    
    // Constructeur : on reçoit en paramètres les valeurs du nom et
    // de l'adresse, on met le solde à 0 par défaut, et on récupère
    // automatiquement un numéro de compte
    CompteBancaire(String unNom, String uneAdresse) {
        nom = unNom;
        adresse = uneAdresse;
        numéro = premierNuméroDisponible;
        solde = 0;
        // Incrémenter la variable de classe
        premierNuméroDisponible++;
    }

    // Constructeur par défaut, sans paramètres
    CompteBancaire() {
        nom = "";
        adresse = "";
        numéro = 0;
        solde = 0;
    }

    // Les méthodes
    public void créditer(int montant) {
        solde += montant;
    }
    public String débiter(int montant) {
        solde -= montant;
        return "Débit accepté";
    }
    public void afficherEtat() {
        System.out.println("Compte numéro " + numéro + 
                           " ouvert au nom de " + nom);
        System.out.println("Adresse du titulaire : " + adresse);
        System.out.println("Le solde actuel du compte est de " +
                           solde + " euros.");
        System.out.println("************************************************");
    }
    // Accès en lecture
    public String nom() {
        return this.nom;
    }
    public String adresse() {
        return this.adresse;
    }

    public int numéro() {
        return this.numéro;
    }

    // méthode abstraite, doit être implantée dans les sous-classes
    // traitement quotidien appliqué au compte par un gestionnaire de comptes
    public abstract void traitementQuotidien();

    // sauvegarde du compte dans un BufferedWriter
    public void save(BufferedWriter bw) {
        Utils.saveString(bw, nom);
        Utils.saveString(bw, adresse);
        Utils.saveInt(bw, numéro);
        Utils.saveInt(bw, solde);
    }

    // chargement du compte à partir d'un BufferedReader
    public void load(BufferedReader br) {
        nom = Utils.loadString(br);
        adresse = Utils.loadString(br);
        numéro = Utils.loadInt(br);
        solde = Utils.loadInt(br);
    }
}

// Classe CompteEpargne - version 1.2

import java.io.*;

/**
 * Classe représentant un compte d'épargne, sous-classe de CompteBancaire.
 * @author Karl Tombre
 */

public class CompteEpargne extends CompteBancaire {
    protected double tauxIntérêts;   // taux d'intérêts par jour

    // Constructeur
    CompteEpargne(String unNom, String uneAdresse, double unTaux) {
        // on crée déjà la partie commune
        super(unNom, uneAdresse);
        // puis on initialise le taux d'intérêt
        tauxIntérêts = unTaux;
    }

    // Constructeur par défaut
    CompteEpargne() {
        super();
        tauxIntérêts = 0.0;
    }

    // Méthode redéfinie : l'affichage
    public void afficherEtat() {
        System.out.println("Compte d'épargne");
        super.afficherEtat(); // appeler la méthode de même nom dans la superclasse
    }

    // Méthode redéfinie : débiter -- interdit de passer en-dessous de 0
    public String débiter(int montant) {
        if (montant <= solde) {
            solde -= montant;
            return "Débit accepté";
        }
        else {
            return "Débit non autorisé";
        }
    }
    
    // Définition de la méthode de traitementQuotidien
    public void traitementQuotidien() {
        créditer((int) ((double) solde * tauxIntérêts));
    }
    // sauvegarde du compte dans un BufferedWriter
    public void save(BufferedWriter bw) {
        super.save(bw);
        Double d = new Double(tauxIntérêts);
        Utils.saveString(bw, d.toString());
    }

    // chargement du compte à partir d'un BufferedReader
    public void load(BufferedReader br) {
        super.load(br);
        tauxIntérêts = Double.valueOf(Utils.loadString(br)).doubleValue();
    }
}

// Classe CompteDepot - version 1.2

import java.io.*;

/**
 * Classe représentant un compte de dépôt, sous-classe de CompteBancaire.
 * @author Karl Tombre
 */

public class CompteDepot extends CompteBancaire {
    protected double tauxAgios;   // taux quotidien des agios

    // Constructeur
    CompteDepot(String unNom, String uneAdresse, double unTaux) {
        // on crée déjà la partie commune
        super(unNom, uneAdresse);
        // puis on initialise le taux des agios
        tauxAgios = unTaux;
    }

    // Constructeur par défaut
    CompteDepot() {
        super();
        tauxAgios = 0.0;
    }

    // Méthode redéfinie : l'affichage
    public void afficherEtat() {
        System.out.println("Compte de dépôts");
        super.afficherEtat(); // appeler la méthode de même nom dans la superclasse
    }
    
    // Définition de la méthode de traitementQuotidien
    public void traitementQuotidien() {
        if (solde < 0) {
            débiter((int) (-1.0 * (double) solde * tauxAgios));
        }
    }
    // sauvegarde du compte dans un BufferedWriter
    public void save(BufferedWriter bw) {
        super.save(bw);
        Double d = new Double(tauxAgios);
        Utils.saveString(bw, d.toString());
    }

    // chargement du compte à partir d'un BufferedReader
    public void load(BufferedReader br) {
        super.load(br);
        tauxAgios = Double.valueOf(Utils.loadString(br)).doubleValue();
    }
}

// Interface ListeDeComptes - version 1.2

import java.io.*;

/**
 * Interface représentant une liste de comptes et les opérations
 * que l'on souhaite effectuer sur cette liste
 * @author Karl Tombre
 */

public interface ListeDeComptes {
    // Récupérer un compte à partir d'un nom donné
    public CompteBancaire trouverCompte(String nom);
    // Ajout d'un nouveau compte
    public void ajout(CompteBancaire c);
    // Suppression d'un compte 
    public String supprimer(CompteBancaire c);
    // Afficher l'état de tous les comptes
    public void afficherEtat();
    // Traitement quotidien de tous les comptes
    public void traitementQuotidien();
    // Sauvegarder dans un fichier
    public String sauvegarder(File f);
    // Charger à partir d'un fichier
    public String charger(File f);
    // Liste des noms des titulaires de comptes
    public String[] listeDesNoms();
    // Récupérer toutes les données
    public Object[][] getData();
}

// Classe AgenceBancaire - version 1.4

import java.io.*;

/**
 * Classe représentant une agence bancaire et les méthodes qui lui
 * sont associées.
 * @author Karl Tombre
 */

public class AgenceBancaire implements ListeDeComptes {
    private CompteBancaire[] tabComptes;  // le tableau des comptes
    private int capacitéCourante;         // la capacité du tableau
    private int nbComptes;                // le nombre effectif de comptes

    // Constructeur -- au moment de créer une agence, on crée un tableau
    // de capacité initiale 10, mais qui ne contient encore aucun compte
    AgenceBancaire() {
        tabComptes = new CompteBancaire[10];
        capacitéCourante = 10;
        nbComptes = 0;
    }

    // Méthode privée utilisée pour incrémenter la capacité
    private void augmenterCapacité() {
        // Incrémenter la capacité de 10
        capacitéCourante += 10;
        // Créer un nouveau tableau plus grand que l'ancien
        CompteBancaire[] tab = new CompteBancaire[capacitéCourante];
        // Recopier les comptes existants dans ce nouveau tableau
        for (int i = 0 ; i < nbComptes ; i++) {
            tab[i] = tabComptes[i];
        }
        // C'est le nouveau tableau qui devient le tableau des comptes
        // (l'ancien sera récupéré par le ramasse-miettes)
        tabComptes = tab;
    }

    // Les méthodes de l'interface
    // Ajout d'un nouveau compte
    public void ajout(CompteBancaire c) {
        if (nbComptes == capacitéCourante) { // on a atteint la capacité max
            augmenterCapacité();
        }
        // Maintenant je suis sûr que j'ai de la place
        // Ajouter le nouveau compte dans la première case vide
        // qui porte le numéro nbComptes !
        tabComptes[nbComptes] = c;
        // On prend note qu'il y a un compte de plus
        nbComptes++;
    }
    // Récupérer un compte à partir d'un nom donné
    public CompteBancaire trouverCompte(String nom) {
        boolean trouvé = false;  // rien trouvé pour l'instant
        int indice = 0;
        for (int i = 0 ; i < nbComptes ; i++) {
            if (nom.equalsIgnoreCase(tabComptes[i].nom())) {
                trouvé = true; // j'ai trouvé
                indice = i;    // mémoriser l'indice
                break;         // plus besoin de continuer la recherche
            }
        }
        if (trouvé) {
            return tabComptes[indice];
        }
        else {
            return null;  // si rien trouvé, je rend la référence nulle
        }
    }
    // Afficher l'état de tous les comptes
    public void afficherEtat() {
        // Il suffit d'afficher l'état de tous les comptes de l'agence
        for (int i = 0 ; i < nbComptes ; i++) { 
            tabComptes[i].afficherEtat();
        }
    }

    // Traitement quotidien de tous les comptes
    public void traitementQuotidien() {
        for (int i = 0 ; i < nbComptes ;i++) {
            tabComptes[i].traitementQuotidien();
        }
    }

    // Suppression d'un compte
    public String supprimer(CompteBancaire c) {
        boolean trouvé = false;  // rien trouvé pour l'instant
        int indice = 0;
        for (int i = 0 ; i < nbComptes ; i++) {
            if (tabComptes[i] == c) { // attention comparaison de références
                trouvé = true; // j'ai trouvé
                indice = i;    // mémoriser l'indice
                break;         // plus besoin de continuer la recherche
            }
        }
        if (trouvé) {
            // Décaler le reste du tableau vers la gauche
            // On "écrase" ainsi le compte à supprimer
            for (int i = indice+1 ; i < nbComptes ; i++) {
                tabComptes[i-1] = tabComptes[i];
            }
            // Mettre à jour le nombre de comptes
            nbComptes--;
            return "Compte supprimé";
        }
        else {
            // Message d'erreur si on n'a rien trouvé
            return "Je n'ai pas trouvé ce compte";
        }
    }

    public String sauvegarder(File f) {
        BufferedWriter bw = Utils.openWriteFile(f);
        if (bw != null) {
            Utils.saveInt(bw, nbComptes);
            // Sauvegarder la variable de classe
            Utils.saveInt(bw, CompteBancaire.premierNuméroDisponible);
            for (int i = 0 ; i < nbComptes ; i++) {
                Class typeDeCompte = tabComptes[i].getClass();
                Utils.saveString(bw, typeDeCompte.getName());
                tabComptes[i].save(bw);
            }
            try {
                bw.close();
            }
            catch (IOException ioe) {}
            return "Sauvegarde effectuée";
        }
        else {
            return "Impossible de sauvegarder";
        }
    }
    public String charger(File f) {
        BufferedReader br = Utils.openReadFile(f);
        if (br != null) {
            nbComptes = Utils.loadInt(br);
            CompteBancaire.premierNuméroDisponible = Utils.loadInt(br);
            for (int i = 0 ; i < nbComptes ; i++) {
                try {
                    Class typeDeCompte = Class.forName(Utils.loadString(br));
                    tabComptes[i] = (CompteBancaire) typeDeCompte.newInstance();
                    tabComptes[i].load(br);
                }
                catch(ClassNotFoundException cnfe) {}
                catch(IllegalAccessException iae) {}
                catch(InstantiationException ie) {}
            }
            try {
                br.close();
            }
            catch (IOException ioe) {}
            return "Comptes chargés";
        }
        else {
            return "Impossible de charger la sauvegarde";
        }
    }
    // Rendre la liste des noms
    public String[] listeDesNoms() {
        String[] l = new String[nbComptes]; // créer un tableau de chaînes
        for (int i = 0 ; i < nbComptes ; i++) {
            l[i] = tabComptes[i].nom();
        }
        return l;
    }

    public Object[][] getData() {
        Object[][] theData = new Object[nbComptes][5];
        for (int i = 0 ; i < nbComptes ; i++) {
            theData[i][0] = tabComptes[i].nom();
            theData[i][1] = tabComptes[i].adresse();
            theData[i][2] = new Integer(tabComptes[i].numéro());
            // solde est protected et on y accède directement
            // puisqu'on est dans le même package
            theData[i][3] = new Integer(tabComptes[i].solde);
            theData[i][4] = (tabComptes[i] instanceof CompteEpargne) ?
                new Boolean(true) : new Boolean(false);
        }
        return theData;
    }
}

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

/**
 * Classe GestionBanque, permettant de gérer les comptes d'une agence bancaire
 * à partir d'une interface Swing
 *
 * @author "Karl Tombre" <Karl.Tombre@loria.fr>
 * @version 1.0
 * @see ActionListener
 */

public class GestionBanque implements ActionListener {
    JFrame myFrame;           // la fenêtre principale
    ListeDeComptes monAgence; // l'agence bancaire

    /**
     * Constructeur - c'est ici que tout se passe en fait. On met en place
     * les éléments contenus dans la fenêtre et on active les événements.
     */
    
    GestionBanque() {
        // Créer une fenêtre
        myFrame = new JFrame("Gestion bancaire");  // titre de la fenêtre
        // arrêter tout si on ferme la fenêtre, pour éviter d'avoir un
        // processus qui continue à tourner en aveugle
        myFrame.addWindowListener(new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });

        // Création du panel principal
        JPanel mainPanel = new JPanel();
        // GridLayout(0, 2) --> 2 colonnes, autant de lignes que nécessaire
        mainPanel.setLayout(new GridLayout(0, 2)); 
        // une petite bordure de largeur 5
        mainPanel.setBorder(BorderFactory.createEmptyBorder(5,5,5,5));

        // On crée la liste des comptes et on charge la sauvegarde éventuelle
        monAgence = new AgenceBancaire();
        // On pourrait envisager de sélectionner le fichier via un FileChooser !
        File fich = new File("comptes.dat");
        monAgence.charger(fich);

        JOptionPane.showMessageDialog(mainPanel, monAgence.charger(fich));

        // Création des boutons et association avec les actions
        mainPanel.add(new JLabel("Gestion bancaire", JLabel.CENTER));
        JButton bQuitter = new JButton("Quitter");
        bQuitter.setVerticalTextPosition(AbstractButton.CENTER);
        bQuitter.setHorizontalTextPosition(AbstractButton.CENTER);
        bQuitter.setActionCommand("quitter");
        bQuitter.addActionListener(this);
        mainPanel.add(bQuitter);
        JButton bList = new JButton("Liste des comptes");
        bList.setVerticalTextPosition(AbstractButton.CENTER);
        bList.setHorizontalTextPosition(AbstractButton.CENTER);
        bList.setActionCommand("list");
        bList.addActionListener(this);
        mainPanel.add(bList);
        JButton bAjout = new JButton("Ajouter un compte");
        bAjout.setVerticalTextPosition(AbstractButton.CENTER);
        bAjout.setHorizontalTextPosition(AbstractButton.CENTER);
        bAjout.setActionCommand("ajout");
        bAjout.addActionListener(this);
        mainPanel.add(bAjout);
        JButton bCredit = new JButton("Créditer");
        bCredit.setVerticalTextPosition(AbstractButton.CENTER);
        bCredit.setHorizontalTextPosition(AbstractButton.CENTER);
        bCredit.setActionCommand("crédit");
        bCredit.addActionListener(this);
        mainPanel.add(bCredit);
        JButton bDebit = new JButton("Débiter");
        bDebit.setVerticalTextPosition(AbstractButton.CENTER);
        bDebit.setHorizontalTextPosition(AbstractButton.CENTER);
        bDebit.setActionCommand("débit");
        bDebit.addActionListener(this);
        mainPanel.add(bDebit);
        JButton bConsultation = new JButton("Consulter un compte");
        bConsultation.setVerticalTextPosition(AbstractButton.CENTER);
        bConsultation.setHorizontalTextPosition(AbstractButton.CENTER);
        bConsultation.setActionCommand("consulter");
        bConsultation.addActionListener(this);
        mainPanel.add(bConsultation);
        JButton bTraitement = new JButton("Traitement quotidien");
        bTraitement.setVerticalTextPosition(AbstractButton.CENTER);
        bTraitement.setHorizontalTextPosition(AbstractButton.CENTER);
        bTraitement.setActionCommand("traitement");
        bTraitement.addActionListener(this);
        mainPanel.add(bTraitement);


        //Ajouter le panel à la fenêtre et l'afficher
        myFrame.setContentPane(mainPanel);

        myFrame.pack();        // Taille naturelle
        myFrame.setVisible(true); // rendre visible
    }

    private CompteBancaire selectionCompte() {
        // Récupérer la liste des noms
        String[] l = monAgence.listeDesNoms();
        // Lancer un choix du compte sur le nom du titulaire
        ChoixCompte choix = new ChoixCompte(myFrame, l);
        // Quand on revient, on a choisi
        String nomChoisi = choix.value;
        // Rendre le compte correspondant
        return monAgence.trouverCompte(nomChoisi);
    }
        
    // Comme GestionBanque se déclare 'implements ActionListener'
    // et que c'est this qui a été donné comme ActionListener sur les
    // différents événements, c'est ici qu'il faut mettre la méthode
    // actionPerformed qui indique les actions à entreprendre suivant
    // les choix de l'utilisateur
    public void actionPerformed(ActionEvent e) {
        if (e.getActionCommand().equals("list")) {
            Object[][] t = monAgence.getData();
            // Afficher la table des comptes
            TableComptes tab = new TableComptes(myFrame, t);
        }
        else if (e.getActionCommand().equals("ajout")) {
            SaisieCompte s = new SaisieCompte(myFrame);
            // récupérer le compte saisi dans la variable c
            CompteBancaire c = s.leCompte;
            if (monAgence.trouverCompte(c.nom()) == null) {
                monAgence.ajout(c);
            }
            else {
                JOptionPane.showMessageDialog(myFrame, 
                                              "Impossible, ce nom existe déjà");
            }
        }
        else if (e.getActionCommand().equals("débit")) {
            CompteBancaire c = selectionCompte();
            ChoixMontant m = new ChoixMontant(myFrame, "débiter");
            int montant = m.montant;
            // afficher le message rendu par le débit
            JOptionPane.showMessageDialog(myFrame, c.débiter(montant));
        }
        else if (e.getActionCommand().equals("crédit")) {
            CompteBancaire c = selectionCompte();
            ChoixMontant m = new ChoixMontant(myFrame, "créditer");
            int montant = m.montant;
            c.créditer(montant);
        }
        else if (e.getActionCommand().equals("quitter")) {
            // Sauvegarder la base et afficher le message rendu
            try {
                File fich = new File("comptes.dat");
                if (!fich.exists()) {
                    FileOutputStream fp = 
                        new FileOutputStream("comptes.dat");
                    fich = new File("comptes.dat");
                }
                JOptionPane.showMessageDialog(myFrame, 
                                              monAgence.sauvegarder(fich));
            }
            catch (IOException ioe) {}
            myFrame.setVisible(false);
            System.exit(0);
        }
        else if (e.getActionCommand().equals("consulter")) {
            CompteBancaire c = selectionCompte();
            FicheCompte f = new FicheCompte(myFrame, c);
        }
        else if (e.getActionCommand().equals("traitement")) {
            monAgence.traitementQuotidien();
        }
    }

    // La méthode main est réduite à la création de la fenêtre
    public static void main(String[] args) {
        GestionBanque g = new GestionBanque();
    }
}

---

Figure 6.1 : Interface créée par la classe GestionBanque.

---

---

Figure 6.2 : Exemple de fenêtre de dialogue bref.

---

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

public class ChoixCompte extends JDialog {
    // Le nom sélectionné
    public String value;
    private JList list;

    ChoixCompte(Frame f, String[] tabNoms) {
        super(f, "Choix d'un compte", true);
        final JButton okButton = new JButton("OK");
        okButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e)  {
                    value = (String) list.getSelectedValue();
                    setVisible(false);
                }
            });
        list = new JList(tabNoms);
        // Valeur par défaut
        if (tabNoms.length > 0) {
            value = tabNoms[0];
            list.setSelectedIndex(0); // Par défaut
        }
        else {
            value = "";
        }
        // On n'a le droit que de choisir un nom à la fois
        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        list.addMouseListener(new MouseAdapter() {
                public void mouseClicked(MouseEvent e) {
                    if (e.getClickCount() == 2) {
                        okButton.doClick();
                    }
                }
            });
        // La liste peut être longue, donc mettre un scroll
        JScrollPane listScroller = new JScrollPane(list);
        // Créer un container avec un titre et la liste de choix
        JPanel listPane = new JPanel();
        listPane.setLayout(new BoxLayout(listPane, BoxLayout.Y_AXIS));
        JLabel label = new JLabel("Choisissez un compte");
        listPane.add(label);
        listPane.add(listScroller);
        listPane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        // Mettre aussi le bouton
        JPanel buttonPane = new JPanel();
        buttonPane.add(okButton);

        // Mettre tout ça dans la fenêtre
        Container contentPane = getContentPane();
        contentPane.add(listPane, BorderLayout.CENTER);
        contentPane.add(buttonPane, BorderLayout.SOUTH);

        pack();
        setVisible(true);
    }
}

---

Figure 6.3 : Fenêtre ouverte par la classe ChoixCompte.

---

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

public class TableComptes extends JDialog {
    
    class MyTableModel extends AbstractTableModel {
        final String[] nomsCol = {"Nom", "Adresse", "Numéro", "Solde", "Compte d'épargne"};
        Object[][] data;

        MyTableModel(Object[][] myData) {
            super();
            data = myData;
        }

        public int getColumnCount() {
            return nomsCol.length;
        }
        public int getRowCount() {
            return data.length;
        }
        public String getColumnName(int col) {
            return nomsCol[col];
        }
        public Object getValueAt(int row, int col) {
            return data[row][col];
        }
        public Class getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }
        // Interdire l'édition
        public boolean isCellEditable(int row, int col) {
            return false;
        }
    }
    
    TableComptes(Frame f, Object[][] myData) {
        super(f, "Liste des comptes", true);
        MyTableModel myModel = new MyTableModel(myData);
        JTable table = new JTable(myModel); 
        // Mettre dans un ascenseur 
        JScrollPane scrollPane = new JScrollPane(table);

        // Créer un panel pour mettre tout ça
        JPanel listPane = new JPanel();
        listPane.setLayout(new BoxLayout(listPane, BoxLayout.Y_AXIS));
        JLabel label = new JLabel("Liste des comptes");
        listPane.add(label);
        listPane.add(scrollPane);
        listPane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        // Mettre un bouton OK
        final JButton okButton = new JButton("OK");
        okButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    setVisible(false);
                }
            });
        // Le mettre dans un panel
        JPanel buttonPane = new JPanel();
        buttonPane.add(okButton);

        // mettre le tout dans la fenêtre de dialogue
        Container contentPane = getContentPane();
        contentPane.add(listPane, BorderLayout.CENTER);
        contentPane.add(buttonPane, BorderLayout.SOUTH);

        pack();
        setVisible(true);
    }
}

---

Figure 6.4 : Fenêtre ouverte par la classe TableComptes.

---

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

public class SaisieCompte extends JDialog {
    public CompteBancaire leCompte;
    JTextField nom;
    JTextField adresse;
    JCheckBox épar;
    boolean épargne;

    SaisieCompte(Frame f) {
        super(f, "Saisie d'un nouveau compte", true);

        // Pour l'instant, pas de compte saisi
        leCompte = null;
        épargne = false;

        final JButton okButton = new JButton("OK");
        okButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    if (épargne) {
                        leCompte = new CompteEpargne(nom.getText(),
                                                     adresse.getText(),
                                                     0.00015);
                    }
                    else {
                        leCompte = new CompteDepot(nom.getText(),
                                                   adresse.getText(),
                                                   0.00041);
                    }
                    setVisible(false);
                }
            });
        
        // On crée un panel pour la saisie
        JPanel pane = new JPanel();
        pane.setLayout(new GridLayout(0, 2)); 

        pane.add(new JLabel("Nom"));
        nom = new JTextField(25);
        pane.add(nom);
        pane.add(new JLabel("Adresse"));
        adresse = new JTextField(25);
        pane.add(adresse);

        épar = new JCheckBox("Compte d'épargne");
        épar.setSelected(false);
        épar.addItemListener(new ItemListener() {
                public void itemStateChanged(ItemEvent e) {
                    if (e.getStateChange() == ItemEvent.SELECTED) {
                        épargne = true;
                    }
                    else {
                        épargne = false;
                    }
                }
            });
        pane.add(new JLabel("Type du compte"));
        pane.add(épar);
        
        pane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        // Mettre aussi le bouton
        JPanel buttonPane = new JPanel();
        buttonPane.add(okButton);

        // Mettre tout ça dans la fenêtre
        Container contentPane = getContentPane();
        contentPane.add(pane, BorderLayout.CENTER);
        contentPane.add(buttonPane, BorderLayout.SOUTH);

        pack();
        setVisible(true);
        
    }
}

---

Figure 6.5 : Fenêtre ouverte par la classe SaisieCompte.

---

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

public class ChoixMontant extends JDialog {
    // Le montant sélectionné
    public int montant;
    JTextField myTextField;

    ChoixMontant(Frame f, String objet) {
        super(f, "Choix du montant", true);
        final JButton okButton = new JButton("OK");
        okButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    montant = Integer.parseInt(myTextField.getText());
                    setVisible(false);
                }
            });
        montant = 0; // par défaut
        myTextField = new JTextField(10);
        myTextField.setText("0");
        // Créer un container avec un titre et le textfield
        JPanel tPane = new JPanel();
        tPane.setLayout(new GridLayout(0, 2));
        JLabel label = new JLabel("Montant à " + objet);
        tPane.add(label);
        tPane.add(myTextField);
        // Puis le bouton
        // Mettre aussi le bouton
        JPanel buttonPane = new JPanel();
        buttonPane.add(okButton);

        // Mettre tout ça dans la fenêtre
        Container contentPane = getContentPane();
        contentPane.add(tPane, BorderLayout.CENTER);
        contentPane.add(buttonPane, BorderLayout.SOUTH);

        pack();
        setVisible(true);
    }
}

---

Figure 6.6 : Fenêtre ouverte par la classe ChoixMontant.

---

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

// Solution simple : FicheCompte est fortement inspiré de SaisieCompte
// mais avec des labels seulement
public class FicheCompte extends JDialog {
    FicheCompte(Frame f, CompteBancaire c) {
        super(f, "Fiche du compte sélectionné", true);

        // Le bouton OK de la fin
        final JButton okButton = new JButton("OK");
        okButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    setVisible(false);
                }
            });
        
        // On crée un panel
        JPanel pane = new JPanel();
        // 2 colonnes, autant de lignes qu'on veut
        pane.setLayout(new GridLayout(0, 2)); 

        pane.add(new JLabel("Nom "));
        pane.add(new JLabel(c.nom()));
        pane.add(new JLabel("Adresse "));
        pane.add(new JLabel(c.adresse()));
        pane.add(new JLabel("Numéro "));
        pane.add(new JLabel(Integer.toString(c.numéro())));
        pane.add(new JLabel("Solde "));
        pane.add(new JLabel(Integer.toString(c.solde)));

        if (c instanceof CompteDepot) {
            pane.add(new JLabel("Statut "));
            pane.add(new JLabel("Compte de dépôt"));

            pane.add(new JLabel("Taux quotidien des agios "));
            pane.add(new JLabel(Double.toString(((CompteDepot) c).tauxAgios)));
            }
        else {
            pane.add(new JLabel("Statut "));
            pane.add(new JLabel("Compte d'épargne"));

            pane.add(new JLabel("Taux quotidien des intérêts "));
            pane.add(new JLabel(Double.toString(((CompteEpargne) c).tauxIntérêts)));
        }
            
        pane.setBorder(BorderFactory.createEmptyBorder(10,10,10,10));

        // Mettre aussi le bouton
        JPanel buttonPane = new JPanel();
        buttonPane.add(okButton);

        // Mettre tout ça dans la fenêtre
        Container contentPane = getContentPane();
        contentPane.add(pane, BorderLayout.CENTER);
        contentPane.add(buttonPane, BorderLayout.SOUTH);

        pack();
        setVisible(true);
        
    }
}

---

Figure 6.7 : Fenêtre ouverte par la classe FicheCompte.

---

6.7  Conclusion

Ils n'ont rien rapporté que des fronts sans couleur
Où rien n'avait grandi, si ce n'est la pâleur.
Tous sont hagards après cette aventure étrange ;
Songeur ! tous ont, empreints au front, des ongles d'ange,
Tous ont dans le regard comme un songe qui fuit,
Tous ont l'air monstrueux en sortant de la nuit !
On en voit quelques-uns dont l'âme saigne et souffre,
Portant de toutes parts les morsures du gouffre ! Victor Hugo

1

InputStream étant une classe abstraite, cette variable désigne forcément une instance d'une de ses sous-classes, mais nous n'y accédons que par le biais de l'interface d'InputStream.

2

La réflexivité peut se définir d'une manière générale comme la description du comportement d'un système qui entretient un rapport de cause à effet avec lui-même. Plus précisément, un système réflexif possède une structure, appelée auto-représentation, qui décrit la connaissance qu'il a de lui-même. Java possède certaines propriétés de réflexivité, notamment celles que nous utilisons ici pour demander à une classe son nom, ou pour récupérer un objet de type Class à partir de son nom.

3

L'arbre très simple que nous programmons dans l'exemple donné ici peut bien entendu être très déséquilibré, puisque sa configuration dépend fortement de l'ordre dans lequel on introduit les données. Mais il existe des versions plus élaborées de structures d'arbres où l'on rééquilibre l'arbre chaque fois qu'une adjonction ou une suppression menace de rompre l'équilibre.

4

En fait, on ne retrouve pas vraiment toutes les fonctionnalités : je vous ai laissé la programmation d'un bouton permettant de supprimer un compte, à titre d'exercice d'application !