Filière : DUT - Génie Informatique

Élément : Programmation Orientée Objet

Semestre : II
Pr. Salek RIADI

TD/TP N°2

Exercice 1
Un nombre complexe comporte une partie réelle et une partie imaginaire (partieReelle +
partieImaginaire * i avec i2 = -1). Le programme suivant (TestComplexe.java) contient une
classe Complexe qui permet de représenter les nombres complexes :

/* TestComplexe.java */
class Complexe {
Complexe(double im, double re) {
partieReelle = im;
partieImaginaire = re;
}
public String toString() {
return partieReelle + " + " + partieImaginaire + "i";
}
private double partieReelle;
private double partieImaginaire;
}

public class TestComplexe{

public static void main(String args[]){
Complexe C = new Complexe(2, 3);
System.out.println(C.toString());
}
}

1. Quels résultats fournit ce programme ?

2. Compléter la classe Complexe en ajoutant :
­ des accesseurs (get) et mutateurs (set) pour les différents attributs ;
­ un constructeur par copie Complexe(Complexe C) ;
­ une méthode usuelle permettant l’addition de deux nombres complexes Complexe
ajouter(Complexe C) ;
­ une méthode statique permettant la soustraction de deux nombres complexes void
soustraire(Complexe C1, Complexe C2) ;
3. Modifier la classe TestComplexe afin de tester les nouvelles fonctionnalités de la classe
Complexe.

2022/2023 1/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

Exercice 2
En mathématiques, une suite arithmétique (Arithmetic Sequence) des nombres réels est définie
par récurrence, comme suit :
= + = + .

Où :
 n est un entier naturel strictement positif n ≥ 1 ;
 r est un nombre réel qui représente la raison (rate) de la suite arithmétique ;
 u0 est un nombre réel qui représente le premier terme (initial term) de la suite
arithmétique.
Soit an une suite arithmétique de raison r1 et de premier terme a0, et soit bn une suite
arithmétique de raison r2 et de premier terme b0. La somme de ces deux suites sn = an + bn est
une suite arithmétique de raison (r1 + r2) et de premier terme (a0 + b0).
Le programme source TestArithmeticSequence.java contient une classe
ArithmeticSequence qui permet de représenter les suites arithmétiques et une classe
TestArithmeticSequence qui utilise les fonctionnalités de la classe ArithmeticSequence.
1. Quels résultats fournit ce programme ?
2. Compléter la classe ArithmeticSequence en ajoutant :
­ un attribut rate de type réel ;
­ un attribut initialTerm de type réel ;
­ un constructeur de suite arithmétique public ArithmeticSequence(double r, double
u0) qui reçoit en argument deux paramètres réels la raison et le première terme ;
­ un accesseur getRate et un mutateur setRate pour l’attribut rate ;
­ un accesseur getInitialTerm et un mutateur setInitialTerm pour l’attribut initialTerm ;
­ une méthode getTerm(int n) qui fournit en résultat la valeur de la terme n (un) ;
­ une méthode sumofFirstnTerms(int n) qui fournit en résultat la somme des n premiers
termes de la suite (∑ ).
­ une méthode productofFirstnTerms(int n) qui fournit en résultat le produit des n
premiers termes de la suite (∏ ).
­ une méthode usuelle permettant l’addition de deux suites arithmétiques
ArithmeticSequence addArithmeticSequence(ArithmeticSequence sequence)
­ une méthode statique ArithmeticSequence sumofTwoArithmeticSequences(
ArithmeticSequence sequence1, ArithmeticSequence sequence2) qui fournit en
résultat la somme de deux suites arithmétiques.

2022/2023 2/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

/* TestArithmeticSequence.java */

class ArithmeticSequence{
// … à compléter
}

public class TestArithmeticSequence{

public static void main(String[] args){
ArithmeticSequence u = new ArithmeticSequence(1.0, 1.0);
for(int i=0; i<4; i++)
System.out.println("U" + i + " = " + u.getTerm(i));
ArithmeticSequence v = new ArithmeticSequence(0.0, 0.0);
v.setRate(u.getRate()+1);
v.setInitialTerm(u.productofFirstnTerms(4)-u.sumofFirstnTerms(4));
for(int i=0; i<4; i++)
System.out.println("V" + i + " = " + v.getTerm(i));
v = v.addArithmeticSequence(u);
ArithmeticSequence w = ArithmeticSequence.sumofTwoArithmeticSequences(u, v);
for(int i=0; i<4; i++)
System.out.println("W" + i + " = " + w.getTerm(i));
}
}

Exercice 3
En mathématiques, une suite géométrique (Geometric Sequence) des nombres réels est définie
par récurrence, comme suit :
= × = ×

Où :
 n est un entier naturel strictement positif n ≥ 1 ;
 r est un nombre réel qui représente la raison (rate) de la suite géométrique ;
 u0 est un nombre réel qui représente le premier terme (initial term) de la suite
géométrique.
Soit an une suite géométrique de raison r1 et de premier terme a0, et soit bn une suite géométrique
de raison r2 et de premier terme b0. Le produit de ces deux suites pn = an × bn est une suite
géométrique de raison (r1 × r2) et de premier terme (a0 × b0).
Le programme source TestGeometricSequence.java contient une classe GeometricSequence
qui permet de représenter les suites géométriques et une classe TestGeometricSequence qui
utilise les fonctionnalités de la classe GeometricSequence.
1. Quels résultats fournit ce programme ?
2. Compléter la classe GeometricSequence en ajoutant :

2022/2023 3/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

­ un attribut rate de type réel ;

­ un attribut initialTerm de type réel ;
­ un constructeur de suite géométrique public GeometricSequence(double r, double
u0) qui reçoit en argument deux paramètres réels la raison et le première terme ;
­ un accesseur getRate et un mutateur setRate pour l’attribut rate ;
­ un accesseur getInitialTerm et un mutateur setInitialTerm pour l’attribut initialTerm ;
­ une méthode getTerm(int n) qui fournit en résultat la valeur de la terme n (un) ;
­ une méthode sumofFirstnTerms(int n) qui fournit en résultat la somme des n premiers
termes de la suite (∑ ).
­ une méthode productofFirstnTerms(int n) qui fournit en résultat le produit des n
premiers termes de la suite (∏ ).
­ une méthode usuelle permettant la multiplication de deux suites géométriques
GeometricSequence multiplybyGeometricSequence( GeometricSequence
sequence)
­ une méthode statique GeometricSequence productofTwoGeometricSequences(
GeometricSequence sequence1, GeometricSequence sequence2) qui fournit en
résultat le produit de deux suites géométriques.

/* TestGeometricSequence.java */

class GeometricSequence{
// … à compléter
}

public class TestGeometricSequence{

public static void main(String[] args){
GeometricSequence u = new GeometricSequence(2.0, 1.0);
for(int i=0; i<4; i++)
System.out.println("U" + i + " = " + u.getTerm(i));
GeometricSequence v = new GeometricSequence(0.0, 0.0);
v.setRate(1/u.getRate());
v.setInitialTerm(2 * u.productofFirstnTerms(4));
for(int i=3; i>=1; i--)
System.out.println("V" + i + " = " + v.getTerm(i));
v = v.multiplybyGeometricSequence(u);
GeometricSequence w = GeometricSequence.productofTwoGeometricSequences(u, v);
for(int i=0; i<4; i++)
System.out.println("W" + i + " = " + w.getTerm(i));
}
}

2022/2023 4/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

Exercice 4
En mathématiques, la suite de Syracuse (Syracuse Sequence) d’un nombre entier strictement
positif N > 0 est définie par récurrence comme suit :
 Pour n = 0 :
=
 Pour tout entier naturel strictement positif n ≥ 1:
= 2
3 +1

On note que, après un nombre fini d’itérations, on obtient la séquence de valeurs 4, 2, 1 qui se
répète à l’infini :
 Si N égal à 1 ou 2 ou 4, la valeur maximale de la suite de Syracuse sera 4.
 Pour les autres cas, on peut obtenir la valeur maximale de la suite de Syracuse sans
calculer toutes les termes de la suite. Il suffit de comparer les premiers termes jusqu’à
1.
Exemple : la table suivante présente les termes de u0 à u30 d’une suite de Syracuse avec N = 5 ;
on compare les termes u0, u1, u2, u3, u4 et u5, on trouve que la valeur maximale de cette suite est
16.
u0 u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12 u13 u14 u15 u16 u17 u18 u19 u20 u21 u22 u23 u24 u25 u26 u27 u28 u29 u30
5 16 8 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 4 2 1 4
Le programme source TestSyracuseSequence.java contient une classe SyracuseSequence qui
permet de représenter les suites de Syracuse et une classe TestSyracuseSequence qui utilise
les fonctionnalités de la classe SyracuseSequence.
1. Quels résultats fournit ce programme ?
2. Compléter la classe SyracuseSequence en ajoutant :
­ un attribut N de type entier ;
­ un constructeur de suite de Syracuse public SyracuseSequence(int number) qui reçoit
en argument un nombre entier ;
­ un accesseur getTerm(int n) qui fournit en résultat la valeur de un ;
­ une méthode getNumberofIterationsUntilOne qui fournit en résultat le plus petit indice
n tel que un = 1 ;
­ une méthode getMaximumAltitude qui fournit en résultat la valeur maximale de la suite
de Syracuse ;
­ une méthode getNumberofIterationsBeforeN qui fournit en résultat le plus petit indice
n tel que un+1 < N.
­ une méthode statique getMaximumAltitude qui fournit en résultat la valeur maximale
de plusieurs suites de Syracuse.

2022/2023 5/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

/* TestSyracuseSequence.java */

class SyracuseSequence{
// … à compléter
}

public class TestSyracuseSequence{

public static void main(String[] args){
SyracuseSequence u = new SyracuseSequence(5);
for(int i=0; i<=u.getNumberofIterationsUntilOne(); i++)
System.out.println("U"+ i + " = " + u.getTerm(i));
System.out.println("Nombre d'iterations avant d'atteindre N est : " +
u.getNumberofIterationsBeforeN());
int[] tab = {1, 5, 10, 15, 20};
SyracuseSequence[] sequences = new SyracuseSequence[tab.length];
for(int i=0; i<tab.length; i++){
sequences[i] = new SyracuseSequence(tab[i]);
System.out.println("La valeur maximale de la suite de Syracuse " + tab[i] + " est : "+

sequences[i].getMaximumAltitude());
}
System.out.println("La valeur maximale de toutes les suites de Syracuse 1, 5, 10, 15,
20 est : " + SyracuseSequence.getMaximumAltitude(sequences));
}
}

Exercice 5
Un monôme est une fonction mathématique qui s’écrit sous la forme M(X) = cXd où c
(coefficient) est un nombre réel et d (degré) est un nombre entier. Par exemple : le monôme
3.5X5 représenté par le coefficient c = 3.5 et le degré d = 5.
Un polynôme est une somme de monômes P(X) = ∑ . On peut représenter le polynôme
par un tableau de coefficients. Par exemple, le polynôme 2.5X5+ 2X2+ 0.5 représenté par le
tableau de coefficients suivant : {0.5, 0, 2, 0, 0, 2.5}.
Le programme source TestPolynome.java contient une classe Monome qui permet de
représenter les monômes et une classe Polynome qui permet de représenter les polynômes.
1. Compléter la classe Polynome en ajoutant :
­ un constructeur du polynôme public Polynome(Monome[] ms)) qui reçoit en argument
un tableau de monômes ;
­ un constructeur du polynôme public Polynome(double[] coefs) qui reçoit en argument
un tableau de coefficients ;
­ un constructeur par copie public Polynome (Polynome P) qui reçoit en argument un
Polynome ;

2022/2023 6/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

­ une méthode statique permettant l’addition de deux polynômes public static Polynome
somme(Polynome P, Polynome Q).
2. Compléter la classe TestPolynome afin d’utiliser les fonctionnalités de la classe Polynome.

2022/2023 7/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

/* TestPolynome.java */

class Monome {
private double coeff; // coefficient
private int degre; // degré
// constructeur d'initialisation (paramétré);
public Monome(double c, int d) {
coeff = c;
degre = d;
}
// constructeur par copie
public Monome(Monome m) {
coeff = m.coeff;
degre = m.degre;
}
// méthode statique permet de faire la somme de deux monômes de même degré
public static Monome somme(Monome m1, Monome m2) {
return new Monome(m1.coeff + m2.coeff, m1.degre);
}
}

class Polynome {
private Monome[] monomes; // un tableau de monômes
public Polynome(Monome[] ms) {
// … à completer
}
public Polynome(double[] coefs) {
// … à completer
}
public Polynome(Polynome P) {
// … à completer
}
public static Polynome somme(Polynome P, Polynome Q){
// … à completer
}
}
public class TestPolynome {
public static void main(String arg[]) {
// … à completer
}
}

2022/2023 8/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

Exercice 6
En mathématiques, on peut représenter une matrice de dimension r×c par un tableau
rectangulaire de nombres à r lignes (rows) et c colonnes (columns) :

, , , … , ,
⎡ , , , … , ,
⎤
⎢ … ⎥
, , , , ,
=⎢ ⋮ ⋮ ⋮ ⋱ ⋮ ⋮
⎥
⎢ ⎥
⎢ , , , … , , ⎥
⎣ , , , … , , ⎦

Les nombres qui constituent une matrice sont appelés des éléments. On peut repérer un élément
ei,j par son indice de ligne i (1 ≤ i ≤ r) et son indice de colonne j (1 ≤ j ≤ c).
Par exemple, A est une matrice de dimension 5×4 :
1 6 3 9
⎡1.5 2 0.75 3 ⎤
= ⎢⎢ 0 5 5
⎥
2.5⎥
⎢0.5 1.6 3 2⎥
⎣5 3 2 4⎦

, = 1.6
Le programme source TestMatrix.java contient une classe Matrix qui permet de représenter
les matrices et une classe TestMatrix qui utilise les fonctionnalités de la classe Matrix.
1. Quels résultats fournit ce programme ?
2. Compléter la classe Matrix en ajoutant :
­ un attribut M de type tableau de réels à deux dimensions ;
­ un constructeur de matrice public Matrix(float[][] elements) qui reçoit en argument un
tableau d’éléments ;
­ un accesseur getElement qui fournit en résultat l’élément ei,j en un position donné
(i, j) ;
­ un mutateur setElement pour modifier l’élément ei,j en un position donné (i, j) ;
­ une méthode permettant l’addition de deux matrices public Matrix add(Matrix Mat) ;
­ une méthode statique permettant la multiplication de deux matrices public static Matrix
product(Matrix Mat1, Matrix Mat2).

2022/2023 9/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

/* TestMatrix.java */

class Matrix {

private int number_of_rows; // nombre de lignes

private int number_of_columns; // nombre de colonnes

public Matrix(int r, int c) {

number_of_rows = r;
number_of_columns = c;
M = new float[number_of_rows][number_of_columns];
}

public Matrix(float[][] M_) {

// … à compléter
}

public Matrix add(Matrix Mat) {

// … à compléter
}

public static Matrix product(Matrix Mat1, Matrix Mat2) {

// … à compléter
}

public String toString() {

String str = "";
for (int i = 0; i < number_of_rows; i++) {
for (int j = 0; j < number_of_columns; j++)
str += M[i][j] + "\t";
str += "\n";
}
return str;
}

// … à compléter

2022/2023 10/11
Filière : DUT - Génie Informatique
Élément : Programmation Orientée Objet
Semestre : II
Pr. Salek RIADI

/* TestMatrix.java (suite) */

class TestMatrix {
public static void main(String[] args) {

float T1[][] = { { 1, 0, 0 }, { 0, 1, 0 }, {0, 0, 1} };

Matrix Mat1 = new Matrix(T1);
System.out.println(Mat1.toString());

float T2[][] = { { 1, 4, 9 }, { 5, 5, 5 }, {1, 0, 2} };

Matrix Mat2 = new Matrix(T2);
System.out.println(Mat2.toString());

Matrix Mat3 = new Matrix(3, 2);

for (int i = 0, k=1; i < 3; i++)
for (int j = 0; j < 2; j++, k++)
Mat3.setElement(i, j, k);
System.out.println(Mat3.toString());

Matrix Mat4 = Mat1.add(Mat2);

System.out.println(Mat4.toString());

System.out.println(Matrix.product(Mat1, Mat3).toString());

}
}

2022/2023 11/11