Travaux Pratiques N°3

Programmation Orientée Objet

Avec Java
Création et utilisation de classes

Objectif du TP: Création et utilisation de classes

I- Les articles du supermarché

A. Écrivez une classe Article pour représenter les articles vendus dans un supermarché. Chaque article
comporte quatre variables d’instance

• private long reference– un numéro qui caractérise l’article de manière unique

• private String intitule– la description de l’article sous forme de texte
• private float prixHT– le prix unitaire hors taxes de l’article
• private int quantiteEnStock– le nombre d’unités de l’article disponibles

et dispose d’un certain nombre de méthodes

• public Article(long reference, String intitule, float prixHT, int quantiteEnStock) – constructeur
«immédiat» qui donne une valeur à chacune des variables d’instance,
• public long getReference(), public String getIntitule(), public int getQuantiteEnStock() – les «
accesseurs » permettant d’obtenir la valeur de chaque variable d’instance
• public void approvisionner(int nombreUnites) – méthode pour augmenter la quantité disponible
de l’article
• public boolean vendre(int nombreUnites) – cette méthode enregistre la vente
d’un certain nombre d’unités de l’article, dont il faut donc diminuer en conséquence la quantité
disponible en stock.
Si nombreUnites est supérieur à la quantité disponible alors le stock n’est pas modifié et la
méthode renvoie false; autrement elle renvoie true.
• public float prixHT()– cette méthode calcule et renvoie le prix HT de l’article
• public float prixTTC()– cette méthode calcule et renvoie le prix TTC de l’article
• public String toString() – chaîne de caractères exprimant la référence, l’intitulé et le prix de
l’article.
• public boolean equals(Article unArticle) – a.equals(b) est true si et
seulement si a et b représentent le même article (c’est-à-dire s’ils ont la même référence).

B. Pour tester cette classe écrivez une méthode main qui crée un tableau comportant trois articles (au
moins) et qui essaie toutes ces méthodes.

N.B. Attention, la méthode equals de l'API n’a pas exactement l’en-tête que nous avons utilisé ici (on
verra cela plus loin).
1
 II- Dates
Pour cet exercice faites semblant de ne pas savoir qu’il existe dans la bibliothèque Java des classes
java.util.Date et java.util.Calendar qui offrent probablement les services demandés ici.
Écrivez une classe Date dont chaque instance représente une date précise. Mettez-y quatre variables
d’instance privées : annee (un entier non négatif), mois (un entier compris entre 1 et 12), jour (un entier
compris entre 1 et une borne supérieure qui dépend du mois) et jourSemaine (un entier indiquant le jour
de la semaine : 0 pour lundi, 1 pour mardi, etc.
Écrivez les méthodes
i. public Date(int jour, int mois, int annee) – initialisation d’une date, à partir des trois nombres
donnés. La validité des ces nombres doit être vérifiée (voyez ci-dessous comment) et, en cas de date
incohérente, un message doit être affiché et le programme abandonné. C’est ici que le jour de la
semaine doit être déterminé (voyez ci-dessous une manière simple de le faire).
ii. int getJour(), int getMois(), int getAnnee(), int getJourSemaine() – des « accesseurs » pour
obtenir les valeurs correspondantes
iii. public String toString()– renvoie l’expression d’une date sous forme de texte, comme
"vendredi 8 décembre 2006"
iv. public boolean infeg(Date d)– comparaison : a.infeg(b)renvoie truesi la date a est antérieure ou
égale à la date b, sinon cela renvoie false.

Pour simplifier, supposez qu’une année est bissextile si et seulement si son millésime est divisible par
quatre (en réalité c’est un peu plus compliqué).

Indications, 1 – Pour abandonner le programme vous pouvez appeler la méthode System.exit(int code).
Un tel traitement des erreurs est naïf, nous verrons plus loin (à l’occasion des exceptions) une meilleure
manière de faire cela.

Indications, 2 – Pour vous éviter de perdre votre temps sur des choses qui ne sont pas l’objet de cet exercice,
voici une expression évaluant la validité d’une date (avec la simplication sur les années bissextiles
mentionnée). Vous pouvez vous contenter de la copier-coller dans votre programme, puis de tester la valeur
de dateInvalide:

boolean dateInvalide = mois < 1 || mois > 12

|| jour < 0 || jour > 31
|| jour == 31 && (mois == 4 || mois == 6 || mois == 9 || mois == 11)
|| jour >= 30 && mois == 2
|| jour == 29 && mois == 2 && annee % 4 != 0;

Indications, 3 – Pour vous éviter de perdre votre temps sur des choses qui ne sont pas l’objet de cet exercice,
voici une manière simple de calculer le jour de la semaine correspondant à une date donnée (en trichant un
peu par rapport à notre engagement de ne pas utiliser les outils de la bibliothèque Java) :
private int jourSemaine(int jour, int mois, int annee) {
Calendar c = Calendar.getInstance();
c.set(annee, mois - 1, jour); return
c.get(Calendar.DAY_OF_WEEK);
}
Écrit comme cela, vous obtenez 1 : dimanche, 2 : lundi, ... 7 : samedi. Pour avoir 0 : lundi, 1 : mardi, ...
6 : dimanche, remplacez la dernière ligne ci-dessus, par :
return (c.get(java.util.Calendar.DAY_OF_WEEK) + 5) % 7;
Attention à vos éventuels import : un malencontreux import java.util.*; va créer un conflit muet entre
java.util.Date et votre propre Date. En règle générale, évitez asolument les import du style import
monPackage.*;

2
III- Flacons et bouteilles...

Vous travaillez chez MOHA & Co., producteur exclusif du sirop Mirifik, un élixir extraordinaire issu de la
recherche spatiale qui rend jeune, beau et intelligent et qui empêche la chute des cheveux et les tâches de
transpiration. Dilué à différentes concentrations, le sirop Mirifik est commercialisé dans diverses sortes de
flacons.

On vous demande d’écrire une classe Flacon dont les instances représentent les flacons de sirop Mirifik
en stock. Cette classe comportera :

i. des variables d’instance :

1. private final float capacite– la capacité du flacon (en ml) ,
2. private float volume – le volume de liquide (en ml) que le flacon contient à un
instant donné,
3. private float concentration – la concentration de ce liquide, c.-à-d. le rapport (volume sirop)
/ (volume sirop+eau),
4. String etiquette– un texte libre « affiché » sur le flacon
ii. des méthodes :
1. public Flacon(String etiquette, float capacite)– Construction d’un flacon ayant
la capacité donnée et portant l’étiquette indiquée. Initialement, le volume est mis
à zéro.
2. public void verser(float volumeSirop, float volumeEau)– Ajout à un flacon
des volumes de sirop et d’eau indiqués.
La possibilité d’une telle opération doit être vérifiée et, en cas d’impossibilité, on doit
produire l’affichage d’un message et l’abandon du programme.
3. public void transvaser(Flacon autreFlacon, float volume) – Ajout à un flacon
du volume indiqué du liquide extrait de l’autreFlacon indiqué. La possibilité
d’une telle opération doit être vérifiée et, en cas d’impossibilité, on doit produire
l’affichage d’un message et l’abandon du programme.
4. public String toString() – Affichage de l’étiquette, du volume et de la
concentration du contenu du flacon en question.

Écrire une méthode mainpour tester toutes ces opérations.

Que pensez-vous des qualifieurs que nous avons appliqué aux variables d’instance ? Pourquoi capacite a
été qualifiée final ? Est-il intéressant de qualifier private le volume et la concentration?

N.B. Comme à l’exercice précédent, pour abandonner le programme vous pouvez appeler la méthode
System.exit(int code).

3
III- Points du plan

A. Définissez une classe Point pour représenter les points du plan rapporté à une origine fixée. Les
coordonnées d’un point sont ici deux nombres flottants x, y, mémorisés dans deux variables d’instance
privées (par exemple de type double). La classe Point comportera au moins les méthodes d’instance
suivantes, toutes publiques :
• Point(double x, double y), constructeur d’un point à partir de ses
coordonnées cartésiennes,
• double x(), double y()qui renvoient les coordonnées
cartésiennes du point,
• double r(), double t(), qui renvoient les coordonnées polaires du point
(voir ci-dessous),
• String toString(), qui renvoie une expression textuelle du
point, comme "(2.0,3.0)",
• boolean equals(Object o), comparaison : a.equals(b)
répond à la question « a et b représentent-ils deux points égaux ? »,
• void homothetie(double k), qui applique au point une
homothétie de centre (0, 0) et de rapport k ; pour cela, il suffit de
remplacer (x, y) par (k × x, k × y),
• void translation(double dx, double dy), qui applique au point une
translation de vecteur (dx, dy) ; cela consiste à remplacer (x, y) par (x
+ dx, y + dy).
• void rotation(double a), qui applique au point une rotation de centre
(0, 0) et d’angle a.
Une manière – qui n’est pas la plus efficace – de faire cela consiste à
calculer les coordonnées polaires (r, t) correspondant à (x, y) puis les
coordonnées cartésiennes (x’, y’) correspondant à (r, t + a)

Rappel de formules: x = r × cos(t), y = r × sin(t), r = sqrt(x2 + y2), t = atan(y / x) [ou, mieux,

t = atan2(y, x) ]

B. Application de la classe Point. Une ligne polygonale est définie par un certain nombre de points, ses
sommets. Définissez une classe LignePol pour représenter de tels objets. Les sommets y seront mémorisés
sous forme de tableau de points. Il en découle que le nombre de sommets d’une ligne polygonale ne pourra
pas augmenter au cours de la vie de celle-ci, mais cela ne sera pas un problème dans le cadre de cet exercice.

Cette classe comportera au moins deux variables d’instance privées :

• Point[] sommets– le tableau des points qui sont les sommets de la ligne polygonale,
• int nbSommets – le nombre de sommets (ici, cette information est redondante, puisque
nbSommets= sommets.length) et les

méthodes publiques :

• LignePol(int n), constructeur d’une ligne polygonale à n

sommets (initialement indéterminés),
• LignePol(Point[] sommets), constructeur d’une ligne
polygonale ayant les sommets indiqués,
• Point getSommet(int i), renvoie le ième sommet,
• void setSommet(int i, Point p), donne ppour valeur du ième
sommet,
• String toString(), renvoie une expression de la ligne

4
 polygonale sous forme de texte,
• void homothetie(double k), qui applique à chaque sommet de la
ligne polygonale une homothétie de centre (0, 0) et de rapport k,
• void translation(double dx, double dy), qui applique à chaque
sommet de la ligne polygonale une translation de vecteur (dx, dy)
• void rotation(double a), qui applique à chaque sommet de la
ligne polygonale une rotation de centre (0, 0) et d’angle a

En supposant (c’est tout à fait fictif) que vous disposiez d’un environnement graphique dans lequel on
obtient le tracé du d’extrémités (x0,y0) et (x1,y1) par l’expression

tracerLigne(int x0, int y0, int x1, int y1)

ajoutez à la classe LignePol une méthode tracerqui produit le tracé de la ligne polygonale. Ensuite,
écrivez une méthode mainqui construit et « trace » la cocotte ci-dessus.

N.B. Pour faire tourner la simulation vous pouvez définir :

void tracerLigne(int x0, int y0, int x1, int y1) { System.out.println("tracer de (" + x0 + "," + y0 + ") à (" +
x1 + "," +
y1 + ")");
}

C. Imaginons (c’est de la fiction) qu’une enquête effectuée auprès des utilisateurs de votre classe Point a
montré que cette classe est correcte et pratique mais que, du point de vue des performances, il aurait mieux
valu prendre pour représentation interne des points leur coordonnées polaires (r, t) au lieu des coordonnées
cartésiennes (x, y).

Réécrivez donc la classe Point de manière que les variables d’instance soient les coordonnées polaires du
point, et non plus ses coordonnées cartésiennes, en respectant la contrainte suivante :

Vous devez faire en sorte que la vue publique de la classe soit inchangée, afin que les
applications de la classe Point (par exemple, la classe LignePol) restent valides sans nécessiter
la moindre modification. Une confirmation qu’on a respecté cette contrainte sera que le
programme de la question précédente fonctionne sans qu’il y ait besoin de modifier quoi que
ce soit.

5
IV- Objets membres d’autres objets

Cet exercice est surtout une petite réflexion sur la notion de duplication ou clonage d’objets, surtout
quand il s’agit d’objets qui ont pour membres d’autres objets (ce qui est le cas de la majorité des objets).

Vous devez disposer d’une classe Point, même très simple (par exemple, celle du début de l’exercice
précédent). Assurez-vous que cette classe n’a pas de constructeur sans arguments.

A. Un rectangle est déterminé par la donnée de deux points, respectivement son angle supérieur gauche et
son angle inférieur droit. Définissez une classe Rectangle ayant deux variables d’instance privées coinNO
(pour « coin Nord-Ouest ») et coinSE (pour « coin Sud-Est ») et, au moins, les méthodes suivantes :

• Rectangle(double x0, double y0, double x1, double y1), constructeur d’un rectangle ayant (x0,y0)
et (x1,y1) pour coins,
• String toString(), qui renvoie une expression du rectangle sous forme de texte, comme
"[(1.0,2.0);(3.0,4.0)]",

B. Faites le test suivant :

public static void main(String[] args) { Rectangle r1, r2;

r1 = new Rectangle(1, 2, 3, 4);
r2 = r1;
System.out.println("r1: " + r1 + ", r2: " + r2); r1.coinNO = new
Point(0, 0); System.out.println("r1: " + r1 + ", r2: " + r2);
r1.coinSE.homothetie(2);
System.out.println("r1: " + r1 + ", r2: " + r2);
}

On aurait pu penser que l’expression « r2 = r1; » affectait à r2une duplication de r1. Qu’est-ce que
l’exécution du code précédent montre ?

C. Écrivez la première ligne de la classe Rectanglecomme ceci

public class Rectangle implements Cloneable {

et l’en-tête de la fonction maincomme ceci

public static void main(String[] args) throws CloneNotSupportedException {

Maintenant remplacez la ligne « r2 = r1;» par

r2 = (Rectangle) r1.clone();

Votre classe utilise donc maintenant la version prédéfinie de la méthode clone. Reexécutez le test :
qu’est-ce que vous constatez ?

D. Ajoutez à votre classe la méthode suivante (vous pouvez effacer ou non les déclarations
« implements» :

public Rectangle clone() {

return new Rectangle(coinNO.x(), coinNO.y(), coinSE.x(), coinSE.y());
}

et refaites le test. Que constatez-vous à présent ?

6
V- Fractions

La bibliothèque Java ne comporte pas de classe pour représenter les fractions (comme celles de l’école
primaire, avec un numérateur et un dénominateur). On se propose ici de pallier ce manque, en définissant
une classe Fractionmunie des méthodes suivantes :

i. public Fraction(BigInteger num, BigInteger den)– constructeur basique

ii. public Fraction(int n, int d) – construction d’une fraction à partir de deux entiers
(qu’il faudra convertir en BigInteger)
iii. public Fraction(int n) – construction d’une fraction à partir d’un
entier (pour
transformer un entier en fraction on met 1 comme dénominateur)
iv. public Fraction add(Fraction f)– addition de deux fractions
v. public Fraction sub(Fraction f)– soustraction de fractions
vi. public Fraction mult(Fraction f)– multiplication de fractions
vii. public Fraction divi(Fraction f)– division de fractions
viii. public String toString()– conversion d’une fraction en chaîne de caractères
ix. public double doubleValue() – obtention d’une valeur décimale qui est une
approximation de la fraction

C'est pour éviter les problèmes de débordement qu'il est conseillé de représenter le numérateur et le
dénominateur d’une fraction par des objets BigInteger.