UNIVERSITE DE LA MANOUBA Matière : POO

-----¤¤¤¤----- Classe : I.I. 1A

ECOLE NATIONALE DES SCIENCES DE A-U : 2016-2017
L'INFORMATIQUE
Série N°5 – Les Classes en Java
Exercice n°1
Soit le programme suivant :
// Fichier Point.java
class Point { // deux attributs de type int
int abscisse; int ordonnee;
// constructeur
Point(){ abscisse = 0 ; ordonnee = 0 ; }
// méthode permettant de changer les coordonnées d’un point
void set( int u , int v ){ abscisse = u ; ordonnee = v ; }
// méthode permettant de translater un point
void translate( int u , int v ){ abscisse = abscisse + u ; ordonnee = ordonnee + v ; } }
1. Ajouter à la classe Point la méthode afficher, de type de retour void, de sorte que p.afficher()
affiche à l’écran l’abscisse et l’ordonnée de p.
void affiche(){ System.out.println( "abscisse = " + abscisse + " ordonnee = " + ordonnee ) ; }

2. Ajouter à la classe Point la méthode origine, de type de retour boolean qui teste si les coordonnées
du point sont nulles. Ajouter également une méthode egale telle que p.egale(q) renvoie true si et
seulement si les abscisses et ordonnées des points p et q sont égaux.
boolean origine(){ return ( ( abscisse == 0 ) && ( ordonnee == 0 ) ) ; }
boolean egale( Point q ){ return ( ( abscisse == q.abscisse ) && ( ordonnee == q.ordonnee ) ) ; }

3. Ecrire un deuxième constructeur de la classe Point, dont le prototype est Point( int u , int v ) qui
permet d’initialiser l’abscisse et l’ordonnée avec u et v. Ecrire une seconde méthode set, prenant
en argument un objet de la classe Point, et qui recopie les attributs de ces arguments.
Point( int u , int v ){ abscisse = u ; ordonnee = v ; }
void set( Point q ){ abscisse = q.abscisse ; ordonnee = q.ordonnee ; }

4. Ajouter à la classe Point une méthode symetrie telle que p.symetrie() renvoie un nouvel objet
Point qui représente le symétrique du point p, dans une symétrie centrale par rapport à l’origine du
repère.
Point symetrie(){ Point q = new Point(0-abscisse,0-ordonnee) ; return q ; }
5. On veut numéroter les points au fur et à mesure de leur création. On ajoute donc les variables
suivantes :
static int nombre ; int numero ; où l’attribut numero indique le numéro du point et où la variable
de classe nombre indique combien d’objets ont été créés. Réécrire les constructeurs Point en
conséquence. Réécrire également la méthode afficher pour observer la valeur de ces nouveaux
attributs.
Point(){ abscisse = 0 ; ordonnee = 0 ; nombre++ ; numero = nombre ; }
Point( int u , int v ){ abscisse = u ; ordonnee = v ; nombre++ ; numero = nombre ; }
void affiche(){ System.out.println( "abscisse = " + abscisse + " ordonnee = " + ordonnee + " nombre
de points = " + nombre + " numero = " + numero) ; }

1/5
Exercice n°2
Nous nous proposons dans cet exercice d’écrire une classe implémentant une paire d’entier,
pour cela :
1. Définir une classe Paire dont le constructeur initialise les attributs privés de la paire.
2. Définir une méthode affiche et une fonction main pour tester cette classe.
3. Définir un deuxième constructeur, qui initialisera à 0 les composants de la paire.
4. Définir un troisième constructeur, qui initialisera une paire à l’aide d’une autre paire.
5. Définir des fonctions permettant d’accéder et de modifier chaque élément de la paire. Enrichir la
classe Paire d’une méthode définissant quand une paire est inférieure à une autre selon la règle
lexicographique suivante : (x1, y1) < (x2, y2) ssi (x1 < x2) ou (x1 = x2 et y1 < y2).
public class Paire{
private int first ;
private int second ;
public Paire( int first , int second ){ this.first = first ; this.second = second ; }
public Paire(){ this.first = 0 ; this.second = 0 ; }
public Paire( Paire p ){ this.first = p.first ; this.second = p.second ; }
public int getFirst(){ return first ; }
public int getSecond(){ return second ; }
public void setFirst( int x ){ first = x ; }
public void setSecond( int y ){ second = y ; }
public void affiche(){ System.out.print( "("+ first + ","+ second +")" ) ; }
public static void main( String[] args ){ Paire p1 = new Paire( 1 , 2 ) ; Paire p2 = new Paire() ; Paire
p3 = new Paire( p1 ) ;
p1.affiche() ;
p2.affiche() ;
p3.affiche() ;
p3.setFirst(6) ;
System.out.println( "(" + p3.getFirst() + ","+ p3.getSecond() + ")" ) ; } }
public boolean strictInf( Paire q ){ return ( (this.first < q.first) || (this.first == q.first && this.second <
q.second) ) ; }

Exercice 3
Ecrivez une classe Rationnel qui définit les nombres rationnels.
La classe a les attributs privés suivants :
• numerateur : Le numérateur;
• denominateur : Le dénominateur.
La classe Rationnel doit disposer des constructeurs suivants :
• Rationnel();
• Rationnel(int numerateur, int denominateur);
• Rationnel(Rationnel r).
La classe Rationnel doit contenir des accesseurs (get) et mutateurs (set) pour les différents
attributs.
Elle doit aussi contenir les méthodes :
• void additionner(Rationnel r) : ajout du Rationnel en paramètre;
• void soustraire(Rationnel r) : soustraction du Rationnel en paramètre;
• void multiplier(Rationnel r) : multiplication avec le Rationnel en paramètre;
• void diviser(Rationnel r) : division par Rationnel en paramètre;

2/5
 • double evaluer() : renvoie le résultat sous la forme d'un nombre réel;
• Rationnel inverser() : renvoie le Rationnel inverse ;
• void afficher() : affiche une représentation du rationnel (a/b).
Ecrivez aussi une classe TestRationnel afin de tester la classe Rationnel.
Exercice 4
Fournissez la classe Point conçue de manière à ce que le programme suivant fonctionne
correctement :

class TestPoint
{
public static void main(String[] args)
{
// Création du point de coordonnées x=1 et y=3
Point p1 = new Point(1.0, 3.0);
// Création du point de coordonnées x=5 et y=6
Point p2 = new Point(5.0, 6.0);
// Création du point de coordonnées x=2 et y=7
Point p3 = new Point(2.0, 7.0);
p1.affiche( ); // affiche : p = (1.0 , 3.0)
p2.affiche( ); // affiche : p = (5.0 , 6.0)
p3.affiche( ); // affiche : p = (2.0 , 7.0)

// affiche la distance entre p1 et p2

System.out.println("Distance entre p1 et p2 = " +p1.distance (p2));

// affiche la distance entre p1 et p3

System.out.println("Distance entre p1 et p3 = " + Point.distance(p1,p3));

}
}
Indications :
La distance entre deux points (x1,y1) et (x2,y2) est égale à :

d= (x2− x1) +( y2− y1)

2 2

La classe prédéfinie Math contient des méthodes static permettant de calculer la racine carré et
la puissance d'un certain nombre, voici la déclaration de ces méthodes :
class Math {
// Méthode sqrt : retourne la racine carré de nb
public static double sqrt(double nb) {…}

// Méthode pow : retourne nbpuissance

public static double pow(double nb, double puissance) {…}
//… }
Exercice 4
On considère une classe nommée Polynome représentant des polynômes. Cette classe est dotée
de deux champs, ordre dénotant l’ordre du polynôme (la valeur du plus grand coefficient) et
donnees, un tableau stockant les coefficients du polynôme. Par exemple 2+5x+6x2 aura un ordre
égal à 2 et données égal à {2, 5, 6}.

1/ Voici le squelette de la classe à compléter :

3/5
class Polynome {
private double donnees [ ];
private int ordre;

// Constructeur ayant comme arguments l’ordre et un tableau de données

Polynome(int o, double[] tab) { ... }

// Constructeur par recopie du polynôme en paramètre

Polynome(Polynome p) { ... }

// Retourne un polynôme somme du polynôme courant et le polynôme en paramètre

Polynome ajouter(Polynome p) { ... }

// Retourne un polynôme résultat de la multiplication du polynôme courant par un double en

paramètre
Polynome multiplier(double d) { ... }

// Evaluation du polynôme courant en x

double evaluer(double x) { ... }

// La méthode affiche le polynôme sous sa forme habituelle

void affiche { ... }
}

2/ Tester dans main toutes ces méthodes.

public class polynome {

private double donnees [ ];
private int ordre;
public polynome() {ordre = 0; donnees = new double[1]; }
public polynome(int deg) { ordre = deg; donnees = new double[ordre + 1];}
// Constructeur ayant comme arguments l’ordre et un tableau de données
polynome(int o, double[] tab) { ordre=o; donnees = new double[ordre + 1];
for (int i = 0; i <= ordre; i++) donnees[i] = tab[i];}
private double coefficient(int n) { if (n >= donnees.length) return 0; else return donnees[n]; }
// Constructeur par recopie du polynôme en paramètre
polynome(polynome p) {ordre = p.ordre; donnees = new double[ordre + 1]; for (int i = 0; i <= ordre; i++)
donnees[i] = p.donnees[i];}
// Retourne un polynôme somme du polynôme courant et le polynôme en paramètre
polynome ajouter(polynome p) { polynome resultat = (ordre > p.ordre) ? new polynome(ordre) : new
polynome(p.ordre);
for (int i = 0; i <= resultat.ordre; i++) resultat.donnees[i] = coefficient(i) + p.coefficient(i); return resultat;
}
// Retourne un polynôme résultat de la multiplication du polynôme courant par un double en paramètre

polynome multiplier(double d) {polynome resultat = new polynome(ordre); for (int i = 0; i <=

resultat.ordre; i++) resultat.donnees[i] = d*coefficient(i); return resultat; }
double evaluer(double x) { double res=0;
for (int i=0;i<=ordre;i++) { res+=coefficient(i)*Math.pow(x, i);} return res;}

4/5
 // La méthode affiche le polynôme sous sa forme habituelle
void affiche() {boolean affichePlus = false; if (ordre == -1 || (ordre == 0 && egalite(donnees[0], 0)))
System.out.print(0); else for (int i = ordre; i >= 0; i--) { double coef = coefficient(i); if (!egalite(coef, 0)) if (coef > 0
&& affichePlus) System.out.print("+" + afficheMonome(coef, i)); else { System.out.print(afficheMonome(coef, i));
affichePlus = true; } } System.out.println();
}
private String afficheMonome(double coef, int ordre) { if (ordre == 0) return new
Double(coef).toString(); else if (ordre == 1) return coef + "*X"; else return coef + "*X^" + ordre; }

private boolean egalite(double a, double b) { final double EPSILON = 1E-6; return ((a - b) * (a - b) <
EPSILON * EPSILON); }

public static void main(String[] args) {

double [] tab={2, 5, 6};
int deg=2;
polynome p=new polynome (deg, tab);
p.affiche();
p=p.ajouter(p);
p.affiche();
p=p.multiplier(2);
p.affiche();
System.out.println(p.evaluer(1));
System.out.println(p.toString());
}

5/5