cours0708/G5a/Exercices/4-exosClasses2.html

256 lines
9.2 KiB
HTML
Raw Permalink Normal View History

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>exosJavaClasse 2</title>
</head>
<body>
<span style="font-family: Arial;">
<h1>Exercices
java
: Classes et
h&eacute;ritage</h1>
<span style="font-family: Arial;"><br>
<h2>4. Une
&eacute;tag&egrave;re &agrave; confiture</h2>
<span style="font-family: Arial;">
<ul>
<p><strong>4.1.</strong>
Reprendre l'exercice "Confitures" et cr&eacute;er une classe <code>Etagere</code>
repr&eacute;sentant une &eacute;tag&egrave;re pouvant
contenir plusieurs pots de confitures
avec les m&eacute;thodes suivantes : </p>
<ul>
<li><code>int
getNbMaxConfitures()</code> et <code>int
getNbConfitures()</code>
: les accesseurs qui renvoient respectivement le nombre maximal de pots
de confiture, et le nombre de pots qu'elle contient effectivement;</li>
<li><code>void
ajouter( Confiture )</code> : qui
ajoute un pot de confiture sur l'&eacute;tag&egrave;re;</li>
<li><code>Confiture
getConfiture( int )</code> : qui
permet de r&eacute;cup&eacute;rer le i&egrave;me pot de
confiture de l'&eacute;tag&egrave;re (la position du premier
pot est 1);</li>
<li><code>int
chercherConfiture( String, int )</code>
: qui permet de
chercher la position du premier pot de confiture de
l'&eacute;tag&egrave;re rep&eacute;r&eacute;
par son parfum et son ann&eacute;e (renvoie 0 s'il n'y a pas de
confiture de
cette sorte);</li>
<li><code>Confiture
enleverConfiture( int )</code> et <code>Confiture
enleverConfiture( String, int )</code>
: pour la suppression d'un pot de confiture de
l'&eacute;tag&egrave;re, soit par sa
position, soit par son parfum et ann&eacute;e; il faut alors
"tasser" les
confitures vers le d&eacute;but de l'&eacute;tag&egrave;re;
les deux m&eacute;thodes renvoient le
pot de confiture que l'on a supprim&eacute; (<code>null</code>
si aucun).</li>
<li><code>toString()</code>
: qui permet d'afficher le contenu d'une &eacute;tag&egrave;re.
Le constructeur prendra
en
param&egrave;tre le nombre maximal de
pots que peut
contenir l'&eacute;tag&egrave;re. L'impl&eacute;mentation
de l'&eacute;tag&egrave;re pourra se faire par un tableau ou un
Vector,
mais cela ne doit pas &ecirc;tre visible de
l'ext&eacute;rieur.</li>
</ul>
</ul>
</span>
<div style="margin-left: 40px;"><span style="font-family: Arial;"><strong>4.2.</strong>
Cr&eacute;er un main
qui permette de tester toutes ces m&eacute;thodes ; tester avec 2
&eacute;tag&egrave;res
<h2>5.Une
&eacute;tag&egrave;re g&eacute;n&eacute;rique...</h2>
<span style="font-family: Arial;">
<p>Le but est de
cr&eacute;er
une nouvelle classe plus g&eacute;n&eacute;rique afin de
pouvoir ranger sur notre &eacute;tag&egrave;re autre chose que
des confitures.
Pour cela, nous allons cr&eacute;er une hi&eacute;rarchie de
classes repr&eacute;sentant tous les types de conserves que l'on
souhaite stocker.</p>
<ul>
<p><strong>5.1.</strong>
Cr&eacute;er une classe abstraite <code>Conserve</code>
repr&eacute;sentant tous les types de conserves.</p>
<p>Une conserve
contiendra
toujours :</p>
<ul>
<li>un identifiant<br>
</li>
<li>le nom du cuisinier</li>
<li>la date (ou
l'ann&eacute;e de cr&eacute;ation et de stockage)</li>
<li>une m&eacute;thode
abstraite d'ajout sur une &eacute;tag&egrave;re <code>abstract
public void ajouter(Etagere e);</code></li>
<li>et toutes les
m&eacute;thodes d'acc&egrave;s et de modifications
n&eacute;cessaires...</li>
</ul>
<p>La m&eacute;thode <code>ajouter
</code>sera
sp&eacute;cifique
&agrave; chaque type
de conserve, car certaines prendront plus de place que d'autres !</p>
<p><strong>5.2.</strong>
Modifier maintenant la classe <code>Confiture</code>
afin qu'elle h&eacute;rite de la classe <code>Conserve</code>.</p>
<p><strong>5.3.</strong>
Cr&eacute;er une nouvelle classe <code>Moutarde</code>
sp&eacute;cialisant aussi la classe <code>Conserve</code>.</p>
<p> Cette classe
contiendra en
plus
des informations de la classe <code>Conserve</code>
un entier type qui d&eacute;crira le type de moutarde dont
il s'agit. Cet attribut prendra une valeur parmi les constantes :</p>
<ul>
<li><code>ANCIENNE
= 0</code> : pour de la moutarde
&agrave; l'ancienne;</li>
<li><code>CONDIMENT
= 1</code> : pour de la moutarde
condiment;</li>
<li><code>FORTE
= 2</code> : pour de la moutarde
forte.</li>
</ul>
<p> Ces constantes seront
stock&eacute;es comme attributs statiques de la classe <code>Moutarde</code>.</p>
<p> Pour la
m&eacute;thode <code>void
ajouter(Etagere e)</code>
demand&eacute;e par la superclasse <code>Conserve</code>,
il faudra prendre en compte
la sp&eacute;cificit&eacute; des pots de moutarde &agrave;
l'ancienne. Ceux-ci &eacute;tant en
terre cuite, ils sont tr&egrave;s volumineux et
n&eacute;cessitent
deux emplacements
sur l'&eacute;tag&egrave;re. Pour les deux autres types de
moutarde, ils s'ajoutent &agrave;
l'&eacute;tag&egrave;re de mani&egrave;re normale.</p>
<p> <strong>5.4.</strong>
Tester ces classes avec un programme ajoutant plusieurs types de
conserves sur une &eacute;tag&egrave;re.</p>
<p> <strong>5.5.</strong>
Pour finir, on peut g&eacute;n&eacute;raliser nos
&eacute;tag&egrave;res afin qu'elles stockent toutes sortes
d'objets et pas uniquement des conserves. Pour cela, d&eacute;finir
une interface <code>Stockable</code>
d&eacute;crivant le comportement
d'un objet que l'on souhaite stocker sur notre
&eacute;tag&egrave;re.</p>
<p> Cette interface
comportera
uniquement une m&eacute;thode <code>void
ajouter(Etagere e);</code></p>
<p> Modifier toutes les
classes
pr&eacute;c&eacute;dentes afin qu'elles impl&eacute;mentent
cette interface. Modifier aussi
la classe <code>Etagere</code>
qui maintenant g&egrave;re un tableau de <code>Stockable</code>.<br>
</p>
</ul>
</span>
<h2> 6. Trois petits
points...</h2>
<p> <strong>6.1</strong>
Cr&eacute;er une classe <code>Point</code>
permettant de manipuler des points du plan. On la munira :</p>
<ul>
<li>de deux attributs
priv&eacute;s <code>x</code>
et <code>y</code>
r&eacute;els correspondant &agrave; l'abscisse et &agrave;
l'ordonn&eacute;e de ce point;</li>
<li>d'un constructeur sans
argument, qui cr&eacute;e le point de
coordonn&eacute;es (0,0);</li>
<li>d'un constructeur recevant
deux arguments r&eacute;els, qui sont
respectivement l'abscisse et l'ordonn&eacute;e du point;</li>
<li>de deux accesseurs <code>public
double getX()</code> et <code>public
double getY()</code> pour l'abscisse
et l'ordonn&eacute;e; on ne
fournira pas de modificateurs;</li>
<li>d'une m&eacute;thode <code>public
void translation ( double vx,
double vy )</code> permettant de
translater un point, ainsi que d'une
m&eacute;thode <code>public
Point imageParTranslation( double vx,
double vy )</code> permettant de
construire l'image d'un point par une
translation de vecteur <code>(vx,vy)</code>;</li>
<li>de la m&eacute;thode <code>public
String toString()</code>
affichant les coordonn&eacute;es du point sous la forme (x,y).</li>
</ul>
<p> <strong>6.2</strong>
Tester cette classe avec le code suivant :</p>
<blockquote>
<pre> public class Geometrie {<br> public static void main() {<br> Point p1, p2, p3;<br> p1 = new Point();<br> System.out.println( "Cr&eacute;ation du point p1 : " + p1 );<br> p2 = new Point( 1, 2 );<br> System.out.println( "Cr&eacute;ation du point p2 : " + p2 );<br><br> System.out.println( "\nTranslation de vecteur (3,4) ..." );<br><br> p1.translation( 3, 4 );<br> System.out.println( "Le point p1 apr&egrave;s translation : " + p1 );<br><br> p3 = p2.imageParTranslation( 3, 4 );<br> System.out.println( "L'image du point p2 apr&egrave;s translation : " + p3 );<br> System.out.println( "Mais p2 n'a pas chang&eacute;, p2 : " + p2 );<br> }<br>}<br></pre>
</blockquote>
<p> Il faut obtenir le
r&eacute;sultat suivant :</p>
<blockquote>
<pre> Cr&eacute;ation du point p1 : (0, 0)<br>Cr&eacute;ation du point p2 : (1, 2)<br><br>Translation de vecteur (3,4) ...<br>Le point p1 apr&egrave;s translation : (3, 4)<br>L'image du point p2 apr&egrave;s translation : (4, 6)<br>Mais p2 n'a pas chang&eacute;, p2 : (1, 2)<br></pre>
</blockquote>
<p> <strong>6.3</strong>
Ajouter &agrave; la classe
pr&eacute;c&eacute;dente :
</p>
<ul>
<li>les
m&eacute;thodes <code>public
static double calculRayon(
double x, double y )</code> et <code>public
static double calculAngle(
double x, double y )</code>,
permettant d'obtenir, &agrave; partir des
coordonn&eacute;es cart&eacute;siennes (x, y) d'un point, ses
coordonn&eacute;es polaires. <br>
<i>Rappel</i>
: les fonctions math&eacute;matiques usuelles sont
d&eacute;finies dans la classe <code>Math</code>
de <code>java.lang</code>.</li>
<li>les m&eacute;thodes de
classe permettant d'effectuer la
conversion inverse : <code>public
static double calculAbscisse( double
r, double t )</code> et <code>public
static double calculOrdonnee(
double r, double t )</code>;</li>
<li>les m&eacute;thodes <code>public
double getRayon()</code> et <code>public
double getAngle()</code> qui
fournissent
les coordonn&eacute;es polaires d'un point.</li>
</ul>
<span style="font-family: Arial;">
<ul>
</ul>
</span>
</span></div>
</span>
</span>
</body>
</html>