Corrigé 4

Prérequis

Corrigé 4.1 : La classe Rectangle

La classe Rectangle exprimée en Java est décrite à la suite. Elle introduit les deux attributs largeur et hauteur. Il convient de remarquer que lorsqu’un paramètre de même nom qu’un attribut est utilisé, l’accès à l’attribut se fait via this.

public class Rectangle { 
   int largeur, hauteur; 
 
   public Rectangle(int largeur, int hauteur) { 
       this.largeur = largeur; 
       this.hauteur = hauteur; 
   } 
 
   public int getLargeur() { 
       return largeur; 
   } 
 
   public int getHauteur() { 
       return hauteur; 
   } 
 
   public void setLargeur(int largeur) { 
       this.largeur = largeur; 
   } 
 
   public void setHauteur(int hauteur) { 
       this.hauteur = hauteur; 
   } 
 
   public int surface() { 
       return largeur * hauteur; 
   } 
 
   public int perimetre() { 
       return (largeur + hauteur) * 2; 
   } ...

Corrigé 4.2 : La classe Calculatrice

La classe Calculatrice dans sa version Java est présentée ci-après. Les méthodes ajoute, multiplie et divise changent la valeur de l’objet.

public class Calculatrice { 
   double valeur; 
 
   public Calculatrice(double valeur) { 
       this.valeur = valeur; 
   } 
 
   public double getValeur() { 
       return valeur; 
   } 
 
   public void ajoute(double argument) { 
       valeur = valeur + argument; 
   } 
 
   public void multiplie(double argument) { 
       valeur = valeur * argument; 
   } 
 
   public void divise(double argument) { 
       valeur = valeur / argument; 
   } 
} 

Le programme Java mettant en œuvre la calculatrice se trouve ci-dessous. Il est basé sur une boucle où l’utilisateur choisit l’opération qu’il veut effectuer.

import java.util.Scanner; 
 
public class TestCalculatrice { 
   static Scanner reader = new Scanner(System.in); 
 
   public static double lireArgument() { 
       System.out.print("Entrez...

Corrigé 4.3 : La classe Complexe

La classe Complexe permet de décrire des nombres complexes qui sont décrits par deux nombres réels. Les opérations d’ajout et de multiplication d’un nombre réel au nombre complexe sont écrites selon les règles de l’énoncé. Voici la version Java de cette classe.

public class Complexe { 
   double reel, imaginaire; 
 
   public double getReel() { 
       return reel; 
   } 
 
   public double getImaginaire() { 
       return imaginaire; 
   } 
 
   public void setReel(double reel) { 
       this.reel = reel; 
   } 
 
   public void setImaginaire(double imaginaire) { 
       this.imaginaire = imaginaire; 
   } 
 
   public Complexe(double reel, double imaginaire) { 
       this.reel = reel; 
       this.imaginaire = imaginaire; 
   } 
 
   public double module() { 
       return Math.sqrt(reel * reel + imaginaire * imaginaire); 
   } 
 
   public void ajouteReel(double argument)...

Corrigé 4.4 : La classe NombreAleatoire

En Java, la classe NombreAleatoire possède un constructeur qui prend en paramètre la borne inférieure et la borne supérieure de l’intervalle dans lequel le nombre aléatoire doit se situer. Le constructeur invoque ensuite la méthode recalcule qui donne la valeur du nombre aléatoire. Cette valeur ne change plus tant que cette méthode recalcule n’est pas appelée à nouveau.

public class NombreAleatoire { 
   int valeur, borneInf, borneSup; 
 
   public NombreAleatoire(int borneInferieure, int borneSuperieure) { 
       borneInf = borneInferieure; 
       borneSup = borneSuperieure; 
       reCalcule(); 
   } 
 
   public int getBorneInf() { 
       return borneInf; 
   } 
 
   public int getBorneSup() { 
       return borneSup; 
   } 
 
   public int getValeur() { 
       return valeur; 
   } 
 
   public int compare(int valeur) { 
       if (valeur == this.valeur) return 0; 
       if (valeur > this.valeur) return 1; 
 ...

Corrigé 4.5 : La classe Vecteur

En Java, la classe Vecteur permettant de travailler sur des vecteurs utilise un tableau pour les représenter en interne. Ce tableau est créé dans le constructeur. Les accesseurs prennent par conséquent un paramètre qui est l’indice de l’élément dont la valeur doit être lue ou écrite.

import java.util.Scanner; 
 
public class Vecteur { 
   int[] tab; 
   Scanner reader = new Scanner(System.in); 
 
   public Vecteur(int taille) { 
       tab = new int[taille]; 
   } 
 
   public int getElement(int indice) { 
       return tab[indice]; 
   } 
 
   public void setElement(int indice, int valeur) { 
       tab[indice] = valeur; 
   } 
 
   public void lit() { 
       for (int i = 0; i < tab.length; i++) 
           tab[i] = reader.nextInt(); 
   } 
 
   public void affiche() { 
       for (int i = 0; i < tab.length; i++) 
           System.out.print(tab[i] + " "); 
       System.out.println(); ...

Corrigé 4.6 : La classe Complexe2

La classe Complexe2 en Java reprend la version existante de la classe Complexe puis l’étend en ajoutant une méthode pour l’addition des nombres complexes et une méthode pour la multiplication des nombres complexes.

Dans la programmation de la méthode multiplieComplexe, nous avons pris soin d’utiliser une variable temporaire pour mémoriser le résultat de la nouvelle partie réelle. En effet, le calcul de la nouvelle partie imaginaire est basé sur la valeur de la partie réelle du nombre complexe avant sa mise à jour.

public class Complexe2 { 
   double reel, imaginaire; 
 
   public double getReel() { 
       return reel; 
   } 
 
   public double getImaginaire() { 
       return imaginaire; 
   } 
 
   public void setReel(double reel) { 
       this.reel = reel; 
   } 
 
   public void setImaginaire(double imaginaire) { 
       this.imaginaire = imaginaire; 
   } 
 
   public Complexe2(double reel, double imaginaire) { 
       this.reel = reel; 
       this.imaginaire = imaginaire; 
   } 
 
   public double module() { 
       return Math.sqrt(reel * reel + imaginaire * imaginaire); 
   } 
 
   public void ajouteReel(double argument) { 
       reel = reel + argument; 
   } 
 
   public void multiplieReel(double argument) { 
       reel = reel * argument; 
       imaginaire = imaginaire * argument; 
   } 
 
   public void ajouteComplexe(Complexe2 argument) { 
       reel = reel + argument.getReel(); 
       imaginaire = imaginaire + argument.getImaginaire(); 
   } ...

Corrigé 4.7 : La classe Angle

La classe Angle a pour particularité d’introduire des accesseurs sur une même valeur et basés sur des unités différentes. Le choix de représenter en interne la valeur de l’angle en grades est propre à cet exercice. Vous pouvez utiliser n’importe quelle autre unité sans que cela n’interfère sur les clients de la classe. Le code suivant donne la version de cette classe en Java.

public class Angle { 
   double valeur = 0; // la valeur en grades de l'angle 
 
   public double getValeurGrades() { 
       return valeur; 
   } 
 
   public void setValeurGrades(double valeur) { 
       this.valeur = valeur; 
   } 
 
   public double getValeurDegres() { 
       return valeur * 180 / 200; 
   } 
 
   public void setValeurDegres(double valeur) { 
       this.valeur = valeur * 200 / 180; 
   } 
 
   public double getValeurRadians() { 
       return valeur * Math.PI / 200; 
   } 
 
   public void setValeurRadians(double valeur) { 
       this.valeur...

Corrigé 4.8 : La classe Fraction

La classe Fraction représente des nombres rationnels positifs. Dans la version de la classe en Java, le constructeur prend soin de vérifier que ces contraintes sont bien respectées. Dans le cas contraire, le nombre rationnel représenté est 0/1, c’est-à-dire 0. La méthode reduit réalise la réduction au maximum du numérateur et du dénominateur. Elle les divise par leur PGCD dont le calcul est réalisé par la méthode pgcd. Enfin, la méthode addition calcule l’addition de la fraction avec une autre fraction et renvoie le résultat sous la forme d’un nouvel objet de la classe Fraction. Ce nouvel objet est créé au début de la méthode. Sa méthode reduit est appelée. Il est ensuite renvoyé comme résultat.

public class Fraction { 
   int numerateur, denominateur; 
 
   public Fraction(int num, int den) { 
       if ((num >= 0) && (den > 0)) { 
           numerateur = num; 
           denominateur = den; 
       } else { 
           numerateur = 0; 
           denominateur = 1; 
       } 
   } 
 
   public double reel() { 
       return (double) numerateur / (double) denominateur; 
   } 
 
   public int pgcd(int...

Corrigé 4.9 : La classe Rectangle2

La classe Rectangle2 décrit des rectangles dont les côtés sont parallèles aux axes. La méthode intersection calcule le rectangle résultant de l’intersection entre deux rectangles existants. Un premier test permet de traiter le cas où l’intersection est vide. Dans le cas contraire, l’intersection est calculée simplement sur chaque axe à l’aide des opérateurs min et max. Le code de cette classe écrite en Java a la forme suivante.

public class Rectangle2 { 
   float xmin, xmax, ymin, ymax; 
 
   public Rectangle2(float xmin, float xmax, float ymin, float ymax) { 
       this.xmin = xmin; 
       this.xmax = xmax; 
       this.ymin = ymin; 
       this.ymax = ymax; 
   } 
 
   public float getXmin() { 
       return xmin; 
   } 
 
   public float getXmax() { 
       return xmax; 
   } 
 
   public float getYmin() { 
       return ymin; 
   } 
 
   public float getYmax() { 
       return ymax; 
   } ...

Corrigé 4.10 : La classe Ensemble

La classe Ensemble reprend pour attributs les deux variables qui servent à décrire un ensemble à l’aide d’un tableau comme expliqué dans les exercices 2.5 et 2.6. Le constructeur prend comme paramètre la taille maximale de l’ensemble et crée alors le tableau interne.

L’insertion et la suppression donnent alors lieu à une méthode spécifique pour chaque opération. La méthode insere prend soin de vérifier la taille maximale avant de procéder à l’insertion dans le tableau.

L’utilisation de la classe Ensemble a permis de regrouper en une seule unité les données et opérations introduites dans les exercices 2.5 et 2.6 où ces données et opérations étaient mélangées avec celles des autres parties du programme principal. Le code suivant donne la version pour le langage Java.

public class Ensemble { 
   int tailleEnsemble; 
   int[] ensemble; 
 
   public Ensemble(int tailleMaximaleEnsemble) { 
       tailleEnsemble = 0; 
       ensemble = new int[tailleMaximaleEnsemble]; 
   } 
 
   public boolean insere(int valeur) { 
       int j = 0; 
       while ((j < tailleEnsemble) && (ensemble[j] != valeur)) 
           j++; 
       // insertion de la valeur si elle n'a pas été trouvée ...

Corrigé 4.11 : La classe EnsembleTrie

La classe EnsembleTrie introduit les mêmes attributs et méthodes que la classe Ensemble. La différence réside dans la programmation des méthodes insere et supprime qui sont maintenant basées sur l’algorithme de recherche dichotomique introduit dans les exercices 2.7 et 2.8. Voici le code Java de cette classe.

public class EnsembleTrie { 
   int tailleEnsemble; 
   int[] ensemble; 
 
   public EnsembleTrie(int tailleMaximaleEnsemble) { 
       tailleEnsemble = 0; 
       ensemble = new int[tailleMaximaleEnsemble]; 
   } 
 
   public boolean insere(int valeur) { 
       int borneGauche, borneDroite, milieu; 
       boolean trouve; 
 
       borneGauche = 0; 
       borneDroite = tailleEnsemble - 1; 
       trouve = false; 
       while ((!trouve) && (borneGauche <= borneDroite)) { 
           milieu = (borneGauche + borneDroite) / 2; 
           if (ensemble[milieu] == valeur) 
               trouve = true; 
           else { 
               if (ensemble[milieu] > valeur) 
                   borneDroite = milieu - 1; 
               else 
                   borneGauche = milieu + 1; 
           } 
       } 
       // insertion de la valeur si elle n'a pas été trouvée 
       if (!trouve) { 
           if (tailleEnsemble == ensemble.length) 
               return false; 
           for (int i = tailleEnsemble; i > borneGauche; i--) 
       ...

Corrigé 4.12 : La classe Matrice

La classe Matrice représente des matrices rectangulaires. La représentation interne choisie est un tableau à deux dimensions. En Java, ce tableau est créé dans le constructeur de la classe dont les deux paramètres sont le nombre de lignes et le nombre de colonnes.

L’accesseur getMatrice permet de retrouver la valeur d’un élément dans la matrice à partir de son numéro de ligne et de son numéro de colonne.

La méthode ajoute vérifie que le nombre de lignes et le nombre de colonnes de l’autre matrice sont compatibles puis, à l’aide de deux boucles imbriquées, calcule la valeur du résultat élément par élément.

import java.util.Scanner; 
public class Matrice { 
   Scanner reader = new Scanner(System.in); 
   int[][] tabMatrice; 
   int nombreLignes, nombreColonnes; 
 
   public Matrice(int nombreLignes, int nombreColonnes) { 
       this.nombreLignes = nombreLignes; 
       this.nombreColonnes = nombreColonnes; 
       tabMatrice = new int[nombreLignes][nombreColonnes]; 
   } 
 
   public int getNombreLignes() { 
       return nombreLignes; 
   } 
 
   public int getNombreColonnes() { 
       return nombreColonnes; 
   } 
 ...

Corrigé 4.13 : La classe Devine

En Java, la classe Devine présente la particularité d’avoir un constructeur qui prend comme paramètre un objet de la classe NombreAleatoire introduite dans le corrigé 4.4. Cet objet est ensuite utilisé dans la méthode session qui organise l’interaction avec l’utilisateur. Celle-ci est basée sur des appels des méthodes du nombre aléatoire.

import java.util.Scanner; 
 
public class Devine { 
   NombreAleatoire nombreAleatoire; 
   Scanner parser = new Scanner(System.in); 
 
   public Devine(NombreAleatoire nombreAleatoire) { 
       this.nombreAleatoire = nombreAleatoire; 
   } 
 
   public int session() { 
       int tentative, resultat, nbrTentatives = 0; 
       do { 
           System.out.print("Proposez un nombre entier entre " 
                   + nombreAleatoire.getBorneInf() + " et " 
                   + nombreAleatoire.getBorneSup() + " : "); 
           tentative = parser.nextInt(); 
           resultat = nombreAleatoire.compare(tentative); ...