TD04

Université de Nice-Sophia Antipolis
POLYTECH. CiP2
vendredi 30 septembre 2016
Durée: 3h
la partie réelle et à la partie imaginaire.
7) Déclarez dans la fonction main la variable c1 et testez votre application.
Complexe c1 = new Complexe (32 , -234);
Algorithmique et Programamtion Java
Travaux Pratiques – Séance no 4
8) Ajoutez dans la fonction main la déclaration de la variable c2 :
Complexe c2 = new Complexe ();
1
9) Testez votre application. Que se passe-t-il ?
Et oui, le constructeur par défaut n’est plus accessible ! Il faut donc ajouter à la classe Complexe
un deuxième constructeur, qui initialise les parties réelle et imaginaire à 0.
La classe Complexe
Un programme Java est une collection de classes. Nous avons déjà vu qu’il devait en comporter au moins une contenant la fonction main. Un programme Java en cours d’exécution est une
interaction d’objets. Les classes décrivent des objets possédant les mêmes propriétés.
Nous allons définir une classe Complexe permettant de représenter des nombres complexes. Un
objet complexe est constitué d’une partie réelle et d’une partie imaginaire, toutes deux de type
réel.
1) Tout d’abord, créez un répertoire que vous nommerez Complexe. Les fichiers que vous créerez
par la suite devront tous être placés dans ce répertoire.
2) Créez le fichier Complexe.java qui déclare la classe Complexe formée des deux attributs privés
que sont les parties réelle et imaginaire, puis compilez cette classe.
/* la classe complexe représente les nombres mathématiques complexes */
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éel ;
p r i v a t e d o u b l e img ;
}
3) Créez le fichier TestComplexe.java, dans lequel vous définirez la classe TestComplexe qui contiendra la fonction principale main. Nous l’utiliserons pour tester la classe Complexe. Dans la fonction
main, déclarez une variable c1 de type Complexe et créez un objet, à l’aide de l’opérateur new que
vous affecterez à la variable c1. Notez que la variable c1 contient une référence à l’objet de type
Complexe, et non l’objet lui-même. Écrivez sur la sortie standard le complexe c1. Compilez cette
classe et exécutez l’application TestComplexe.class.
Le résultat qui est affiché est quelque chose de la forme Complexe@80cc9b4. La procédure
System.out.println n’accepte en paramètre qu’une chaı̂ne de caractères. Si le paramètre n’est
pas de type String, deux cas se présentent : soit il est d’un type de base, et alors il est converti ;
soit le paramètre est un objet, et alors la méthode toString de l’objet est appelée afin d’avoir une
représentation sous forme de chaı̂ne de caractères de l’objet. Si cette dernière n’existe pas dans
l’objet, d’autres fonctions toString sont recherchées, et il en existe au moins une qui donne le
résultat que vous avez obtenu.
4) Ajoutez à la classe Complexe, la méthode toString() qui renvoie une chaı̂ne de caractères de la
forme (réel ,img ). Pour cela, vous utiliserez l’opérateur + qui concatène deux chaı̂nes de caractères.
5) Recompilez la classe Complexe et exécutez à nouveau l’application TestComplexe.class. Par
défaut, à quelle valeur est initialisé un complexe ?
Si l’on veut que la classe Complexe fournisse d’autres initialisations, il va falloir écrire des
constructeurs. Les constructeurs sont des méthodes particulières qui ne renvoient aucun résultat
et dont le nom est le nom de la classe. Les constructeurs sont exécutés par l’opérateur new pour
initialiser les variables membres des objets.
10) Faites-le. Testez votre application.
11) Ajoutez à la classe Complexe, la constante I qui représente le complexe (0, 1). Cette constante
sera partagée par tous les objets, et devra être déclarée static .
Les membres réel et img sont privés et ne sont pas accessibles à l’extérieur de la classe Complexe.
Ainsi la notation c1.réel dans la fonction main est erronée. C’est à la classe, si elle le désire, d’offrir
aux clients, des méthodes pour accéder à ses données privées.
12) Définissez les méthodes partieRéelle et partieImaginaire qui renvoient les valeurs des parties
réelle et imaginaire d’un objet complexe.
13) Complétez la fonction main pour tester ces deux méthodes.
On veut pouvoir réaliser les opérations mathématiques standard sur les complexes.
Commençons par programmer les méthodes de conversion de la représentation polaire vers la
représentation cartésienne.
Rappel : Tout complexe c admet une représentation cartésienne x + iy et polaire ρeθ où ρ est
la norme et θ la phase de c. Le passage d’un système de coordonnées à l’autre se fait à l’aide des
formules de conversion :
coordonnées
p polaires
ρ = x2 + y 2
θ = arctan(y/x)
coordonnées cartésiennes
x = ρ cos(θ)
y = ρ sin(θ)
14) Ajoutez la méthode rho (qui calcule la norme de l’objet courant) à la classe Complexe.
15) Préparez sur papier l’algorithme de la méthode theta (qui calcule la phase de l’objet courant).
de manière formelle sa validité. Attention, la fonction arctan est définie de IR vers
Démontrez
− π2 , π2 . Programmez cette méthode et ajoutez-la à la classe Complexe.
Notez que la méthode double Math.atan2(double y, double x) règle le problème précédent.
16) Testez les deux méthodes rho et theta.
17) Écrivez la méthode statique polComplexe qui possède deux paramètres de type réel représentant la norme et la phase d’un complexe polaire, et qui renvoie un objet de type complexe en
coordonnées cartésiennes. Cette méthode possède l’en-tête suivant :
p u b l i c s t a t i c Complexe polComplexe ( d o u b l e n , d o u b l e p )
18) Testez cette méthode en l’appliquant à la norme et la la phase de c1. Que pensez-vous du
résultat ?
6) Écrivez un constructeur qui prend en paramètres deux double et les affecte, respectivement, à
19) Ajoutez des méthodes qui effectuent la somme, la soustraction et le produit de l’objet courant
et de leur paramètre de type Complexe. Ces méthodes ont les en-têtes suivants :
1
2
public
public
public
public
Complexe
Complexe
Complexe
Complexe
i f ....
}
résoudre (a ,b , c );
plus ( Complexe c )
moins ( Complexe c )
mult ( Complexe c )
div ( Complexe c )
}
/* *
* Antécédent : a , b , c coefficients réels de l ’ équation ( ax 2 + bx + c = 0)
* Conséquent : (x - rac1 ) (x - rac2 ) = 0
*/
Notez que le produit de deux complexes est plus simple à écrire en utilisant les coordonnées
polaires :
ρ(c1 × c2)
θ(c1 × c2)
= θ(c1) + θ(c2)
De même, la division de deux complexes est plus simple à écrire en utilisant les coordonnées
polaires :
ρ(c1/c2)
=
θ(c1/c2)
=
ρ(c1) × ρ(c2)
θ(c1) − θ(c2)
Pensez à utiliser la méthode polComplexe pour le produit.
20) Définissez les méthodes boolean égal(Complexe) et boolean différent(Complexe) qui testent
l’égalité et la différence entre l’objet courant et le complexe transmis en paramètre. On prendra
soin de traiter le problème posé par l’opérateur == sur les réels.
2
p r i v a t e v o i d résoudre ( d o u b l e a , d o u b l e b , d o u b l e c ) {
....
}
ρ(c1) × ρ(c2)
=
Un objet équation du second degré
Il s’agit de d’écrire une classe Eq2Degré qui représente une équation du second degré de la forme
ax2 + bx + c = 0 avec a 6= 0 et ses deux racines de type Complexe.
21) Dans le répertoire Complexe, ouvrez un nouveau fichier Eq2Degré.java. Dans ce fichier définissez
la classe Eq2Degré qui possède trois attributs privés, la constante epsilon, pour la précision des
calculs, et les deux racines, rac1 et rac2 de type Complexe.
22) Ajoutez le constructeur Eq2Degré qui posséde comme paramètres données , les trois coefficients de l’équation et qui calcule les racines rac1 et rac2. Vous utiliserez une méthode privée
résoudre qui résout l’équation selon la méthode vue au tp1 et que vous appellerez depuis le
constructeur.
De plus, ce constructeur vérifiera que le coefficient du terme de degré 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 Eq2degré {
p r i v a t e s t a t i c f i n a l d o u b l e epsilon = 1E -10;
p r i v a t e Complexe rac1 , rac2 ;
/* *
* Construit un objet Eq2degré avec les 3 coefficients a ( a !=0) , b et c
* et calcule ses 2 racines de type Complexe .
*
* @param a coefficient < code > double </ code > du terme de degré 2
* @param b coefficient < code > double </ code > du terme de degré 1
* @param b coefficient < code > double </ code > du terme de degré 0
*/
} //fin classe Eq2degré
Notez que chaque objet de type Eq2Degré définit une équation du second degré particulière
représentée par ses deux racines.
23) Ajoutez à la classe Eq2Degré, les méthodes premièreRacine et deuxièmeRacine qui renvoient
respectivement, la première et la deuxième racine de l’équation. Ces deux méthodes possèdent les
en-têtes suivants :
/* *
* Renvoie la première racine de l ’ équation courante
*
* @return un < code > Complexe </ code >
*
*/
p u b l i c Complexe premièreRacine ()
/* *
* Renvoie la deuxième racine de l ’ équation courante
*
* @return un < code > Complexe </ code >
*
*/
p u b l i c Complexe deuxièmeRacine ()
24) Ouvrez un nouveau fichier TestEq2degré.java, et écrivez la classe TestEq2degré avec la fonction
main pour tester la classe Eq2Degré.
i m p o r t java . io .*;
c l a s s TestEq2degré {
p u b l i c s t a t i c v o i d main ( String [] args ) t h r o w s IOException {
Eq2degré e = new ...
System . out . println (.....
}
}
25) Ajoutez à la classe Eq2Degré, la méthode toString qui renvoie une représentation des deux
racines sous la forme d’une chaı̂ne de caractères
26) Dans la fonction main, testez la méthode toString en exécutant par exemple l’énoncé suivant :
System . out . println ( e );
Eq2degré ( d o u b l e a , d o u b l e b , d o u b l e c ) {
3
4