TP objets

ING 1 - POO Java année 2016 -2017
Premiers exercice sur les classes
TD - TP n°3
Exercice 1 :
Définissez une classe Complexe, pour représenter les nombres de l’ensemble ℂ . Un objet
complexe aura deux attributs, une partie réelle et une partie imaginaire : a+ ib .
Vous définirez un constructeur par défaut qui initialisera les deux attributs à zéro, ainsi qu’un
constructeur qui initialisera un nombre complexe à partir de deux paramètres réels.
Écrire une méthode toString(). La méthode toString permet la conversion d’un objet de type
complexe en une chaîne de caractères. Elle sera utilisée implicitement par certaines méthodes, par
exemple System.out.println. Ainsi l’appel à la méthode System.out.println(c) ; avec c de type
complexe utilisera la méthode toString() de la classe Complexe.
Exercice 2 :
Complétez la classe Complexe avec les opérations d’addition et de multiplication. Testez ces deux
méthodes.
Exercice 3 :
Nous allons dans cet exercice reprendre l’exemple sur les équations du second degré et le coder en
utilisant les principes de la programmation orientée objet (en utilisant des classes et des méthodes).
Le but est de résoudre une équation de la forme : ax 2+ bx+ c=0
Définir une classe Eq2Degré avec les caractéristiques suivantes :
• la classe possède les attributs réels suivants : r1 et r2 (les éventuelles solutions), delta (le
discriminant), a, b et c les coefficients du polynôme ;
• écrire un constructeur Eq2Degré à trois paramètres réels x1,x2 et x3 qui correspondent aux
coefficients du polynôme à résoudre. Ce constructeur affectera les valeurs passées en
paramètre aux attributs a, b et c et calculera la valeur du discriminant delta ;
• écrire une méthode afficheDiscriminant() qui affiche la valeur du discriminant ;
• écrire une méthode résoudre() qui résout l’équation et affecte aux attributs r1 et r2 les
racines des solutions (on ne prendra pas en compte le cas des solutions complexes) ;
• écrire une méthode afficheSolutions() qui affiche les solutions de l’équation.
Utiliser le programme Test.java suivant afin de tester votre classe :
public class Test {
// Résolution de l'équation -2x² + x + 3
public static void main(String [] args){
Eq2Degré equation = new Eq2Degré(-2.0,1.0,+3.0);
equation.afficheDiscriminant();
equation.resoudre();
equation.afficheSolutions();
}
}
Vous devriez obtenir quelque chose qui ressemble à la sortie écran ci-dessous :
java Test
25.0
La première racine est 1.5
La deuxième racine est -1.0
Comme vous avez pu le constater dans notre programme Test.java il est nécessaire d’appeler la
méthode résoudre() avant la méthode afficheSolutions().
• modifier votre classe afin que la méthode afficheSolutions() appelle la méthode résoudre (),
celle-ci ne pourra être appelée à l’extérieur de la classe ;
• modifier votre classe afin qu’elle affiche qu’il n’y a aucune solution si le discriminant est
nul.
Exercice 4 :
Utilisez la classe Complexe afin de représenter les racines de l’équation du second degré si la
valeur du discriminant est négative.
Exercice 5 : Gestion d’une collection d’objets
Définition de la classe Impair
On souhaite afficher les 100 premiers entiers impairs. Pour préparer les exercices suivants, on va le
faire de façon un peu artificielle. On définira la classe Impair, qui représente les nombres impairs.
Pour disposer des nombres impairs, la classe fournit les méthodes suivantes :
•
•
•
•
Impair() : le constructeur
int premier () : retourne le premier des nombres impairs (1)
int suivant () : retourne le nombre impair suivant
◦ si on venait d’appeler la méthode premier(), le suivant est le deuxième nombre impair
◦ sinon, le suivant est le nombre impair qui suit celui qui a été retourné lors du dernier
appel à la méthode suivant().
boolean ilEnReste() : dit si, vu les appels précédents aux méthodes premier() et suivant(),
on peut encore demander un autre nombre impair. Bien que la suite des nombres impairs soit
infinie, nous avons choisi de limiter aux 100 premiers nombres impairs. Donc la méthode
ilEnReste() retourne false si on dépasse cette limite, true si on est encore en mesure de
donner un suivant() inférieur à cette limite.
une fois la classe Impair définie, écrivez une classe Main avec une fonction main, comme on
le fait usuellement. Cette fonction main devra :
◦ créer une instance de la classe Impair, que l’on appellera nb
◦ faire une boucle while qui traduise l’algorithme suivant :
Tant qu’il reste des éléments à afficher dans nb, prendre l’élément suivant et
l’afficher.
•
Vous utiliserez les méthodes premier, suivant et ilEnReste de l’objet nb.
Exercice 6 : notion de tableau dans les classes
Ne pas le faire
On souhaite définir une classe Casier qui permet de stocker 10 entiers, et de les récupérer en cas
de besoin. Vous utiliserez un tableau.
Afin de stocker un entier k dans la cellule i (0 <= i < 10), la classe fournira la méthode :
public void Range(int k, // l’entier à rager,
int i) ; // le numéro de la cellule
•
•
•
pour lire les entiers stockés, on fournira des méthodes premier(), suivant(), ilEnReste()
qui s’utilisent comme dans l’exercice 5.
dans la fonction main de la classe Main, stockez quelques valeurs dans le casier, aux
positions que vous désirez, et affichez l’ensemble du casier, de la même façon que vous
aviez affiché les nombres impairs dans l’exercice précédent.
faites apparaître proprement la taille maximale du tableau de sorte à ne faire qu’une seule
modification du code Java le jour où on veut la modifier.
Exercice 7 : sur les constructeurs
Nous allons créer deux classes, l’une représentant une personne, nommée Personne et l’autre pour
contenir la méthode « main », nommée PersonneMain.
•
•
•
Créer la classe nommée PersonneMain, publique (avec le mot clé public devant class), ne
comportant pas de champ et comportant une unique méthode main() de signature public
static void main(String args[]) ; Au sein de cette méthode, créer, à l’aide de l’opérateur new
une instance d’objet de type Personne (voir la description de la classe Personne ci-dessous)
et appeler sa méthode afficher().
Je vous rappelle qu’un fichier source java peut contenir au plus une classe publique et que,
si c’est le cas, le nom du fichier doit correspondre (y compris les majuscules/minuscules) au
nom de la classe publique.
Créer une classe, nommée Personne, publique, contenant 2 attributs :
◦ un attribut nom de type String
◦ un champ age de type int.
•
Créer un constructeur initialisant tous les champs, de signature Personne(String leNom,
int lAge) initialisant les deux champs de la classe à leNom et lAge.
•
Créer la méthode toString() de signature String toString() qui affiche le nom et l’age au
format décrit ci-après.
Pour un objet de type Personne dont la variable d’instance nom vaut « Martin » et la
variable d’instance age vaut 25, la méthode afficher () affichera à l’écran :
Nom : Martin
Age : 25 ans
•
Tester ces classes en exécutant PersonneMain.
Exercice 8 : extension de la classe Personne
Ajouter un attribut à la classe Personne, de type tableau de réels double[] comptes; susceptible de
représenter les divers soldes des 3 comptes en banque de la personne.
On modifiera le constructeur pour affecter des valeurs aléatoires réelles entre 0 et 1000 € aux
différents comptes si aucun tableau de réel n’est passé en paramètre au constructeur, si un tableau
de 3 réels est passé en paramètre au constructeur, ce sont ces valeurs réelles qui seront affectées à
l’attribut compte.
Adapter le constructeur la méthode toString() qui doit afficher, outre le nom et l’age de la
personne les différents éléments du tableau comptes. Créer, au sein de la classe Personne, la
méthode void diviserParDeux(), qui modifie le tableau comptes en divisant chaque élément par
deux.
Afin de tester que les constructeurs précédents sont bien conformes à ce qu’ils doivent être, dans la
classe PersonneMain, créer deux objets de type Personne avec les deux constructeurs différents.
Appeler la méthode diviserParDeux() sur le premier des objets de type Personne.
Appeler la méthode toString() de ces deux objets. Le code utilisé sera par exemple le suivant :
double[] mesNombres = new double[3] ;
mesNombres[0] = 100.0 ;
mesNombres[1] = 92.0 ;
mesNombres[1] = 942.0 ;
Personne ami1 = new Personne("martin", 30, mesNombres) ;
Personne ami2 = new Personne("dupont", 45) ;
ami1.diviserParDeux() ;
ami1.afficher() ;
ami2.afficher() ;