TD04

Universit´e de Nice-Sophia Antipolis vendredi 30 septembre 2016
POLYTECH. CiP2 Dur´ee: 3h
Algorithmique et Programamtion Java
Travaux Pratiques – S´eance no4
1 La classe Complexe
Un programme Java est une collection de classes. Nous avons d´ej`a vu qu’il devait en compor-
ter au moins une contenant la fonction main. Un programme Java en cours d’ex´ecution est une
interaction d’objets. Les classes d´ecrivent des objets poss´edant les mˆemes propri´et´es.
Nous allons d´efinir une classe Complexe permettant de repr´esenter des nombres complexes. Un
objet complexe est constitu´e d’une partie r´eelle et d’une partie imaginaire, toutes deux de type
r´eel.
1) Tout d’abord, cr´eez un r´epertoire que vous nommerez Complexe.Les fichiers que vous cr´eerez
par la suite devront tous ˆetre plac´es dans ce r´epertoire.
2) Cr´eez le fichier Complexe.java qui d´eclare la classe Complexe form´ee des deux attributs priv´es
que sont les parties r´eelle et imaginaire, puis compilez cette classe.
/* la cl ass e com pl ex e re pr´es ent e les nom br es m at h´ema ti qu es c om pl exe s */
p u b l i c c l a s s Complexe {
p r i v a t e d o u b l e r´e el ;
p r i v a t e d o u b l e img ;
}
3) Cr´eez le fichier TestComplexe.java, dans lequel vous d´efinirez la classe TestComplexe qui contien-
dra la fonction principale main. Nous l’utiliserons pour tester la classe Complexe. Dans la fonction
main, d´eclarez une variable c1 de type Complexe et cr´eez un objet, `a l’aide de l’op´erateur new que
vous affecterez `a la variable c1. Notez que la variable c1 contient une r´ef´erence `a l’objet de type
Complexe, et non l’objet lui-mˆeme. ´ Ecrivez sur la sortie standard le complexe c1. Compilez cette
classe et ex´ecutez l’application TestComplexe.class.
Le r´esultat qui est affich´e est quelque chose de la forme Complexe@80cc9b4. La proc´edure
System.out.println n’accepte en param`etre qu’une chaˆıne de caract`eres. Si le param`etre n’est
pas de type String, deux cas se pr´esentent : soit il est d’un type de base, et alors il est converti ;
soit le param`etre est un objet, et alors la m´ethode toString de l’objet est appel´ee afin d’avoir une
repr´esentation sous forme de chaˆıne de caract`eres de l’objet. Si cette derni`ere n’existe pas dans
l’objet, d’autres fonctions toString sont recherch´ees, et il en existe au moins une qui donne le
r´esultat que vous avez obtenu.
4) Ajoutez `a la classe Complexe, la m´ethode toString() qui renvoie une chaˆıne de caract`eres de la
forme (r´eel,img). Pour cela, vous utiliserez l’op´erateur +qui concat`ene deux chaˆınes de caract`eres.
5) Recompilez la classe Complexe et ex´ecutez `a nouveau l’application TestComplexe.class. Par
d´efaut, `a quelle valeur est initialis´e un complexe ?
Si l’on veut que la classe Complexe fournisse d’autres initialisations, il va falloir ´ecrire des
constructeurs. Les constructeurs sont des m´ethodes particuli`eres qui ne renvoient aucun r´esultat
et dont le nom est le nom de la classe. Les constructeurs sont ex´ecut´es par l’op´erateur new pour
initialiser les variables membres des objets.
6) ´ Ecrivez un constructeur qui prend en param`etres deux double et les affecte, respectivement, `a
1
la partie r´eelle et `a la partie imaginaire.
7) D´eclarez dans la fonction main la variable c1 et testez votre application.
Co mpl exe c1 = new C omp le xe (32 , -234);
8) Ajoutez dans la fonction main la d´eclaration de la variable c2 :
Co mpl exe c2 = new C omp lex e ();
9) Testez votre application. Que se passe-t-il ?
Et oui, le constructeur par d´efaut n’est plus accessible ! Il faut donc ajouter `a la classe Complexe
un deuxi`eme constructeur, qui initialise les parties r´eelle et imaginaire `a 0.
10) Faites-le. Testez votre application.
11) Ajoutez `a la classe Complexe, la constante Iqui repr´esente le complexe (0,1). Cette constante
sera partag´ee par tous les objets, et devra ˆetre d´eclar´ee static .
Les membres r´eel et img sont priv´es et ne sont pas accessibles `a l’ext´erieur de la classe Complexe.
Ainsi la notation c1.r´eel dans la fonction main est erron´ee. C’est `a la classe, si elle le d´esire, d’offrir
aux clients, des m´ethodes pour acc´eder `a ses donn´ees priv´ees.
12) D´efinissez les m´ethodes partieR´eelle et partieImaginaire qui renvoient les valeurs des parties
r´eelle et imaginaire d’un objet complexe.
13) Compl´etez la fonction main pour tester ces deux m´ethodes.
On veut pouvoir r´ealiser les op´erations math´ematiques standard sur les complexes.
Commen¸cons par programmer les m´ethodes de conversion de la repr´esentation polaire vers la
repr´esentation cart´esienne.
Rappel : Tout complexe cadmet une repr´esentation cart´esienne x+iy et polaire ρeθo`u ρest
la norme et θla phase de c. Le passage d’un syst`eme de coordonn´ees `a l’autre se fait `a l’aide des
formules de conversion :
coordonn´ees polaires coordonn´ees cart´esiennes
ρ=px2+y2x=ρcos(θ)
θ=arctan(y/x)y=ρsin(θ)
14) Ajoutez la m´ethode rho (qui calcule la norme de l’objet courant) `a la classe Complexe.
15) Pr´eparez sur papier l’algorithme de la m´ethode theta (qui calcule la phase de l’objet courant).
D´emontrez de mani`ere formelle sa validit´e. Attention, la fonction arctan est d´efinie de IR vers
−π
2,π 2. Programmez cette m´ethode et ajoutez-la `a la classe Complexe.
Notez que la m´ethode double Math.atan2(double y, double x) r`egle le probl`eme pr´ec´edent.
16) Testez les deux m´ethodes rho et theta.
17) ´ Ecrivez la m´ethode statique polComplexe qui poss`ede deux param`etres de type r´eel repr´esen-
tant la norme et la phase d’un complexe polaire, et qui renvoie un objet de type complexe en
coordonn´ees cart´esiennes. Cette m´ethode poss`ede l’en-tˆete suivant :
p u b l i c s t a t i c C omp lex e po lCom plex e ( double n , double p)
18) Testez cette m´ethode en l’appliquant `a la norme et la la phase de c1. Que pensez-vous du
r´esultat ?
19) Ajoutez des m´ethodes qui effectuent la somme, la soustraction et le produit de l’objet courant
et de leur param`etre de type Complexe. Ces m´ethodes ont les en-tˆetes suivants :
2

public Co mp lex e pl us ( C omp le xe c)
public Co mp lex e mo ins ( C omp le xe c)
public Co mp lex e mu lt ( C omp le xe c)
public C omp le xe d iv ( Co mp le xe c)
Notez que le produit de deux complexes est plus simple `a ´ecrire en utilisant les coordonn´ees
polaires :
ρ(c1×c2) = ρ(c1) ×ρ(c2)
θ(c1×c2) = θ(c1) + θ(c2)
De mˆeme, la division de deux complexes est plus simple `a ´ecrire en utilisant les coordonn´ees
polaires :
ρ(c1/c2) = ρ(c1) ×ρ(c2)
θ(c1/c2) = θ(c1) −θ(c2)
Pensez `a utiliser la m´ethode polComplexe pour le produit.
20) D´efinissez les m´ethodes boolean ´egal(Complexe) et boolean diff´erent(Complexe) qui testent
l’´egalit´e et la diff´erence entre l’objet courant et le complexe transmis en param`etre. On prendra
soin de traiter le probl`eme pos´e par l’op´erateur == sur les r´eels.
2 Un objet ´equation du second degr´e
Il s’agit de d’´ecrire une classe Eq2Degr´e qui repr´esente une ´equation du second degr´e de la forme
ax2+bx +c= 0 avec a6= 0 et ses deux racines de type Complexe.
21) Dans le r´epertoire Complexe, ouvrez un nouveau fichier Eq2Degr´e.java. Dans ce fichier d´efinissez
la classe Eq2Degr´e qui poss`ede trois attributs priv´es, la constante epsilon, pour la pr´ecision des
calculs, et les deux racines, rac1 et rac2 de type Complexe.
22) Ajoutez le constructeur Eq2Degr´e qui poss´ede comme param`etres donn´ees , les trois coef-
ficients de l’´equation et qui calcule les racines rac1 et rac2. Vous utiliserez une m´ethode priv´ee
r´esoudre qui r´esout l’´equation selon la m´ethode vue au tp1 et que vous appellerez depuis le
constructeur.
De plus, ce constructeur v´erifiera que le coefficient du terme de degr´e 2 est non nul et affichera
un message d’erreur dans le cas contraire.
p u b l i c c l a s s Eq 2de gr´e {
p r i v a t e s t a t i c f i n a l d o u b l e ep sil on = 1E -1 0;
private Co mp lex e rac1 , rac 2 ;
/* *
* Con st ru it un obj et Eq 2d egr ´e avec les 3 co ef fi ci en ts a (a !=0) , b et c
* et ca lcul e s es 2 rac ines de ty pe Com ple xe .
*
* @para m a coef fi ci en t <code > doubl e </ code > du t erm e de deg r´e 2
* @para m b coef fi ci en t <code > doubl e </ code > du t erm e de deg r´e 1
* @para m b coef fi ci en t <code > doubl e </ code > du t erm e de deg r´e 0
*/
Eq 2de gr´e ( double a , double b , double c ) {
3
i f ....
}
r ´e so ud re ( a ,b , c );
}
/* *
* An t´e c´e d en t : a , b , c c o ef fi ci en ts r ´e e ls d e l ’ ´e q ua ti on ( a x2+ bx + c = 0)
* C on s´equ en t : ( x - rac 1 ) (x - r ac2 ) = 0
*/
p r i v a t e v oi d r´e sou dre ( double a , double b , double c ) {
....
}
}//fin classe Eq2degr´e
Notez que chaque objet de type Eq2Degr´e d´efinit une ´equation du second degr´e particuli`ere
repr´esent´ee par ses deux racines.
23) Ajoutez `a la classe Eq2Degr´e, les m´ethodes premi`ereRacine et deuxi`emeRacine qui renvoient
respectivement, la premi`ere et la deuxi`eme racine de l’´equation. Ces deux m´ethodes poss`edent les
en-tˆetes suivants :
/* *
* Ren vo ie l a pr emi `e r e ra cin e d e l ’ ´e q ua tio n co ur ant e
*
* @retu rn un < code > Co mple xe </ code >
*
*/
public Complexe premi`ereRacine()
/* *
* Ren vo ie l a de uxi `e m e ra cin e d e l ’ ´e q ua tio n co ur ant e
*
* @retu rn un < code > Co mple xe </ code >
*
*/
public Complexe deuxi`emeRacine()
24) Ouvrez un nouveau fichier TestEq2degr´e.java, et ´ecrivez la classe TestEq2degr´e avec la fonction
main pour tester la classe Eq2Degr´e.
import ja va . io . *;
class TestEq2degr´e {
p u b l i c s t a t i c v o id m ain ( S tri ng [] a rgs ) throws IOException {
Eq 2de gr´e e = new ...
Sy st em . ou t . pr int ln ( .. .. .
}
}
25) Ajoutez `a la classe Eq2Degr´e, la m´ethode toString qui renvoie une repr´esentation des deux
racines sous la forme d’une chaˆıne de caract`eres
26) Dans la fonction main, testez la m´ethode toString en ex´ecutant par exemple l’´enonc´e suivant :
S yst em . o ut . p r in tl n ( e );
4