TP: JAVA

Amine Ramadane
LP-ABD
2022-2023
Table des matières

Exercice 1 :..................................................................................................................................................... 2

Exercice 2 :..................................................................................................................................................... 3

Exercice 3 :..................................................................................................................................................... 6

Exercice 4 :..................................................................................................................................................... 8

Exercice 5 :..................................................................................................................................................... 9

Exercice 6 :................................................................................................................................................... 11

Exercice 7 :................................................................................................................................................... 15

Exercice 8 :................................................................................................................................................... 17

Exercice 9 :................................................................................................................................................... 19

p. 1
Exercice 1 :

Sachant que le taux de TVA est égal à 20 %, écrire un programme qui lit le prix HT d’un article et le nombre
d’articles, et qui affiche à la fin le prix total TTC correspondant. Faire en sorte que les libellés apparaissent
clairement.

Corrigé :

import java.util.Scanner; // importe la classe Scanner pour la lecture de données en entrée

class PrixTotalTTC {
public static void main(String[] args) {
// déclare les variables
double prixHT;
int nombreArticles;
double tauxTVA = 0.2; // le taux de TVA est de 20%
double prixTTC;

Scanner scanner = new Scanner(System.in); // crée un objet Scanner pour lire les données en entrée

// lit le prix HT et le nombre d'articles

System.out.print("Entrez le prix HT de l'article : ");
prixHT = scanner.nextDouble();
System.out.print("Entrez le nombre d'articles : ");
nombreArticles = scanner.nextInt();
scanner.close();

// calcule le prix TTC

prixTTC = (prixHT + prixHT * tauxTVA) * nombreArticles;

// affiche le prix total TTC

System.out.println("Prix total TTC : " + prixTTC + " MAD");
}
}

Test code :

Entrez le prix HT de l'article : 15

Entrez le nombre d'articles : 4

Prix total TTC : 72.0 MAD

Voici comment ce programme fonctionne :

• Tout d'abord, nous importons la classe Scanner pour pouvoir lire les données en entrée.
• Nous déclarons les variables prixHT, nombreArticles, tauxTVA et prixTTC. tauxTVA est initialisé à 0.2, qui
correspond à un taux de TVA de 20%.
• Nous créons un objet Scanner qui nous permettra de lire les données en entrée.
• Nous demandons à l'utilisateur de saisir le prix HT et le nombre d'articles, et nous stockons ces valeurs dans
les variables correspondantes.
• Nous calculons le prix TTC en utilisant la formule prixTTC = (prixHT + prixHT * tauxTVA) * nombreArticles.
• Nous affichons le prix total TTC en utilisant la commande System.out.println().

p. 2
Exercice 2 :

1- Écrire un programme qui calcule la somme de trois nombres entrés au clavier :

• En utilisant 5 variables
• En utilisant 2 variables
2- Ecrire un programme qui lit trois valeurs entières (A, B et C) au clavier et qui affiche la plus grande des
trois valeurs (MAX) et la plus petite d’entre elles (MIN).

Corrigé :

En utilisant 5 variables, écrire un programme qui calcule la somme de trois nombres entrés au clavier :

import java.util.Scanner; // importe la classe Scanner pour la lecture de données en entrée

class Main {
public static void main(String[] args) {
// déclare les variables
int nombre1, nombre2, nombre3;
int somme1, sommeFinal;

Scanner scanner = new Scanner(System.in); // crée un objet Scanner pour lire les données en entrée

// lit les trois nombres

System.out.print("Entrez le premier nombre : ");
nombre1 = scanner.nextInt();
System.out.print("Entrez le deuxième nombre : ");
nombre2 = scanner.nextInt();
System.out.print("Entrez le troisième nombre : ");
nombre3 = scanner.nextInt();
scanner.close();

// calcule la somme1
somme1 = nombre1 + nombre2;
// calcule la sommeFinal
sommeFinal = somme1 + nombre3;

// affiche la somme2
System.out.println("La somme est : " + sommeFinal);
}
}

Test code :

Entrez le premier nombre : 1

Entrez le deuxième nombre : 2

Entrez le troisième nombre : 1

La somme est : 4

p. 3
Voici comment ce programme fonctionne :

• Tout d'abord, nous importons la classe Scanner pour pouvoir lire les données en entrée.
• Nous déclarons les cinq variables nombre1, nombre2, nombre3, somme1 et sommeFinal.
• Nous créons un objet Scanner qui nous permettra de lire les données en entrée.
• Nous demandons à l'utilisateur de saisir les trois nombres et nous stockons ces valeurs dans les variables
correspondantes.
• Nous calculons la somme1 des deux nombres en utilisant la formule somme1 = nombre1 + nombre2.
• Nous calculons la sommeFinal des trois nombres en utilisant la formule sommeFinal = somme1 + nombre3.
• Nous affichons la sommeFinal en utilisant la commande System.out.println().

En utilisant 2 variables, écrire un programme qui calcule la somme de trois nombres entrés au clavier :

import java.util.Scanner; // importe la classe Scanner pour la lecture de données en entrée

class Main
{
public static void main(String[] args) {
int nombre, somme;
Scanner scanner = new Scanner(System.in); // crée un objet Scanner pour lire les données en entrée

// lit le premier nombre

System.out.print("Entrez le premier nombre : ");
nombre = scanner.nextInt();
// Initialiser la somme avec le premier nombre
somme = nombre;

// lit le deuxième nombre

System.out.print("Entrez le deuxième nombre : ");
nombre = scanner.nextInt();
// ajouter à la somme
somme += nombre;

// lit le troisième nombre et l'ajoute à la somme

System.out.print("Entrez le troisième nombre : ");
nombre = scanner.nextInt();
scanner.close();
// ajouter à la somme
somme += nombre;

// affiche la somme
System.out.println("La somme est : " + somme);
}
}

Test code :

Entrez le premier nombre : 1

Entrez le deuxième nombre : 2

Entrez le troisième nombre : 1

La somme est : 4

p. 4
Voici comment ce programme fonctionne :

• Tout d'abord, nous importons la classe Scanner pour pouvoir lire les données en entrée.
• Nous déclarons les cinq variables nombre, somme.
• Nous créons un objet Scanner qui nous permettra de lire les données en entrée.
• Nous demandons à l'utilisateur de saisir le premier nombre et nous stockons cette valeur dans la variable
nombre.
• On initialise la somme avec la valeur de la variable nombre
• Nous demandons à l'utilisateur de saisir le deuxième nombre et nous stockons cette valeur dans la variable
nombre et nous l'ajoutons à la somme en utilisant la formule somme += nombre.
• Nous demandons à l'utilisateur de saisir le troisième nombre et nous stockons cette valeur dans la variable
nombre et nous l'ajoutons à la somme en utilisant la formule somme += nombre.
• Nous affichons la somme en utilisant la commande System.out.println().

2- Ecrire un programme qui lit trois valeurs entières (A, B et C) au clavier et qui affiche la plus grande des trois
valeurs (MAX) et la plus petite d’entre elles (MIN).

import java.util.Scanner; // importe la classe Scanner pour la lecture de données en entrée

class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // crée un objet Scanner pour lire les données en entrée
int a, b, c, min, max;
System.out.println("Entrez la valeur A : ");
a = scanner.nextInt();

System.out.println("Entrez la valeur B : ");

b = scanner.nextInt();

System.out.println("Entrez la valeur C : ");

c = scanner.nextInt();

scanner.close();

// Trouver le minimum et le maximum

min = Math.min(a, Math.min(b, c));
max = Math.max(a, Math.max(b, c));

// Trouver le minimum et le maximum d'une autre manière

/*
min = a;
if (b < min) min = b;
if (c < min) min = c;

max = a;
if (b > max) max = b;
if (c > max) max = c;
*/

System.out.println("MIN = " + min);

System.out.println("MAX = " + max);
}
}

p. 5
 Test code :

Entrez la valeur A: 1

Entrez la valeur B: 2

Entrez la valeur C: 3

MIN = 1

MAX = 3

Voici comment ce programme fonctionne :

• Tout d'abord, nous importons la classe Scanner pour pouvoir lire les données en entrée.
• Nous déclarons les cinq variables a, b, c, min et max.
• Nous créons un objet Scanner qui nous permettra de lire les données en entrée.
• Nous demandons à l'utilisateur de saisir les trois nombres et nous stockons ces valeurs dans les variables
correspondantes.
• On utilise les méthodes min et max de la classe Math pour trouver le minimum et le maximum des trois valeurs
• Nous affichons la min et max en utilisant la commande System.out.println().

Exercice 3 :

1. un programme qui demande successivement n nombres à l’utilisateur, et qui lui affiche ensuite la
somme et la moyenne de ces nombres.

import java.util.Scanner; // importe la classe Scanner pour la lecture de données en entrée

class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

// Demande à l'utilisateur combien de nombres il souhaite entrer

System.out.print("Combien de nombres souhaitez-vous entrer? : ");
int n = scanner.nextInt();

// Initialise la somme et la moyenne à 0

int somme = 0;
double moyenne = 0;

// Boucle pour lire n nombres

for (int i = 1; i <= n; i++) {
System.out.print("Entrez le nombre " + i + " : ");
int num = scanner.nextInt();
somme += num;
}
scanner.close();

// Calcule la moyenne en divisant la somme par le nombre de nombres

moyenne = (double) somme / n;

// Affiche la somme et la moyenne

System.out.println("Somme : " + somme);
System.out.println("Moyenne : " + moyenne);
}
}

p. 6
 Test code :
Entrez le nombre 1 : 2

Entrez le nombre 2 : 4

Entrez le nombre 3 : 1

Somme : 7

Moyenne : 2.3333333333333335

Voici comment ce programme fonctionne :

• Tout d'abord, nous importons la classe Scanner pour pouvoir lire les données en entrée.
• Le programme commence par lire la valeur de n en utilisant la méthode nextInt de Scanner. Ensuite, il
initialise les variables somme et moyenne à 0.
• Ensuite, il utilise une boucle for pour demander successivement n nombres à l'utilisateur et les lire en
utilisant la méthode nextInt. À chaque itération de la boucle, le nombre lu est ajouté à la variable somme.
• Ensuite, le programme calcule la moyenne en divisant la valeur de somme par n. Enfin, il affiche la somme et
la moyenne en utilisant System.out.println.

2. Réécrire le programme précédent, mais cette fois-ci on ne connaît pas d’avance combien l’utilisateur
souhaite saisir de nombres. La saisie des nombres s’arrête lorsque l’utilisateur entre un zéro.

import java.util.Scanner; // importe la classe Scanner pour la lecture de données en entrée

class Main {
public static void main(String[] args) {
Scanner scanner= new Scanner(System.in);
int somme = 0;
int count = 0;
double moyenne = 0;

// Boucle jusqu'à ce que l'utilisateur entre un zéro

while (true) {
System.out.println("Entrez un nombre (0 pour arrêter) : ");
int num = scanner.nextInt();

if (num == 0) break;

somme += num;
count++;
}
scanner.close();

// Calcule la moyenne s'il y a au moins un nombre

if (count > 0) {
moyenne = (double) somme / count;
}

System.out.println("Somme : " + somme);

System.out.println("Moyenne : " + moyenne);
}
}

p. 7
 Test code :
Entrez un nombre (0 pour arrêter) : 1

Entrez un nombre (0 pour arrêter) : 2

Entrez un nombre (0 pour arrêter) : 0

Somme : 3

Moyenne : 1.5

Voici comment ce programme fonctionne :

• Le programme commence par initialiser les variables somme, count et moyenne à 0. Ensuite, il utilise une boucle
while (true) qui s'exécute indéfiniment jusqu'à ce que la condition break soit rencontrée.
• À chaque itération de la boucle, le programme demande un nombre à l'utilisateur et le lit en utilisant la méthode
nextInt de Scanner. S'il s'agit de zéro, la boucle s'arrête grâce à l’instruction break. Sinon, le nombre est ajouté
à la variable somme et le compteur count est incrémenté.
• Ensuite, le programme calcule la moyenne en divisant la valeur de somme par count et en stockant le résultat
dans la variable moyenne, mais seulement s'il y a au moins un nombre (c'est-à-dire si count est supérieur à 0).
Enfin, il affiche la somme et la moyenne en utilisant System.out.println.

Exercice 4 :
Ecrire un programme qui effectue la lecture d’un entier n et affiche si n’est parfait ou non. Un nombre parfait
est un entier positif supérieur à 1, égal à la somme de ses diviseurs ; on ne compte pas comme diviseur le
nombre lui-même. Exemple : 6 est un nombre parfait puisque : 6=1+2+3.

import java.util.Scanner;

class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);

// Demande à l'utilisateur de saisir un entier n

System.out.println("Entrez un entier n : ");
int n = scanner.nextInt();
scanner.close();
// Initialise la somme des diviseurs à 0
int somme = 0;

// Boucle pour trouver tous les diviseurs de n

for (int i = 1; i < n; i++) {
if (n % i == 0) {
somme += i;
}
}

// Vérifie si n est un nombre parfait

if (somme == n) {
System.out.println(n + " est un nombre parfait");
} else {
System.out.println(n + " n'est pas un nombre parfait");
}
}
}

p. 8
Voici comment ce programme fonctionne :
• Le programme commence par demander à l'utilisateur de saisir un entier n en utilisant la méthode nextInt de
Scanner. Ensuite, il initialise la variable somme à 0, qui servira à stocker la somme des diviseurs de n.
• Ensuite, il utilise une boucle for pour parcourir tous les entiers de 1 à n-1 et vérifier s'ils sont des diviseurs de
n. Si c'est le cas, ils sont ajoutés à la variable somme.
• Ensuite, le programme vérifie si somme est égal à n. Si c'est le cas, cela signifie que n est un nombre parfait,
car il est égal à la somme de ses diviseurs. Sinon, n n'est pas un nombre parfait. Le résultat est affiché en
utilisant System.out.println.

Exercice 5 :
1- Ecrire un programme qui déclare et remplisse un tableau, nommé Note, de 10 valeurs réelles en les
mettant toutes à zéro.

import java.util.Arrays;

class Main {
public static void main(String[] args) {
// Déclaration du tableau Note
double[] Note = new double[10];

// Remplissage du tableau Note avec des valeurs à zéro

Arrays.fill(Note, 0.0);

// Affichage du contenu du tableau Note

System.out.println(Arrays.toString(Note));
}
}

2- Soit une matrice carrée A (n, m) de réels. Ecrire un Java programme avec les commentaires inclus
permettant de tableaux 2 dimensions :
• Saisir les valeurs entières de n et m (n<=30 et m<=20).
• Remplir la matrice A par la somme des deux indices i et j (i+j).
• Calculer la matrice transposée de la matrice A.
• Calculer le produit de la matrice A et sa matrice transposée.
• Calculer la trace de la matrice A.
• Déterminer le maximum et sa position, des valeurs des deux diagonales.

p. 9
 import java.util.Scanner;

public class Main {

public static void main(String[] args) {
Scanner sc = new Scanner(System.in);

// Saisie des valeurs entières de n et m

System.out.print("Saisissez la valeur de n (n <= 30) : ");
int n = sc.nextInt();
System.out.print("Saisissez la valeur de m (m <= 20) : ");
int m = sc.nextInt();

// Vérification que n et m sont bien inférieurs ou égaux à 30 et 20 respectivement

if (n > 30 || m > 20) {
System.out.println("Erreur : n et m doivent être inférieurs ou égaux à 30 et 20 respectivement !");
return;
}

// Déclaration et remplissage de la matrice A avec la somme des indices i et j

double[][] A = new double[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
A[i][j] = i + j;
}
}

// Calcul de la matrice transposée de A

double[][] At = new double[m][n];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
At[i][j] = A[j][i];
}
}

// Calcul du produit de A et sa matrice transposée

double[][] AB = new double[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
AB[i][j] = 0.0;
for (int k = 0; k < m; k++) {
AB[i][j] += A[i][k] * At[k][j];
}
}
}

// Calcul de la trace de A
double trace = 0.0;
for (int i = 0; i < n; i++) {
trace += A[i][i];
}

// Détermination du maximum et de sa position des valeurs des deux diagonales

double max = A[0][0];
int pos = 0;
for (int i = 1; i < n; i++) {
if (A[i][i] > max) {
max = A[i][i];
pos = i;
}
}
for (int i = 1; i < n; i++) {
if (A[i][n - i - 1] > max) {
max = A[i][n - i - 1];
pos = i;
}
}

p. 10
Exercice 6 :
Exercice en Java pour la programmation orientée objet, l'héritage et le polymorphisme :

Créez une classe de base Forme avec un champ couleur (une chaîne de caractères) et les méthodes
suivantes :

• setCouleur(String couleur) : qui permet de définir la couleur de la forme

• getCouleur() : qui retourne la couleur de la forme
• afficher() : qui affiche un message indiquant que la méthode afficher() de la classe Forme a été
appelée

class Forme {
private String couleur;

// setCouleur(String couleur) : qui permet de définir la couleur de la forme

public void setCouleur(String couleur) {
this.couleur = couleur;
}

// retourne la couleur de la forme

public String getCouleur() {
return couleur;
}

// affiche un message indiquant que la méthode afficher() de la classe Forme a été appelée
public void afficher() {
System.out.println("La méthode afficher() de la classe Forme a été appelée.");
}
}

p. 11
 Créez deux classes dérivées de Forme : Cercle et Rectangle. La classe Cercle devrait avoir un champ
rayon (un nombre réel) et les méthodes suivantes :

• setRayon(double rayon) : qui permet de définir le rayon du cercle

• getRayon() : qui retourne le rayon du cercle
• calculerPerimetre() : qui calcule et retourne le périmètre du cercle
• calculerSurface() : qui calcule et retourne la surface du cercle
• afficher() : qui affiche les informations sur le cercle (couleur, rayon, périmètre et surface)

class Cercle extends Forme {

private double rayon;

// setRayon(double rayon) : qui permet de définir le rayon du cercle

public void setRayon(double rayon) {
this.rayon = rayon;
}

// getRayon() : qui retourne le rayon du cercle

public double getRayon() {
return this.rayon;
}

// calculerPerimetre() : qui calcule et retourne le périmètre du cercle

public double calculerPerimetre() {
return 2 * Math.PI * this.rayon;
}

// calculerSurface() : qui calcule et retourne la surface du cercle

public double calculerSurface() {
return Math.PI * this.rayon * this.rayon;
}

// afficher() : qui affiche les informations sur le cercle (couleur, rayon, périmètre et surface)
@Override
public void afficher() {

System.out.println("Cercle de couleur "

+ this.getCouleur() + ", de rayon "
+ this.rayon + " et de périmètre "
+ this.calculerPerimetre() + " et de surface " + this.calculerSurface());
}
}

p. 12
 La classe Rectangle devrait avoir les champs longueur et largeur (des nombres réels) et les méthodes
suivantes :

• setLongueur(double longueur) : qui permet de définir la longueur du rectangle

• getLongueur() : qui retourne la longueur du rectangle
• setLargeur(double largeur) : qui permet de définir la largeur du rectangle
• getLargeur() : qui retourne la largeur du rectangle
• calculerPerimetre() : qui calcule et retourne le périmètre du rectangle
• calculerSurface() : qui calcule et retourne la surface du rectangle
• afficher() : qui affiche les informations sur le rectangle (couleur, longueur, largeur, périmètre et
surface)

class Rectangle extends Forme {

private double largeur;
private double hauteur;

public void setLargeur(double largeur) {

this.largeur = largeur;
}

public double getLargeur() {

return this.largeur;
}

public void setHauteur(double hauteur) {

this.hauteur = hauteur;
}

public double getHauteur() {

return this.hauteur;
}

public double calculerPerimetre() {

return 2 * (this.largeur + this.hauteur);
}

public double calculerSurface() {

return this.largeur * this.hauteur;
}

@Override
public void afficher() {
System.out.println("Rectangle de couleur " + this.getCouleur()
+ ", de largeur " + this.largeur
+ ", de hauteur " + this.hauteur
+ " et de périmètre " + this.calculerPerimetre()
+ " et de surface " + this.calculerSurface());
}
}

p. 13
 Tester le code en créant des objets de chaque classe et en appelant leurs méthodes.

class Ex6 {

public static void main(String[] args) {

System.out.println("--------------- cercle ---------------");

Cercle monCercle = new Cercle();

monCercle.setCouleur("rouge");

monCercle.setRayon(5.0);

monCercle.afficher();

System.out.println("--------------- rectangle ---------------");

Rectangle monRectangle = new Rectangle();

monRectangle.setCouleur("bleu");

monRectangle.setLargeur(10.0);

monRectangle.setHauteur(20.0);

monRectangle.afficher();

Résultat :

--------------- cercle ---------------

Cercle de couleur rouge, de rayon 5.0 et de périmètre 31.41592653589793 et de surface

78.53981633974483

--------------- rectangle ---------------

Rectangle de couleur bleu, de largeur 10.0, de hauteur 20.0 et de périmètre 60.0 et de

surface 200.0

p. 14
Exercice 7 :
Code source : https://onlinegdb.com/uldG_GmYp

Exercice en Java pour les interfaces, les classes abstraites et l'héritage et le polymorphisme :

1- Créez une interface Animaux avec une méthode abstraite crier() qui renvoie une chaîne de
caractères.

interface Animaux {
public String crier();
public String seDeplacer();
}

2- Créez une classe abstraite Mammifere qui implémente l'interface Animaux et ajoutez les champs
suivants :
• nom (une chaîne de caractères)
• age (un entier)

Et la méthode suivante :

• seDeplacer() : qui renvoie une chaîne de caractères indiquant comment le mammifère se déplace

abstract class Mammifere implements Animaux {

private String nom;
private int age;

public Mammifere(String nom, int age) {

this.nom = nom;
this.age = age;
}

@Override
public String seDeplacer(){
return "Je me déplace en marchant sur mes quatre pattes.";
};

3- Créez une classe Chien qui hérite de la classe Mammifere et implémente l'interface Animaux.

Ajoutez les champs suivants :

• couleurPelage (une chaîne de caractères)

• race (une chaîne de caractères)

Et les méthodes suivantes :

• crier() : qui renvoie un message indiquant que le chien aboie

• jouer() : qui affiche un message indiquant que le chien joue

p. 15
 class Chien extends Mammifere {
private String couleurPelage;
private String race;

public Chien(String nom, int age, String couleurPelage, String race) {

super(nom, age);
this.couleurPelage = couleurPelage;
this.race = race;
}

@Override
public String crier() {
return "Je suis un chien et je aboie.";
}

public void jouer() {

System.out.println("Je suis un chien et je joue.");
}
}

4- Créez une classe Chat qui hérite de la classe Mammifere et implémente l'interface Animaux. Ajoutez
les champs suivants :
• couleurPelage (une chaîne de caractères)
• race (une chaîne de caractères)

Et les méthodes suivantes :

• crier() : qui renvoie un message indiquant que le chat miaule

• seFaireCaresser() : qui affiche un message indiquant que le chat se fait caresser

class Chat extends Mammifere {

private String couleurPelage;
private String race;

public Chat(String nom, int age, String couleurPelage, String race) {

super(nom, age);
this.couleurPelage = couleurPelage;
this.race = race;
}

@Override
public String crier() {
return "Je suis un chat et je miaule.";
}

public void seFaireCaresser() {

System.out.println("Je suis un chat et je me fais caresser.");
}

p. 16
 Tester le code en créant des objets de chaque classe et en appelant leurs méthodes. Utilisez également
le polymorphisme en utilisant des variables de type Animaux pour stocker vos objets.

public class Ex7 {

public static void main(String[] args) {
Animaux monAnimal1 = new Chien("Bobby", 3, "marron", "labrador");
System.out.println(monAnimal1.crier());
System.out.println(monAnimal1.seDeplacer());

Animaux monAnimal2 = new Chat("Minou", 1, "noir", "siamois");

System.out.println(monAnimal2.crier());
System.out.println(monAnimal2.seDeplacer());
}
}

Je suis un chien et je aboie

Je me déplace en marchant sur mes quatre pattes.
Je suis un chat et je miaule.
Je me déplace en marchant sur mes quatre pattes.

Exercice 8 :
Code source : https://onlinegdb.com/rm_R2UZSJ

1- Créez une interface Shape avec une méthode abstraite calculateArea() qui retourne un nombre réel
et une méthode abstraite calculatePerimeter() qui retourne également un nombre réel.

interface Shape {
public double calculateArea();
public double calculatePerimeter();
}

2- Créez une classe Circle qui implémente l'interface Shape et qui possède les champs suivants :
• radius (un nombre réel)
• pi (un nombre réel qui vaut 3.14)
Et les méthodes suivantes :
• calculateArea() : qui calcule et retourne l'aire du cercle en utilisant la formule pi * radius * radius
• calculatePerimeter() : qui calcule et retourne le périmètre du cercle en utilisant la formule 2 * pi *
radius

class Circle implements Shape {

private double radius;
private final double pi = 3.14;

public Circle(double radius) {

this.radius = radius;
}

public double calculateArea() {

return pi * radius * radius;
}

public double calculatePerimeter() {

return 2 * pi * radius;
}
}

p. 17
 3- Créez une classe Rectangle qui implémente l'interface Shape et qui possède les champs suivants :
• width (un nombre réel)
• height (un nombre réel)
Et les méthodes suivantes :
• calculateArea() : qui calcule et retourne l'aire du rectangle en utilisant la formule width *
height
• calculatePerimeter() : qui calcule et retourne le périmètre du rectangle en utilisant la formule
2 * (width + height)

class Rectangle implements Shape {

private double width;
private double height;

public Rectangle(double width, double height) {

this.width = width;
this.height = height;
}

public double calculateArea() {

return width * height;
}

public double calculatePerimeter() {

return 2 * (width + height);
}
}

Tester le code en créant des objets de chaque classe et en appelant leurs méthodes. Par exemple :

public class Ex8 {

public static void main(String[] args) {
Circle monCercle = new Circle(5);
System.out.println("Aire du cercle : " + monCercle.calculateArea());
System.out.println("Périmètre du cercle : " + monCercle.calculatePerimeter());

Rectangle monRectangle = new Rectangle(10.0, 5.0);

System.out.println("Aire du rectangle : " + monRectangle.calculateArea());
System.out.println("Périmètre du rectangle : " + monRectangle.calculatePerimeter());
}
}

Résultat :

Aire du cercle : 78.5

Périmètre du cercle : 31.400000000000002
Aire du rectangle : 50.0
Périmètre du rectangle : 30.0

p. 18
Exercice 9 :
Code source : https://onlinegdb.com/Me2HL12Iz

Exercice en Java utilisant les collections ArrayList et d'autres types de collections:

1- Créez une classe Etudiant avec les champs suivants :

• nom (une chaîne de caractères)
• prenom (une chaîne de caractères)
• age (un entier)
• une méthode toString() qui renvoie les informations de l'étudiant sous la forme "nom prénom,
âge ans".

class Etudiant {
private String nom;
private String prenom;
private int age;

public Etudiant(String nom, String prenom, int age) {

this.nom = nom;
this.prenom = prenom;
this.age = age;
}

public String toString() {

return nom + " " + prenom + ", " + age + " ans";
}
}

p. 19
 2- Créez une classe GroupeEtudiants avec un champ etudiants qui est une liste d'étudiants (utilisez une
ArrayList ou un autre type de collection).
Ajoutez les méthodes suivantes à cette classe :
• ajouterEtudiant(Etudiant e) : qui ajoute un étudiant à la liste
• supprimerEtudiant(Etudiant e) : qui supprime un étudiant de la liste
• afficherEtudiants() : qui affiche les informations de tous les étudiants de la liste

import java.util.ArrayList;
import java.util.List;

class GroupeEtudiants {
private List<Etudiant> etudiants;

public GroupeEtudiants() {
etudiants = new ArrayList<Etudiant>();
}

public void ajouterEtudiant(Etudiant e) {

etudiants.add(e);
}

public void supprimerEtudiant(Etudiant e) {

etudiants.remove(e);
}

public void afficherEtudiants() {

for (Etudiant e : etudiants) {
System.out.println(e.toString());
}
}
}

p. 20
 3- Créez une classe Universite avec un champ groupes qui est une liste de groupes d'étudiants (utilisez
une ArrayList ou un autre type de collection).
Ajoutez les méthodes suivantes à cette classe :
• ajouterGroupe(GroupeEtudiants g) : qui ajoute un groupe à la liste
• supprimerGroupe(GroupeEtudiants g) : qui supprime un groupe de la liste
• afficherEtudiants() : qui affiche les informations de tous les étudiants de tous les groupes de
l'université

import java.util.ArrayList;
import java.util.List;

class Universite {
private List<GroupeEtudiants> groupes;

public Universite() {
groupes = new ArrayList<GroupeEtudiants>();
}

public void ajouterGroupe(GroupeEtudiants g) {

groupes.add(g);
}

public void supprimerGroupe(GroupeEtudiants g) {

groupes.remove(g);
}

public void afficherEtudiants() {

for (GroupeEtudiants g : groupes) {
g.afficherEtudiants();
}
}
}

p. 21
 4- Tester le code en créant des objets de chaque classe et en appelant leurs méthodes. Par exemple :

public class Ex9 {

public static void main(String[] args) {

Universite monUniversite = new Universite();

GroupeEtudiants groupe1 = new GroupeEtudiants();

groupe1.ajouterEtudiant(new Etudiant("Dupont", "Jean", 20));

groupe1.ajouterEtudiant(new Etudiant("Durand", "Marie", 22));

monUniversite.ajouterGroupe(groupe1);

GroupeEtudiants groupe2 = new GroupeEtudiants();

groupe2.ajouterEtudiant(new Etudiant("Martin", "Alice", 21));

groupe2.ajouterEtudiant(new Etudiant("Petit", "Bob", 23));

monUniversite.ajouterGroupe(groupe2);

monUniversite.afficherEtudiants();

Résultat :
Dupont Jean, 20 ans
Durand Marie, 22 ans
Martin Alice, 21 ans
Petit Bob, 23 ans

p. 22