Vous êtes sur la page 1sur 5

Université Paris Diderot JAVA

MASS L2 Année 2007-2008

TP n◦3 - Correction
Classes, tableaux, constructeurs et fractales. . .

Exercice 1
On souhaiterait écrire une méthode renvoyant le maximum d’un tableau, ainsi que l’indice
auquel se trouve ce maximum. Pour ce faire nous allons devoir définir une classe de paire
d’entiers.
1. Écrire dans un nouveau fichier une classe P aireDEntiers, contenant 2 champs privés
entiers valeur et indice (remarquez les conventions d’écriture : un nom de classe commence
toujours par une majuscule, un champ par une minuscule).
Correction : Pour l’ensemble de cet exercice, voir la correction dans le TP précédent.


2. Écrire des méthodes public int getValeur() et public int getIndice() permettant
de récupérer les valeurs des champs privés. On appelle de telles méthodes accesseurs.
3. Écrire des méthodes public void setValeur(int) et public void setIndice(int)
permettant de modifier les valeurs des champs privés. On veillera à ce que l’indice ne
puisse prendre que des valeurs positives. On appelle de telles méthodes modifieurs.
Remarque : quel est l’intérêt de mettre les champs en privé, et d’écrire des accesseurs et
modifieurs ? L’un des éléments de réponse est que l’on a ainsi un contrôle sur les champs.
De cette manière, dans notre exemple, on garantit que l’indice est toujours positif, ce qui
ne serait pas le cas si indice était public.
4. Ouvrir le fichier Exo1 créé au TP précédent, et y ajouter une méthode
public static PaireDEntiers max2(int[] tab) renvoyant à la fois le maximum d’un
tableau, ainsi que l’indice où est situé le maximum.

Exercice 2
Dans cet exercice, nous allons définir une classe Complexe qui permettra de manipuler
des nombres complexes et d’implémenter ainsi certaines opérations algébriques standards. On
prendra soin de tester les méthodes écrites au fur-et-à-mesure dams une méthode main.
1. Écrire une classe Complexe comportant 2 champs publics double re et im (partie réelle
et partie imaginaire).
Correction :
public class Complexe {
public double re;
public double im;
}


1
2. Un constructeur est une méthode qui porte le nom de sa classe et qui ne retourne aucune
valeur (pas même un void). Ajouter un constructeur public Complexe() sans paramètres
qui attribue 0 comme valeur aux champs re et im.
Correction :
public Complexe() {
re=0;
im=0;
}


3. Ajouter un constructeur public Complexe(double re, double im) qui permet de fixer
les valeur des champs re et im de l’instance courante aux doubles re et im placés en
paramètres. Un problème se pose, puisque les noms des champs sont masqués par les
paramètres qui portent leur nom. Pour s’en sortir, on utilise le mot-clé this qui permet
de désigner l’instance courante.
Correction :
public Complexe(double r, double i) {
re=r;
im=i;
}


4. On considère le code suivant :


Complexe c1=new Complexe(2, 3.5);
Complexe c2=c1;
c2.re=-4;
Deug.println(c1.re);
Quel est le résultat affiché ? Pourquoi ?
Correction : Le résultat affiché est -4. c1 et c2 sont juste 2 références pour le même objet. Toute
modification de l’objet référencé par c2 va donc également modifier l’objet référencé par c1.


5. Écrire un dernier constructeur public Complexe(Complexe c) permettant de créer une


copie du Complexe passé en argument.
Correction :
public Complexe(Complexe c) {
re=c.re;
im=c.im;
}


6. Écrire une méthode boolean egal(Complexe c) permettant de comparer 2 complexes.


Pourquoi ne pas utiliser ¨==¨ pour faire une comparaison ?
Correction :
public boolean egal(Complexe c) {
if (re==c.re && im==c.im)
return true
return false;
}

2
ou encore
public boolean egal(Complexe c) {
return (re==c.re && im==c.im);
}
le symbole == comparerait les références et non pas les objets eux-mêmes.
Par exemple dans
Comlexe c1 = new Complexe(2, 3);
Comlexe c2 = new Complexe(2, 3);
if (c1.egal(c2)) //...
la comparaison renverrait faux.


7. Ajouter une méthode public String toString() renvoyant une représentation sous
forme de String du Complexe this.
Correction :
public String toString() {
String res="";
res+=re+" + "+im+" i";
return res;
}


Remarque : Dès lors qu’une classe définit la méthode public String toString(), celle-ci
est appelée implicitement chaque fois qu’une instance de cette classe est utilisée comme
String. Par exemple, si z est un Complexe, "abc"+z signifiera en fait "abc"+z.toString(),
et System.out.println(z) signifiera System.out.println(z.toString()).
8. Écrire une méthode public static void swap(Complexe c1, Complexe c2) permet-
tant de permuter c1 et c2. Par exemple, on voudrait que le code suivant :
Complexe c1=new Complexe(1, 1);
Complexe c2=new Complexe(2, 2);
Complexe.swap(c1, c2)
Deug.println(c1);
affiche ¨2+2i¨.
Pourrait-on écrire une telle méthode pour permuter des entiers ?
Correction :
public static void swap(Complexe c1, Complexe c2) {
double r=c1.re;
double i=c1.im;
c1.re=c2.re;
c1.im=c2.im;
c2.re=r;
c2.im=i;
}
Il serait impossible de permuter des entiers de cette façon. Lorsque l’on écrit une méthode
public static void swap(int i1, int i2)
les arguments entiers sont passés par valeur, car int est un type primitif. Ainsi les entiers passés
en arguments sont intacts (que se passerait-il sinon si on appelait swap(2, 3) ? ?).
Dans le premier cas, si on appelle swap(c3, c4); c1 et c2 sont juste des références vers les mêmes
objets que c3 et c4. Les modifications apportées à ces objets dans la fonction touchent donc des
objets globaux.

3


9. Écrire des méthodes public void conjugue() et public void inverse() qui trans-
forment un complexe en son conjugué ou en son inverse.
Correction :
public void conjugue()
{
im=-im;
}

public void inverse()


{
double modulecarre=re*re+im*im;
re=re/modulecarre;
im=-im/modulecarre;
}

remarquer que ces méthodes ne retournent rien : elles modifient juste le Complexe surlequel elles
sont appelées.


10. Écrire des méthodes publiques public Complexe plus(Complexe c),


public Complexe fois(Complexe c), public Complexe divise(Complexe c),
et public double module() qui implémentent les opérations algébriques classiques sur
les nombres complexes (la racine carrée est donnée par Math.sqrt(double d)).
Correction :
public Complexe plus(Complexe c)
{
Complexe res = new Complexe();
res.re = re + c.re;
res.im = im + c.im;
return res;
}
public Complexe fois(Complexe c)
{
Complexe res = new Complexe();
res.re = re * c.re - im * c.im;
res.im = re * c.im + im * c.re;
return res;
}
public Complexe divise(Complexe c)
{
Complexe c1=new Complexe(c);
c1.inverse();
return fois(c1);
}
ici, on doit renvoyer un nouveau complexe. On doit donc créer un nouveau complexe à l’aide de
new dans le corps de la méthode.
public double module()
{
return Math.sqrt(re*re+im*im);
}

4


11. Ajouter des méthodes plus, et fois qui prennent des double en paramètres. Lorsque
plusieurs méthodes portent ainsi le même nom, on dit qu’elles sont surchargées.
public Complexe plus(double d)
{
Complexe res = new Complexe();
res.re = re + d;
res.im = im;
return res;
}
public Complexe fois(double d)
{
Complexe res = new Complexe();
res.re = re * d;
res.im = im * d;
return res;
}

Exercice 3 optionnel 1 : ensemble de Julia


Ajouter une méthode public void juliaOp(Complexe c) qui remplace this par son carré
auquel on ajoute c.
Considérons, pour c fixé et z0 donné, la suite définie par zi+1 = zi2 + c. L’ensemble de Julia
pour c est l’ensemble des valeurs de z0 telles que la suite soit bornée.
Écrire une méthode int sortie(Complexe c) calculant pour z0 = this le premier indice i
tel que |zi | > 2.
Téléchargez Julia.java sur la page des TPs. Cette classe permet d’afficher une approximation
de l’ensemble de Julia. Compilez-là, et exécutez-là. Essayez de comprendre rapidement son
fonctionnement (en particulier, la méthode paintComponent()).
En vous inspirant de ce code, pourriez-vous essayer d’afficher un ensemble de Mandelbrot ?

Exercice 4 optionnel 2 : racine carrée


Nous avons utilisé ci-dessus la fonction Math.sqrt() pour afficher une racine carrée d’un
réel. Pourriez-vous recoder vous-même cette fonction ?

Vous aimerez peut-être aussi