Programmation orientée objet en Java

Filières: SMA-S5 & SMI-S5 A.U:2020/2021.

Concepts de base de la POO: TD2

Exercice 1
Réalisez une classe Point permettant de représenter un point sur un axe. Chaque point sera caractérisé
par un nom (de type char) et une abscisse (de type double). On prévoira:
— Un constructeur recevant en arguments le nom et l’abscisse d’un point.
— Une méthode afficher imprimant le nom du point et son abscisse.
— Une méthode deplacer effectuant une translation définie par la valeur de son argument.
Écrivez un petit programme utilisant cette classe pour crée un point, en afficher les caractéristiques, le
déplacer et en afficher à nouveau les caractéristiques.

Exercice 2
L’objectif est de définir une représentation d’un objet Personne.
1. Sachant qu’une personne est définie à partir de son nom, son prénom et son âge, définissez les
données de la classe Personne.
2. Écrivez une application MesAmis qui utilise un objet p de type Personne et qui demande la saisie
au clavier de ses nom, prénom et âge.

Exercice 3
Réalisez une classe Vecteur3d permettant de manipuler des vecteurs à trois composantes et disposant:
— d’un constructeur à trois arguments,
— d’une méthode d’affichage des coordonnées du vecteur,
— d’une méthode fournissant la norme d’un vecteur,
— d’une méthode statique fournissant la somme de deux vecteurs,
Écrivez un petit programme utilisant cette classe.

Exercice 4
Soit la classe Point définie:
class Point{
. double x, y ; // abscisse et ordonnée
. public Point (double x, double y){ this.x = x ; this.y = y ; }
. public void afficher() { System.out.println ("Coordonnées" + x + " " + y);}
. }
Complétez cette classe, de façon qu’elle implémente une méthode statique de type Point maxNorme
déterminant parmi deux points lequel est le plus éloigné de l’origine et le fournissant en valeur de retour.
Écrivez un petit programme utilisant cette classe.

1/4
2

Exercice 5
1. Considérons le programme suivant.
1. class A2 { 8. A2 x=new A2();
2. public static int i; 9. A2 y=new A2();
3. public int j; 10. A2 z= x;
4. public A2() {i++; j=i;} 11. A2 t= y;
5. } 12. System.out.println(A2.i + " et " + z.j);
6. public class TestStatique { 13. }
7. public static void main(String[] args){ 14.}
(a) Ce programme peut-il être compilé? Si oui, qu’affiche-t-il? Si non, pourquoi?
(b) Même question en supprimant le mot-clé static de la ligne 2 et en remplaçant A2.i par z.i et
z.j par t.j.

Exercice 6
1. Créez une classe nommée Point caractérisée par les membres suivants:
p Deux attributs x et y de type réel. On veut numéroter les points au fur et à mesure de leur
création. On ajoute donc les attributs suivants : static int cpt=0 ; int numero ;
où l’attribut numero indique le numéro de point et où l’attribut de classe cpt indique combien
d’objets ont été créés.
p Un constructeur vide initialisant les attributs par une valeur aléatoire comprise entre 0 et 10.
p Un constructeur initialisant les attributs et comptant le nombre d’objets créés.
p Un constructeur de recopie Point(Point p) appelant le constructeur avec deux paramètres afin
d’initialiser le point courant à ceux de p.
p Une méthode distance(Point p) de type réel retournant la distance entre le point courant et le
point p passé en paramètre.
p Une méthode symétrique() de type Point retournant un point symétrique à l’instance courante.
p Une méthode static String nbr_Points() permettant d’afficher le nombre des points crées.
2. Créez une classe nommée Triangle qui utilise la classe Point et disposant des membres suivants:
p Trois attributs A, B et C de type Point définissant les sommets du triangle.
p Un constructeur ayant trois paramètre de type Point.
p Un constructeur de recopie Triangle(Triangle unT) initialisant le triangle courant à ceux de
unT.
p Une méthode calculerPerimetre() de type réel retournant la somme des côtés du triangle.
p Une méthode setSommetA(double x, double y) qui remplace les coordonnées du sommet A
par x et y.
p Une méthode deplacerSommetA(double dx , double dy ) qui deplace les coordonnées du som-
met A par dx et dy .
p Une méthode getSommets() retournant un tableau de type Point consitutant les sommets du
triangle.
p Une méthode getAbscissesSommets() retournant un tableau des valeurs des abscisses des som-
mets du triangle.

2/4
3/4
 3

Exercice 7
Un nombre complexe est caractérisé par sa partie réelle et sa partie imaginaire. L’opération produit
est définie comme suit: Si c1 = x1 + iy1 et c2 = x2 + iy2 alors c1 ∗ c2 = (x1 x2 − y1 y2 ) + i(x1 y2 + x2 y1 ).
1. Réalisez la classe Complexe qui est caractérisée par :
p Deux attributs réels re et im qui caractérisent les parties réelle et imaginaire.
p Un constructeur initialisant le nombre complexe.
p Un constructeur vide appelant le constructeur de la question précédente et initialisant les
parties réelle et imaginaire à 0.0.
p Une méthode boolean egalite(Complexe c) permettant de tester l’égalité du nombre complexe
courant avec le nombre complexe c passé en paramètre.
p Une méthode static Complexe multiplier(Complexe c1, Complexe c2) retournant le produit
entre c1 et c2.
p Une méthode Complexe multiplier(Complexe c) permettant de multiplier le nombre complexe
courant par le nombre complexe c passé en paramètre.
p Une méthode static void permuter(Complexe c1,Complexe c2) permettant de permuter c1 et
c2.
p Une méthode void afficher() affichant le nombre complexe au format: re + i ∗ im
2. Réalisez une classe nommée IntervalleReel pour créer et représenter les intervalles réels. Elle est
caractérisée par :
p Deux attributs réels ext1 et ext2 qui définissent les extrémités d’un intervalle réel avec la
condition ext1 ≤ ext2 .
p Un constructeur initialisant les attributs de la classe.
p Une méthode boolean appartient(float x) qui permet de vérifier si le nombre x appartient à
l’intervalle courant.

Exercice 8
1. Créez une classe nommée Client caractérisée par les membres suivants :
p Deux attributs nom et cin de type String qui caractérisent le nom et le CIN d’un client.
p Un constructeur permettant d’initialiser tous les attributs.
p Une méthode afficher() permettant d’afficher les informations du client en cours.
2. Créez une classe nommée Compte qui utilise la classe Client et disposant des membres suivants:
p Un attribut solde de type double indiquant la somme d’argent disponible sur le compte. Ce
solde est exprimé en DHs et peut être positif (compte créditeur) ou négatif (compte débiteur).
p Un attribut proprietaire de type Client qui représente un client.
p Un constructeur initialisant les attributs et comptant le nombre d’objets créés.
p Un constructeur de recopie.
3. Ajoutez à la classe Compte:
p Une méthode static String nbr_Comptes() permettant d’afficher le nombre des comptes crées.
p Une méthode void afficher() permettant d’afficher le résumé d’un compte comme suit:
— Propriétaire du compte numéro: ...
— Nom: ...
4

— CIN: ...
— Solde de compte: ...
p Une méthode void deposer(double montant) permettant d’ajouter un montant au solde du
compte.
p Une méthode void retirer(double montant) permettant de retirer un montant au solde du
compte.
p Une méthode void transfererVers(double montant, Compte c) qui transfere un montant de
compte courant vers le compte passé en paramètres(l’argent est retiré d’un compte et déposé
sur l’autre).
p Une méthode double differenceSoldes(Compte c) retournant la valeur absolue de la différence
entre le solde de compte courant et le solde de compte passé en paramètre.
p Une méthode void comparerSoldes(Compte c) qui permet d’afficher le résultat de comparai-
son entre le solde de compte courant et le solde de compte passé en paramètre au format
suivant:"Le solde de compte numéro ... est (<, >, ou =) à le solde de compte numéro ...".
p Une méthode static void permuterComptes(Compte c1,Compte c2) permettant de permuter
c1 et c2.
4. Créez une classe nommée TestCompte permettant de tester les classes Client et Compte avec les
actions suivantes:
p Créer deux clients cl1 et cl2.
p Créer un compte cp1, en fonction de cl1 et d’un solde initiale est égal à 1000 DHs.
p Créer un compte cp2, en fonction de cl2 et d’un solde initiale est égal à 2000 DHs.
p Déposer 2000 DHs sur le premier compte et retirer 500 DHs de deuxième compte.
p Transférer 200 DHs du premier compte vers le deuxième.
p Afficher les informations des comptes.
p Comparer les soldes des deux comptes et afficher la différence entre eux.
p Permuter les comptes et afficher à nouveau les informations des comptes.
p Afficher le nombre des comptes crées.

4/4
 Programmation orientée objet en Java

Filières: MA5 & SMI5 A.U: 2019/2020.

Solution:Concepts de base de la POO: TD4 /TP4

Exercice 1
Réalisez une classe Point permettant de représenter un point sur un axe. Chaque point sera caractérisé
par un nom (de type char) et une abscisse (de type double). On prévoira:
— Un constructeur recevant en arguments le nom et l’abscisse d’un point.
— Une méthode afficher imprimant le nom du point et son abscisse.
— Une méthode deplacer effectuant une translation définie par la valeur de son argument.
Écrivez un petit programme utilisant cette classe pour crée un point, en afficher les caractéristiques, le
déplacer et en afficher à nouveau les caractéristiques.

Correction:
.
class Point{
. private char nom ;
. private double abs ;
. public Point(char c, double x){
. nom=c ;
. abs=x ;
. }
. public void afficher(){System.out.println("Point de nom" + nom + "d’abscise" + abs) ;}
. public void deplacer(double dx){abs+=dx ;}
public class TstPtAxe{
. public static void main(String agrs[]){
. Point b = new point() ;
. b.Point(’D’,5.25) ;
. b.afficher() ;
. b.deplacer(2.25) ;
. b.afficher() ;
. }
}

1/2
2

Exercice 2
L’objectif est de définir une représentation d’un objet Personne.
1. Sachant qu’une personne est définie à partir de son nom, son prénom et son âge, définissez les
données de la classe Personne.
Corection:
public class Personne{
. public int age ;
. public String nom, prenom ;
. }
2. Écrivez une application MesAmis qui utilise un objet Untel de type Personne et qui demande la
saisie au clavier de ses nom, prénom et âge.
Corection:
public class MesAmis{
. import java.util.Scanner ;//On importe la classe Scanner pour la rendre visible.
. public static void main(String [] argument){
. Personne Untel = new Personne() ;. System.out.print ("Entrez votre nom : ") ;
. Scanner clavier=new Scanner(System.in) ;
. Untel.nom = clavier.nextLine() ;
. System.out.print ("Entrez votre prenom : ") ;
. Untel.prenom = clavier.nextLine() ;
. System.out.print ("Entrez votre age : ") ;
. Untel.age = clavier.nextInt() ;
. System.out.print("Vous vous appelez " + Untel.prenom + " ") ;
. System.out.print(Untel.nom + ". Vous avez " + Untel.age + " ans.") ;
. }
}

Exercice 3
Réalisez une classe Vecteur3d permettant de manipuler des vecteurs à trois composantes et disposant:
— d’un constructeur à trois arguments,
— d’une méthode d’affichage des coordonnées du vecteur,
— d’une méthode fournissant la norme d’un vecteur,
— d’une méthode statique fournissant la somme de deux vecteurs,
Écrivez un petit programme utilisant cette classe.

Correction:
class Vecteur3d {
. private double x, y, z ;
. public Vecteur3d (double x, double y, double z){this.x = x ; this.y = y ; this.z = z ;}
. public void affiche () { System.out.println ("<" + x + ", " + y + ", " + z + " >") ;}
 3

. public double norme (){ return (Math.sqrt (x*x + y*y + z*z)) ;}

. public static Vecteur3d somme(Vecteur3d v, Vecteur3d w){
. Vecteur3d s = new Vecteur3d (0, 0, 0) ;
. s.x = v.x + w.x ; s.y = v.y + w.y ; s.z = v.z + w.z ;
. return s ;
. }
} public class TstV3d {
. public static void main (String args[]){
. Vecteur3d v1 = new Vecteur3d (3, 2, 5) ;
. Vecteur3d v2 = new Vecteur3d (1, 2, 3) ;
. Vecteur3d v3 ;
. System.out.print ("v1 = " ) ;
. v1.affiche() ;
. System.out.print ("v2 = " ) ;
. v2.affiche() ;
. v3 = Vecteur3d.somme (v1, v2) ;
. System.out.print ("v1 + v2 = " ) ; v3.affiche() ;
. }
}
v1 = < 3.0, 2.0, 5.0 >
v2 = < 1.0, 2.0, 3.0 >
v1 + v2 = < 4.0, 4.0, 8.0 >

Exercice 4
Soit la classe Point définie:
class Point{
. private double x, y ; // abscisse et ordonnée
. public Point (double x, double y){ this.x = x ; this.y = y ; }
. public void affCoord() { System.out.println ("Coordonnées" + x + " " + y);}
. }
Complétez cette classe, de façon qu’elle implémente une méthode statique de type Point maxNorme
déterminant parmi deux points lequel est le plus éloigné de l’origine et le fournissant en valeur de retour.
Écrivez un petit programme utilisant cette classe.

Correction:
class Point{
. private double x, y ;
. public Point (double x, double y){ this.x = x ; this.y = y ; }
. public void affCoord() { System.out.println ("Coordonnées" + x + " " + y);}
. public static Point maxNorme (Point a, Point b){
. double na = a.x*a.x + a.y*a.y ;
4

. double nb = b.x*b.x + b.y*b.y ;

. if (na>nb) return a ;
. else return b ;
. }
. }
public class MaxNorme {
. public static void main (String args[]) {
. Point p1 = new Point (2, 5);
. System.out.print ("p1 : ") ;
. p1.affiche() ;
. Point p2 = new Point (3, 1) ;
. System.out.print ("p2 : ") ; p2.affiche() ;
. Point p = Point.MaxNorme (p1, p2) ;
. System.out.print ("Max de p1 et p2 : ") ;
. p.affiche() ;
. }
}
p1 : Coordonnees 2.0 5.0
p2 : Coordonnees 3.0 1.0
Max de p1 et p2 : Coordonnees 2.0 5.0

Exercice 5
Considérons le programme suivant.

1. class A2 { 8. A2 x=new A2();

2. public static int i; 9. A2 y=new A2();
3. public int j; 10. A2 z= x;
4. public A2() {i++; j=i;} 11. A2 t= y;
5. } 12. System.out.println(A2.i + " et " + z.j);
6. public class TestStatique { 13. }
7. public static void main(String[] args){ 14.}

1. Ce programme peut-il être compilé? Si oui, qu’affiche-t-il? Si non, pourquoi?

å Oui et affiche 2 et 1
2. Même question en supprimant le mot-clé static de la ligne 2 et en remplaçant A2.i par z.i et z.j
par t.j.
å Oui et affiche 1 et 1
Exercice 6

class Point{
double x, y;
int num;
static int cpt=0;
///////
public Point(){
x = (int) (10*Math.random());
y = (int) (10*Math.random());
}
///////
public Point(double x, double y){
this.x = x;
this.y = y;
cpt++;
num=cpt ;
}
///////
public Point(Point p){this(p.x,p.y);}
///////
public double distance(Point p){
double xdiff, ydiff;
xdiff = x - p.x;
ydiff = y - p.y;
return Math.sqrt(xdiff*xdiff + ydiff*ydiff);
}
///////
public Point symétrique(){returnnew Point(-getX(),-getY());}
///////
}
class Triangle{
public Point A,B,C;
///////
public Triangle(Point A, Point B, Point C) {
this.A= A;
this.B= B;
this.C= C;
}
///////
public Triangle (Triangle unT){
A= unT.A;
B= unT.B;
C= unT.C;
}
///////

1
 publicvoid afficher(){
System.out.println("Triangle de sommets:\n"
+"("+A.x+","+A.y+")\n"+
"("+B.x+","+B.y+")\n"+
"("+C.x+","+C.y+")\n");
}
///////
publicdouble calculerPerimetre(){returnA.distance(B) +B.distance(C) +C.distance(A);}
////////
publicboolean egalite(Triangle unT){returnA==unT.A&&B==unT.B&&C==unT.C;}
////////
publicvoid setSommetA(doublex, doubley){ A.x=x; A.y=y; }
////////
publicvoid deplacerSommetA(doubledx, doubledy){
A.x= A.x+dx; A.y=A.y+dy;}
////////
public Point[] getSommets(){
Point T[] = {A,B,C};
return T;
}
////////
publicdouble [] getAbscissesSommets(){
double []abs = newdouble [3];
Point ab[] =getSommets();
for(inti=0;i<3;i++)
abs[i] = ab[i].x;
return abs;
}
}

2
Exercice 7

/1/////////////////////////////////////////
Import java.util.Scanner;
class Complexe{
double re,im;
Complexe(double re, double im){this.re=re; this.im=im;}
Complexe(){this(0.0,0.0); }
Complexe(Complexe c) {re=c.re ;im=c.im;}
booleane galite(Complexe c) {
if ((re ==c.re) && (im==c.im)) return true;
return false;
}
static Complexe multiplier(Complexe c1, Complexe c2){
Complexe c3 = new Complexe();
c3.re=c1.re*c2.re-c1.im*c2.im;
c3.im=c1.re*c2.im+c1.im*c2.re;
return c3;
}
Complexe multiplier(Complexe c){
Complexe c4 = new Complexe();
c4.re=re*c.re-im*c.im;
c4.im=re*c.im+im*c.re;
return c4;
}
static void permuter(Complexe c1, Complexe c2) {
double r=c1.re , i=c1.im;
c1.re=c2.re; c1.im=c2.im;
c2.re=r; c2.im=i;
}
void afficher(){System.out.println(re+" +i*"+im); }
}
/2/////////////////////////////////////////
class IntervalReel{
double ext1, ext2;
IntervalReel(double ext1, double ext2){
if (ext1< ext2) { this.ext1= ext1; this.ext2= ext2; }
else { this.ext1= ext2; this.ext2= ext1; }
}
boolean appartient(double x) {
if ((x>=this.ext1)&&(x<=this.ext2))
return true;
else
return false;
}
}

//3/////////////////////////////////////////
public class TestComplexe{
public static void main(String arg[]){
1
 Scanner kyb=new Scanner(System.in);
Complexe c1=new Complexe(1,1);
Complexe c2=new Complexe(1,-1);
Complexe c3=Complexe.multiplier(c1,c2);
Complexe c4=c1.multiplier(c2);
System.out.print("c1=");c1.afficher();
System.out.print("c2=");c2.afficher();
System.out.print("produi 1:=");c3.afficher();
System.out.print("produi 2:=");c4.afficher();
//////////////////////////////////
IntervalReelir= new IntervalReel(1,20);
System.out.print("Donner un nombre:");
double x=kyb.nextDouble();
boolean b0=ir.appartient(x);
System.out.println(x+" appartient à ir :"+b0);

}
}

2
Solution 8
1. //////////////
class Client{
private String cin, nom;
//////////////
Client(String c,String n){cin=c;nom=n;}
//////////////
void afficher(){sopln("CIN: "+cin); sopln("NOM: "+nom);}
//////////////
String getNom() {return nom;}String getCin() {return cin;}
void setNom(String n) {nom=n;}void setCin(String c) {cin=c;}
}
2. //////////////
class Compte{
double s; Client p;
Compte(Client p,double s){ this.p=p; this.s=s; }
Compte(Compte c){ p=c.p; s=c.s ;}
3. //////////////
int num;
static int cpt=0;
Compte(Client p,double s){ this.p=p; this.s=s; cpt++;num=cpt ;}
//////////////
Compte(Compte c){p=c.p; s=c.s;num=++cpt;// ou bien cpt++; num=cpt ;}
4. //////////////
static String nbr_Comptes(){return "Le nombre de comptes crées: "+cpt; }
void afficher(){
System.out.println("Propriétaire du compte numéro: "+num);
p.afficher();
System.out.println("Solde de compte: "+s);
}
void deposer(double m){s+=m;}
void retirer(double m){s-=m;}
void transfererVers(double m, Compte c){
this.retirer(m); // ou retirer(m); ou s-=m ou
c.deposer(m);//c.s+=m
}
double differenceSoldes(Compte c){return (Math.abs(s-c.s));}
void comparerSoldes(Compte c) {
if(s>c.s)
System.out.println("Le solde de compte "+num+" est supérieur à le
solde de compte "+c.num);
else if (s<c.s)
System.out.println("Le solde de compte "+num+" est inférieur à le
solde de compte "+c.num);
else

1
 System.out.println("Le solde de compte "+num+" est égal à le solde de
compte "+c.num);
}
static void permuterComptes(Compte c1,Compte c2){
String nom1=c1.p.getNom(), cin1=c1.p.getCin();
double s1=c1.s;
c1.p.setNom(c2.p.getNom());
c1.p.setCin(c2.p.getCin());
c1.s=c2.s;
c2.p.setNom(nom1);
c2.p.setCin(cin1);
c2.s=s1;
}
}
5. ////////////////////////////////////////
public class TestCompte{
public static void main(String[] args){
//////////
Client cl1=new Client("AA 1234","Ismaili");
Client cl2=new Client("BB 5678","Alaoui");
//////////
Compte cp1=new Compte(cl1,1000);
Compte cp2=new Compte(cl2,2000);
//////////
cp1.deposer(2000);
cp2.retirer(500);
//////////
cp1.transfererVers(200,cp2);
//////////
cp1.afficher();
cp2.afficher();
//////////
cp1.comparerSoldes(cp2);
double dif=cp1.differenceSoldes(cp2);
System.out.println("La différence des soldes= "+dif+ " DHs");
//////////
Compte.permuterComptes(cp1,cp2);
System.out.println("Les comptes après la permutation:");
cp1.afficher();
cp2.afficher();
//////////
System.out.println(Compte.nbr_Comptes());
}
}

2
 Programmation orientée objet en Java

Filières: SMA-S5 & SMI-S5 A.U:2020/2021

Héritage: TD4

Exercice 1

1. Considérons le programme suivant.

1. class A1 { 11. public class TestConstructeur
2. public int x ; 12. {
3. public A1() {x=1 ;} 13. public static void main(String[] args)
4. public A1(int y) {x=y ;} 14. {
5. } 15. B1 b1 =new B1(12);
6.class B1 extends A1{ 16. B1 b2= new B1() ;
7. public B1() {} 17. B1 b3=new B1("POO");
8. public B1(int i){this(); x=x*i ;} 18. System.out.println(b1.x+"/"+b2.x+"/"+b3.x);
9. public B1(String s){super(17);x- -;} 19. }
10. } 20.}

(a) Que va t-on obtenir à l’écran lors de l’exécution de ce programme ?

(b) Même question en ajoutant l’instruction "super();" au début du constructeur B1() et

en supprimant l’instruction "this();" de la ligne 8.

Exercice 2

Indiquer l’affichage produit par le programme suivant:

1. class A{ 11. public static void main (String [] args){
2. static int x=1; int y=2; 12. A a1=new A(); A a2=new B(); B b=new B();
3. public String f(B obj) {return ("A et B");} 13. System.out.println(a1.f(a1));
4. public String f(A obj) {return ("A et A");} 14. System.out.println(a1.f(a2));
5. } 15. System.out.println(a1.f(b));
6. class B extends A{ 16. System.out.println(a2.f(a1));
7. public String f(B obj) {return ("B et B");} 17. System.out.println(b.f(a2));
8. public String f(A obj) {return ("B et A");} 18. System.out.println(a2.f(b));
19. } 19. }
10. public class Test{ 20. }
2

Exercice 3
1. Créez une classe nommée Point caractérisée par les membres suivants:
p Deux attributs privés x et y de type réel.
p Un constructeur initialisant les attributs à partir de deux réels passés en paramètres.
p Un constructeur de recopie initialisant les attributs à ceux de point passé en para-
mètre.
p Un modificateur et un accesseur pour chaque attribut privé.
2. Créez une classe nommée Hexagone qui utilise la classe Point et disposant des membres
suivants:
p Un tableau H de type Point, contenant les six sommets d’hexagone.
p Un constructeur permettant d’initialiser les attributs et compter le nombre d’objets
créés.
p Un constructeur de recopie appelant le constructeur précédent, initialisant les attri-
buts à ceux d’hexagone passé en paramètre et numérotant les objets créés.
p Une méthode getSommet(int i) retournant le ième sommet d’hexagone.
p Une méthode setSommet(int i, double a, double b) qui remplace les coordonnées de
sommet d’indice i par a et b.
p Une méthode setSommet(int i, Point p) qui remplace les coordonnées de sommet
d’indice i par les coordonnées de point p.
p Une méthode deplacerSommets(double dx , double dy ) permettant de déplacer tous
les sommets d’hexagone par le vecteur (dx , dy ).

Exercice 4
1. Créez une classe Planete caractérisée par les membres suivants:
p Deux attributs privés nom et r indiquent le nom et le rayon d’une planète.
p Un attribut id indiquant le numéro d’une planète.
p Un constructeur permettant d’initialiser les attributs et numéroter les objets créés.
p Un modificateur et un accesseur pour chaque attribut privé.
2. Créez une classe SystemeSolaire qui hérite la classe Planete et disposant :
p D’un tableau T de type Planete de taille N.
p D’un attribut indP indiquant l’indice d’une planète dans le tableau TP.
p D’un constructeur permettant d’initialiser les attributs.
p D’une méthode ajouterPlanete() qui prend en paramètre le nom et le rayon de pla-
nète et crée un objet Planete qu’il stocke dans le tableau T.
p D’une méthode getNom() qui retourne le nom de planète dont l’id est passé en para-
mètre.
p D’une méthode setNom(int id, Planete p) qui change le nom de planète numéro id
par le nom de planète p.
 3

p D’une méthode permuterNoms(Planete p, int id) qui permute le nom de planète p

par le nom de planète numéro id.
p D’une méthode afficher() qui permet d’afficher les caractéristiques des planètes.

Exercice 5
1. Créez une classe Position caractérisée par les membres suivants :
p Deux attributs privés x et y.
p Un constructeur initialisant les attributs.
p Un constructeur vide qui crée une position aléatoire.
p Quatre méthodes goNord(), goEst(), goSud()et goOuest() qui modifieront les coor-
données de la position pour les faire avancer d’un pas dans la direction indiquée par
le nom de la méthode.
p Un modificateur et un accesseur pour chaque attribut privé.
2. Créez une classe Robot hérite la classe Position et caractérisée par les membre ssuivants :
p Un attribut pos de type Position et un attribut nom indiquant le nom d’un robot.
p Un attribut privé dir désignant la direction d’un robot et qui prend une des valeurs
suivantes: "Nord", "Est", "Sud" et "Ouest".
p Un constructeur vide qui crée un robot avec une position aléatoire et un nom et une
direction de votre choix.
p Un constructeur initialisant les attributs.
p Un modificateur et un accesseur pour chaque attribut privé.
3. Créez une classe RobotNG qui hérite la classe Robot et caractérisée par les membres
suivants:
p Un tableau T de type Robot de taille N.
p Un constructeur permettant d’initialiser les attributs.
p Une méthode setPosition(Robot r, double a, double b) qui remplace la position de
robot passé en paramètre par a et b.
p Une méthode deplacerPosition(double dx, double dy) qui déplace les positions de
tous les robots par le vecteur (dx,dy).
p Une méthode avancer(int n) qui permet au robot d’avancer de n pas selon sa direc-
tion:
— si le robot se déplace vers l’Est, x augmente de n pas. Vers l’Ouest x diminue de
n pas.
— si le robot se déplace vers le Nord, y augmente de n pas. Vers le Sud y diminue
de n pas.
p Une méthode tournerDroite() qui permet de tourner le robot à droite de 90°.
— si la direction était "Nord" elle devient "Est".
— si la direction était "Est" elle devient "Sud".
— etc ...
Exercice 1

Exercice 2

1/5
Exercice 3
class Point{
private double x, y;
///////
public Point(double x, double y){this.x = x; this.y = y;}
///////
public Point(Point p){x=p.x;y=p.y;}
///////
public double getX(){return x;}
public double getY(){return y;}
public void setX(double x){this.x = x;}
public void setY(double y){this.y = y;}
////////////////
}
///////////===========================////////////////
class Hexagone{
Point H[]=new Point[6];
static int nombre=0;
int numero ;
///////////////
Hexagone(Point[] H){this.H=H; nombre++; }
///////////////
Hexagone(Hexagone unHex){
this(unHex.H);
numero=nombre;
//ou H= unHex.H; numero=++nombre;
//ou for(int i=0; i<6; i++) H[i]= new Point(unHex.H[i]); numero=++nombre;
}
///////////////
Point getSommet(int i){return H[i-1];}
///////////////
void setSommet(int i,double a, double b){
H[i].setX(a);
H[i].setY(b);
}
///////////////
void setSommet(int i, Point p){
H[i]=p;
//ou bien
//H[i].setX(p.getX()); H[i].setY(p.getY());
}
/////////////
void deplacerSommets(int dx, int dy){
for(int i=0; i<6; i++){
H[i].setX(H[i].getX()+dx);
H[i].setY(H[i].getY()+dy);
}
}
}

2/5
Exercice 4

class Planete{
private String nom;
private double r;
int id;
static int cpt=0;
Planete(String n,double r0){
nom=n;
r=r0;
id=++cpt;
}
////////////////////
public String getNom(){return nom;}
public void setNom(String n) {nom=n;}
public double getR(){return r;}
public void setR(double r0) {r=r0;}
}
///////////////
class SystemeSolaire{
int N=100;
Planete TP[]= new Planete[N];
int indP;
SystemeSolaire(Planete TP[]){this.TP=TP;}
////////////////////
void ajouterPlanete(String n, double r){
Planete unP = new Planete(n,r);
TP[indP]=unP;
indP++;
}
////////////////////
String getNom(int id) {return TP[id-1].getNom();}
////////////////////
void setNom(int id, Planete p) {TP[id-1].setNom(p.getNom());}
////////////////////
void permuterNoms(Planete p, int id){
String r1=getNom(id);
setNom(id,p);
p.setNom(r1);
}
////////////////////
void setR(int id1, int id2){TP[id1].setR(TP[id2].getR());}
////////////////////
void afficher() {
for(Planete v:TP){
System.out.println("Planète numéro:"+v.id);
System.out.println("Nom:"+v.getNom());
System.out.println("Rayon:"+v.getR());
}
}

3/5
Exercice 5

public class Position{

private double x,y ;
///////////////////////////////
public Position(double x0, double y0){x=x0; y=y0;}
///////////////////////////////
public Position(){x = Math.random(); y = Math.random() ;}
///////////////////////////////
void goNord() {y++;} void goEst() {x++;}
void goSud() {y--;} void goOuest() {x--;}
///////////////////////////////
public void setX(double x0){x=x0;}
public double getX(){return x;}
public void setY(double y0){y=y0;}
public double getY(){return y;}
}
////////////////////////////////////////
class Robot extends Position{
public Position pos;
public String nom ;
private String dir ;
////////////////////////////
public Robot(){
super();
nom= "Robot Test";
dir = "Nord";
}
/////////////////////////////
public Robot(Position p, String nom, String dir)
super(p.getX(),p.getY());
pos=p;
this.nom=nom;
this.dir = dir;
}
///////////////////////
public void setDir(String d){dir=d;}
public String getDir(){return dir;}
}
//////////////////////////////
class RobotNG extends Robot{
/////////////////////////////
int N=100;
Robot T[]= new Robot[N];
RobotNG(Robot T[]){this.T=T;}
/////////////////////////////
public void setPosition(Robot r,double a, double b) {
r.pos.setX(a);
r.pos.setY(b);
}

4/5
/////////////////////////////
public void deplacerPositions(int dx, int dy){
for(int i=0; i<N; i++){
T[i].pos.setX(T[i].pos.getX()+dx);
T[i].pos.setY(T[i].pos.getY()+dy);
}
}
/////////////////////////////
public void avancer(int n){
switch(getDir()){
case "Nord": pos.setY(pos.getY()+n);break;
case "Est": pos.setX(pos.getX()+n);break;
case "Sud": pos.setY(pos.getY()-n);break;
case "Ouest": pos.setX(pos.getX()-n);break;
}
}
/////////////////////////////
public void tournerDroite(){
switch (getDir()){
case "Nord": setDir("Est"); break;
case "Est": setDir("Sud"); break;
case "Sud": setDir("Ouest"); break;
case "Ouest": setDir("Nord"); break;
}
}
}

5/5
 Programmation orientée objet en Java

Filières: SMA-S5 & SMI-S5 A.U:2020/2021

Tableaux: TD3

Exercice 1
1. Écrivez une méthode tableauHasard() qui retourne un tableau d’entiers contenant les entiers
tirées au hasard entre −5 et +20, la taille n de tableau étant fournie en paramètre.
2. Écrivez une méthode maxMinTableau(int T[]) retournant un tableau à deux éléments contenant
le minimum et le maximum de T dans l’ordre croissant.
3. Écrivez une méthode sousTab(int tab[],int i, int j) retournant le sous-tableau de tab qui va du
terme d’indice i au terme d’indice j.
Exemple: Si int tab[]={5,4,8,96,74,7,1}; l’appel sousTab(tab,2,5); retourne le tableau {8,96,74,7}.
4. Écrivez une méthode intercaler qui reçoit en paramètre deux tableaux d’entiers de longueurs
quelconques et qui retourne un tableau d’entiers qui contient les éléments des deux tableaux
reçus en paramètre intercalés.
Exemple:
L’appel intercaler(new int[] {1, 2, 3, 4}, new int[] {5, 6}); renvoie le tableau {1, 5, 2, 6, 3, 4}.
5. Écrivez une méthode récursive int sommePositifs(int t[], int ind) retournant la somme des entiers
positifs du tableau t compris entre l’indice ind et la fin du tableau.
Exemple:
. Si int t[]={1,5,-5,10,-10,3}; l’appel sommePositifs(t,2); retourne 13.

Exercice 2
1. Écrivez un programme se servant d’une méthode remplir() pour remplir un tableau d’entiers
passé en paramètre avec des valeurs tirées au hasard entre 0 et n, la valeur de n étant fournie en
paramètre. Affichez le contenu du tableau en utilisant for-each.
2. Écrivez un programme se servant d’une méthode inverser() pour inverser l’ordre d’apparition des
nombres présents dans un tableau d’entiers passé en paramètre.
3. Écrivez un programme se servant d’une méthode occurrence() pour rechercher le nombre d’oc-
currences d’un entier dans un tableau d’entiers passé en paramètre.
4. Écrivez un programme se servant d’une méthode separer() pour réorganiser un tableau d’entiers
de telle manière que tous les nombres pairs soient regroupés au début du tableau et soient suivis
les nombres impairs.

1/1
Exercice 1
1. Écrivez une méthode tableauHasard() qui retourne un tableau d’entiers contenant les
entiers tirées au hasard entre −5 et +20, la taille n de tableau étant fournie en
paramètre.

int [] tableauHasard(int n){

int tab[] = new int[n] ;
for(int i = 0; i < n; i++)
tab[i] = (int) ( (Math.random() * 25) - 5 );
return tab ;
}

2. Écrivez une méthode maxMinTableau(int tab[]) retournant un tableau à deux éléments

contenant le minimum et le maximum de T dans l’ordre croissant.

int [] maxMinTableau(int[] tab){

int l= tab.length;
int max=tab[0],
int min= tab[0];
for (int i=1 ; i<l; i++){
if (tab[i]< min)
min=tab[i];
if (tab[i]> max)
max= tab[i] ;
}
int res[]= {min,max};
return res ;
}

1/5
3. Écrivez une méthode sousTab(int tab[],int i, int j) retournant le sous-tableau de tab qui
va du terme d’indice i au terme d’indice j.
Exemple:
Si int tab[]={5,4,8,96,74,7,1};l’appel sousTab(tab,2,5); retourne le tableau
{8,96,74,7}.

4. Écrivez une méthode intercaler qui reçoit en paramètre deux tableaux d’entiers de
longueurs quelconques et qui retourne un tableau d’entiers qui contient les éléments
des deux tableaux reçus en paramètre intercalés.
Exemple:
L’appel intercaler(new int[] {1, 2, 3, 4}, new int[] {5, 6}); renvoie le tableau {1, 5, 2,
6, 3, 4}.

int[] intercaler (int[] tab1, int[] tab2){

int l1= tab1.length, l2= tab2.length;
int[] res = new int[l1+ l2];
int min = Math.min (l1, l2);
int k = 0;
for (int i = 0; i < min; i++){
res[k++] = tab1[i];
res[k++] = tab2[i];
}
// Ajout éléments du plus long tableau
for (int i = min; i < l1; i++) { res[k++] = tab1[i]; }
for (int i = min; i < l2; i++) { res[k++] = tab2[i]; }
return res;
}

5. Écrivez une méthode récursive int sommePositifs(int t[], int ind) retournant la somme
des entiers positifs du tableau t compris entre l’indice ind et la fin du tableau.
Exemple:
Si int t[]={1,5,-5,10,-10,3}; l’appel sommePositifs(t,2); retourne 13.

2/5
Exercice 2
1. Écrivez un programme se servant d’une méthode remplir() pour remplir un tableau
d’entiers passé en paramètre avec des valeurs tirées au hasard entre 0 et n, la valeur de
n étant fournie en paramètre. Affichez le contenu du tableau en utilisant for-each.

public class Exercice21{

public static void remplir (int tab[],int n) {
int i;
for ( i = 0 ; i<tab.length ; i++ )
tab[i] =(int) (n*Math.random());
}
public static void main(String[] args) {
int tab[] = new int[10];
remplir (tab,10) ;
System.out.println("Le contenu de tableau est:");
for (int ele : tab)
System.out.print(ele+ " ");
}
}

2. Écrivez un programme se servant d’une méthode inverser() pour inverser l’ordre

d’apparition des nombres présents dans un tableau d’entiers passé en paramètre.

public class Exercice22{

public static voidinverser(int tab[]){
int aux; l= tab.length;
for ( int i = 0 ; i<l /2 ; i++ ) {
aux = tab[i];
tab[i] = tab[l -1-i];
tab[l -1-i] = aux;
}
}
public static void main(String[] args) {
Scanner kyb=newScanner(System.in);
System.out.println(" Entrez la taille tableaux: ");

3/5
 int N=kyb.nextInt();
int T[]= new int[N] ;
for (int i=0; i<T.length;i++){
System.out.printf("Entrez l’lément T[%d]:",i);
T[i]=kyb.nextInt();
}
inverser (T);
System.out.println("Le tableau après l’inversion:");
for (inti=0; i<T.length; i++)
System.out.print(T[i]+ " ");
}
}

3. Écrivez un programme se servant d’une méthode occurrence() pour rechercher le

nombre d’occurrences d’un entier dans un tableau d’entiers passé en paramètre.

public class Exercice23{

public static int occurrence(int x, int [] tab){
int cpt = 0, i;
for ( i = 0 ; i<tab.length ; i++ ){
if ( tab[i] == x)
cpt++;
}
return(cpt);
}
public static void main(String[] args) {
Scanner kyb=newScanner(System.in);
System.out.println(" Entrez la taille tableaux: ");
int N=kyb.nextInt();
int T[]= new int[N] ;
for (intI=0; I<T.length; I++){
System.out.printf("Entrez l’lément T[%d]:",I );
T[I]=kyb.nextInt();
}
System.out.println("Tapez la valeur recherchée");
int x=kyb.nextInt();
int nbrOc= occurrence(x,T);
System.out.println("Le nombre d’occurrences de "+x+" est: "+nbrOc) ;
}
}

4. Écrivez un programme se servant d’une méthode separer() pour réorganiser un tableau

d’entiers de telle manière que tous les nombres pairs soient regroupés au début du
tableau et soient suivis les nombres impairs.

public class Exercice44{

public static int [] separer(int [] tab){

4/5
 int [] aux = new int[tab.length];
int i, p = 0 ip = tab.length-1;
for (i = 0 ; i<tab.length ; i++ ) {
if ( (tab[i]%2) == 0 ) {
aux [p] = tab[i];
p++;
}
else {
aux [ip] = tab[i];
ip--;
}
}
return aux;
}
public static void main(String[] args) {
Scanner sc=newScanner(System.in);
System.out.println(" Entrez la taille tableaux: ");
intN=kyb.nextInt();
intT[]= newint[N] ;
for (intI=0; I<T.length; I++){
System.out.printf("Entrez l’lémentT[%d]",I );
T[I]=kyb.nextInt();
}
int Tres []=separer (T);
System.out.println("Le tableau après la séparation:");
for (inti=0; i<Tres.length; i++)
System.out.println(Tres[i]+ " ");
}
}

5/5
 Programmation orientée objet en Java

Filières: MA-S5 & SMI-S5 A.U:2020/2021.

Méthodes en Java: TD

Exercice 1
Si l’on déclare les méthodes(fonctions) suivantes :
int fctA(int x) { return x;}
int fctB(int x) { return ++x;}
int fctC(int x) { return x- -;}
Que contiennent les variables r et n après chacune des instructions suivantes.
Instructions r n
int n=1, r = fctA(n++); ............... ...............
int n=2, r = fctA(++n);
int n=3, r = fctB(n- -);
int n=4, r = fctB(- -n);
int n=5, r = fctC(n);

Exercice 2
1. Écrivez un programme se servant des méthodes Math.min et Math.max pour déterminer le mini-
mum et le maximum de quatre nombres réels entrés au clavier.
2. Écrivez une méthode int dixPuissance(int k) qui à k associe 10k . L’utilisation de Math.pow est
interdite.
3. Écrivez une méthode int supprimeDroite(int n) qui retourne l’entier obtenu en supprimant le
chiffre le plus à droite de n. Si n ne comporte qu’un seul chiffre, le résultat est 0.
Exemple : le résultat de supprimeDroite(3432) est 343.
4. Écrivez une méthode double sommesFractions(int n) qui, pour n donné, retourne la somme:
1 1 1 1
1+ 1
+ 2 + 3 + ... + n
2 2 2 2
5. Écrivez une méthode int sommePairs(int n) qui retourne la somme des entiers pairs inférieurs
ou égaux à un entier n donné.

Exercice 3
1. Écrivez une méthode récursive
 double suite_bizarre(int n) qui calcule le n-ième terme de la suite
1
 3
 si n=0
bizarre, définie par : un =

n−1 − 1
 4u si n>0

1/2
2

2. Écrivez une méthode récursive pgcd(int x, int y) qui calcule le plus grand commun diviseur de
deux nombres entiers positifs.
L’algorithme d’Euclide est basé sur le principe suivant :

 x
 si y=0
pgcd(x, y) =

 pgcd(y,x%y) sinon

3. Écrivez une méthode récursive int fibonacci(int n) qui calcule les valeurs de la série de Fibonacci,
définie par :


 0 si n = 0
un = 1 si n = 1

 un−1 + un−2 si n>1

2/2
Exercice 1

1 2
3 3
4 2
4 3
5 5

Exercice 2

import java.util.Sanner ;
public class MinMax {
public static void main(String[] args) {
Scanner kyb=new Scanner(System.in);
System.out.println("Introduire 4 réels: ");
double a= kyb.nextDouble();
double b= kyb.nextDouble();
double c= kyb.nextDouble();
double d= kyb.nextDouble();
double min=Math.min(Math .min(a,b), Math .min(c,d));
double max=Math.max(Math .max(a,b), Math .max(c,d));
System.out.println("Le minimum des 4 réels est "+min);
System.out.println("Le maximum des 4 réels est "+ max);
}
}

1
double sommesFractions(int n){
double s=0,u=1;
for(int i=0;i<=n;i++)
{
s=s+u;
u=u/2;
}
return s;
}
Rq : Vous pouvez utiliser la fonction Math.pow()

2
double suite_bizarre(int n) {
double u=1.0/3;
if(n==0)
return u;
else if(n>=1)
u=4*suite_bizarre(n-1)-1.0;
return u;
}

int pgcd_rec(int x,int y){

if (y == 0)
return x;
else
return pgcd_rec(y, x%y);
}

int fiboRecursif(int n){

if ((n==0)||(n==1))
return n;
else
return fiboRecursif(n-2)+fiboRecursif(n-1);
}