Vous êtes sur la page 1sur 21

Université de Carthage Département Informatique et Télécoms

Institut Supérieur des Sciences Appliquées et de Technologie de


Mateur

Fascicule TP
Programmation Orientée Objet
(Langage Java)

Pour les étudiants de 2ème année SEIoT/IRS

Aymen Ferjani
aymen.ferjani@issatm.ucar.tn

Année universitaire 2021/2022


SOMMAIRE
Page

TP1: Introduction au langage Java 1

TP2: Introduction au langage Java (suite) 6

TP3: Concepts de base de l’orienté objet 10

TP4: Héritage, Polymorphisme et classe abstraite 13

TP5: Implémentation des interfaces et gestion des exceptions 18


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

TP1: Introduction au langage Java


Objectifs

— Compilation et exécution d’un programme Java.


— Saisie de valeurs.
— Passage de valeurs en ligne de commandes (arguments).
— Utilisation des structures conditionnelles et itératives.

1 Notions de cours
1.1 Compilation et exécution d’un programme Java
Avant de commencer à écrire du code Java, il est préalable d’installer un JDK (Java Deve-
lopment Kit) afin de pouvoir compiler et exécuter notre code.
L’écriture d’un code source Java doit se faire dans un fichier ayant l’extension .java. La
compilation de ce dernier générera un autre fichier ayant l’extension .class et qui contient du
pseudo-code. C’est ce fichier qui est interprété et exécuté par la machine virtuelle Java (JVM).
La JVM est une partie intégrante du JDK.
La compilation et l’exécution d’un fichier Java peuvent se faire de deux manières différentes,
soit avec un IDE(Integrated Development Environment), ou bien avec une console.

1.1.1 Avec un IDE


Plusieurs IDE Java existent sur le marché, comme par exemple NetBeans, Eclipse,
IntelliJ, etc. L’écriture du code y est souvent assisté ainsi que la compilation et l’exécution qui
sont lancées d’un simple clic.

1.1.2 En mode console


Avec la console, il est nécessaire de connaı̂tre la commande de compilation (exemple javac)
car il existe plusieurs compilateurs pour Java. Par contre, l’exécution est toujours effectuée
avec la commande java suivie par le nom de la classe (sans l’extension). Voici un exemple de
compilation et d’exécution d’un fichier Java avec la console Linux :

DossierDeTravail$ javac Hello.java


DossierDeTravail$ java Hello
Bonjour tout le monde

1.2 Structure de base d’un fichier Java


public class NomDeLaClasse {
// Les attributs (propriétés) de cette classe
...
// Les méthodes de cette classe
...
// La méthode principale main doit ^etre présente dans une seule classe du projet
public static void main(String[] args) {
...
}
}

Aymen FERJANI page 1 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

— Un fichier source Java contient une ou plusieurs classes, mais une seule classe déclarée
publique. Le nom du fichier doit correspondre au nom de cette classe.
— Si le projet développé est composé d’un seul fichier, alors ce dernier doit forcément contenir
la méthode principale main.
— En programmation procédurale, les méthodes sont vues comme des fonctions.
— La méthode principale main doit toujours avoir la signature suivante :

public static void main(String[] args)

1.3 Types primitifs des variables

Type Signification

int Entier compris entre -231 et 231 − 1.

double Réel codé sur 64 bits.

char Caractère

boolean Booléen

Remarque
— Il existe aussi les types byte, short et long qui sont des types entiers.
— On trouve aussi le type float qui représente un réel.
— Pour les chaı̂nes de caractères, il est préférable d’utiliser la classe String (qui n’est pas un
type primitif).

1.4 Structures conditionnelles et itératives


Les structures conditionnelles et itératives du langage C sont reprises en Java. Ainsi on
trouve les structures conditionnelles if et switch, mais aussi les structures répétitives for, do
while et while. Il existe aussi une boucle nommée foreach pratique pour parcourir et afficher
les éléments d’un tableau ou d’une collection:

int[] tab = {20, -9, 13, 100, 5};


// parcours et affiche chaque élément du tableau tab
for(int x: tab) {
System.out.println(x);
}

Aymen FERJANI page 2 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

1.5 Saisie de valeurs


A partir de la version Java 5, il est possible d’opérer la saisie de valeurs grâce à la classe
Scanner. Voici un exemple :

import java.util.Scanner; //Importer la classe Scanner pour la saisie

public class ExempleSaisie {


public static void main(String[] args) {
String chaine;
int x;
double y;
// Création d'un objet Scanner
Scanner lectureClavier = new Scanner(System.in);

// Affichage d'un message avant la saisie


System.out.print("Donner une chaine de caractère: ");
// Saisie d'une cha^
ıne de caractère
chaine = lectureClavier.next();

// Affichage d'un message avant la saisie


System.out.print("Donner un entier: ");
// Saisie d'un entier
x = lectureClavier.nextInt();

// Affichage d'un message avant la saisie


System.out.print("Donner un réel: ");
// Saisie d'un réel
y = lectureClavier.nextDouble();
}
}

1.6 Passage de valeurs en ligne de commandes (arguments)


Soit la classe Test suivante :

public class Test {


public static void main(String[] args) {
System.out.println("Le premier argument est " + args[0]);
System.out.println("Le deuxième argument est " + args[1]);
System.out.println("Le troisième argument est " + args[2]);
}
}

Le passage d’arguments à ce programme en mode console se fait ainsi :

DossierDeTravail$ java Test bonjour 158 hello


Le premier argument est bonjour
Le deuxième argument est 158
Le troisième argument est hello

Aymen FERJANI page 3 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

2 Exercices pratiques
Pour chaque exercice, un nouveau projet sera créé.

Exercice 1
Créer la classe Hello ayant le code suivant, puis la tester :

public class Hello {


public static void main(String[] args) {
System.out.println("Bonjour tout le monde");
}
}

Exercice 2
Créer la classe Ex2, puis :
1. Écrire la méthode public int addition(int x, int y, int z) qui retourne la somme de 3
entiers x, y et z.
2. Ajouter la méthode public int max(int x, int y, int z) qui retourne le maximum entre
3 entiers x, y et z.
3. Ajouter la méthode public boolean premier(int x) qui vérifie si x est un nombre
premier ou pas.
4. Tester ces 3 méthodes ainsi:

import java.util.Scanner;
public class Ex2 {
//Définitions des méthodes des questions 1,2 et 3
...
public static void main(String[] args) {
Scanner saisie = new Scanner(System.in);
int a, b, c;
System.out.print("Donner 3 entiers: ");
a = saisie.nextInt();
b = saisie.nextInt();
c = saisie.nextInt();
Ex2 obj = new Ex2(); //Création d'une instance de la classe Ex2
System.out.println(a + "+" + b + "+" + c + "=" + obj.addition(a, b, c));
System.out.println("Le maximum des 3 entiers est " + obj.max(a, b, c));
if(obj.premier(a)) {
System.out.println(a + " est un nombre premier");
}
else {
System.out.println(a + " n'est pas un nombre premier");
}
}
}

Aymen FERJANI page 4 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

Exercice 3
Écrire un programme qui calcule et affiche la somme et le produit de 4 entiers passés en
arguments.
Pour chaque argument, utiliser la méthode prédéfinie Integer.parseInt(x) pour obtenir un
entier à partir de cet argument.

Exercice 4
Écrire un programme permettant de lire un entier positif introduit dans la ligne de commande
et de l’afficher sous forme binaire.

Aymen FERJANI page 5 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

TP2: Introduction au langage Java (suite)


Objectifs

— Saisie de valeurs.
— Passage de valeurs en ligne de commandes (arguments).
— Utilisation des structures conditionnelles et itératives.
— Manipulation des tableau.

1 Notions de cours
1.1 Création et manipulation d’un tableau à taille fixe
La création d’un tableau à taille fixe est effectuée par l’instruction suivante :

type[] nomTableau = new type[NombreElements];

Ici, ”type” désigne un type de base ou bien une classe. Voici un exemple :

// Création d'un tableau de 5 entiers


int[] tab = new int[5];

On peut aussi créer et initialiser un tableau en même temps. Exemple :

// Création et initialisation d'un tableau de 3 entiers


int[] x = {9, 45, -22};

La manipulation des tableaux en Java est identique à celle du langage C, avec


l’avantage de pouvoir connaı̂tre la taille d’un tableau grâce à l’attribut length.

1.2 Exemple
// Création et initialisation d'un tableau de 4 réels
double[] tab = {12.0, 2.6, 0.5, 100.11};

tab[2] = -16.125; // modifie l'élément d'indice 2

// Affichage des éléments du tableau


// tab.length retourne la taille du tableau
for(int i = 0; i < tab.length; i++) {
System.out.println(tab[i]);
}
/* ou bien avec une boucle foreach:
for(double x : tab) {
System.out.println(x);
} */

Aymen FERJANI page 6 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

2 Exercices pratiques
Exercice 1
Écrire la classe Année avec une méthode qui permet de déterminer si une année est bissextile
ou non. Une année est bissextile si on a l’un des deux cas suivants:
— L’année est divisible par 4 et non divisible par 100.
— L’année est divisible par 400.

Exercice 2
Écrire la classe JourSemaine avec une méthode qui, à partir d’un entier représentant un
jour de la semaine (entre 1 et 7), affiche le nom correspondant de ce jour.
Exemples:
jour = 1 => Affichage : ”C’est lundi”
jour = 2 => Affichage : ”C’est mardi”

Exercice 3
Écrire un programme permettant de lire 2 arguments qui sont un entier positif (noté n) et
une chaı̂ne de caractères, puis affiche cette chaı̂ne n fois (sur des lignes différentes).
Par exemple, si l’utilisateur passe comme arguments ”5” et ”Bonjour”, on aura l’affichage sui-
vant:

Bonjour 1 fois

Bonjour 2 fois

Bonjour 3 fois

Bonjour 4 fois

Bonjour 5 fois

Exercice 4
Écrire la classe Parfait avec une méthode qui prend un entier positif, et indique si ce dernier
est un nombre parfait ou pas. Un nombre parfait est égal à la somme de ses diviseurs stricts
(sauf lui-même).
Exemples de nombres parfaits:
6=1+2+3
28 = 1 + 2 + 4 + 7 + 14
496 = 1 + 2 + 4 + 8 + 16 + 31 + 62 + 124 + 248

Exercice 5
Écrire un programme qui calcule et affiche la somme des entiers passés en argument.

Exercice 6
Écrire la classe Pair ayant 2 méthodes. La première permet de remplir un tableau d’entiers.
La deuxième affiche les éléments pairs d’un tableau d’entiers.

Aymen FERJANI page 7 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

import java.util.Scanner;
public class Pair {
public void remplirTab(int[] t)
{ /* remplir t avec des entiers saisis */ }
public void affichagePair(int[] t)
{ /* afficher les éléments pairs de t */ }

public static void main(String[] args) {


int n;
Scanner saisie = new Scanner(System.in);
do {
System.out.print("Donner la taille du tableau(>=2): ");
n = saisie.nextInt();
}
while(n < 2);
int tab[] = new int[n]; //Création d'un tableau de n entiers
Pair p = new Pair(); //Création d'une instance de la classe Pair
p.remplirTab(tab);
System.out.println("Affichage des éléments pairs du tableau:");
p.affichagePair(tab);
}
}

Exercice 7
Écrire la classe Tab ayant 3 méthodes. La première permet de créer un tableau d’entiers de
taille n (à saisir) et de le remplir. La deuxième affiche les éléments d’un tableau d’entiers. La
troisième retroune l’élément le plus grand d’un tableau d’entiers.

import java.util.Scanner;
public class Tab {
public static int[] créationTableau() {
/* 1.saisir la taille du tableau, création du tableau
2.remplir le tableau à partir d'entiers saisis
3.retourner ce tableau */ }

public static void affichageTableau(int[] t)


{ /* afficher les éléments du tableau t */ }

public static int maxTableau(int[] t)


{ /* retourner l'élément le plus grand de t */ }

public static void main(String[] args) {


Tab tab = new Tab(); //Création d'une instance de la classe Tab
int t[] = tab.créationTableau();
System.out.println("Affichage des éléments du tableau:");
tab.affichageTableau(t);
System.out.println("Le max du tableau est " + tab.maxTableau(t));
}
}

Aymen FERJANI page 8 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

Exercice 8
Écrire un programme qui créé et remplit un tableau de réels à partir des arguments, puis
inverse ce tableau et affiche ces éléments.

Exercice 9
Écrire un programme qui saisit et remplit un tableau de chaı̂nes de caractères, puis saisit
une chaı̂ne et indique si cette chaı̂ne se trouve dans le tableau. Dans le cas où la chaı̂ne existe,
le programme devra aussi afficher sa position dans le tableau.
Note : Utiliser la méthode String.equals(chaı̂ne) pour comparer entre deux chaı̂nes.
Exemples:

String ch1 = "bonjour", ch2 = "bonjour", ch3 = "Bonjour";


ch1.equals(ch2) // renvoi true
ch1.equals(ch3) // renvoi false

Exercice 10
Écrire un programme qui permet de saisir et remplir les éléments d’un tableau
d’entiers, puis effectue le tri par sélection dans l’ordre croissant sur ce tableau, et enfin affiche
le tableau.
Principe :
Pour chaque élément tab[i], déterminer l’indice min du plus petit élément à droite de tab[i]
(plus petit que tab[i]), puis permuter tab[i] et tab[min]. Si on ne trouve pas un élément plus
petit que tab[i], alors aucune permutation n’est effectuée.

Aymen FERJANI page 9 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

TP3: Concepts de base de l’orienté objet


Objectifs

— Créer des classes, instancier des objets et appeler des méthodes.


— Comprendre le principe d’encapsulation des données.

1 Exercices pratiques
Exercice 1
On souhaite modéliser un point dans un plan ayant un repère orthonormé.
1. Écrire la classe Point contenant les attributs nécessaires ainsi qu’un constructeur prenant
des paramètres.
2. Ajouter un autre constructeur sans paramètre qui initialise un point à la position (0,0).
3. Pour chaque attribut, ajouter une méthode accesseur (get) pour retourner la valeur de
l’attribut, et une méthode mutateur (set) pour modifier la valeur de l’attribut.
4. Ajouter la méthode public void modifierCoord(double x, double y) qui
permet de modifier les coordonnées d’un point.
5. Écrire la méthode public boolean memePosition(Point p) qui vérifie si un point a les
mêmes coordonnées que le point p.
6. Écrire la méthode public boolean estSymetrique(Point p) qui vérifie si un point est
symétrique au point p par rapport à l’origine du repère (0,0).
7. Ajouter la méthode public double distance(Point p) permettant de calculer et
retourner
p la distance entre un point et le point p selon la formule suivante:
(x − xp )2 + (y − yp )2
Utiliser les méthodes prédéfinies Math.pow(x, 2) pour calculer le carré d’un x et Math.sqrt(x)
pour la racine carrée d’un x.
8. Dans le même package, créer la classe TestPoint contenant la méthode main afin de
tester les méthodes de la classe Point:
public class TestPoint
{
public static void main(String[] args)
{
Point p1 = new Point(5,3);
Point p2 = new Point();
System.out.println("p1(" + p1.getX() + "," + p1.getY() + ")" );
System.out.println("p2(" + p2.getX() + "," + p2.getY() + ")" );
p2.modifierCoord(5, 10);
System.out.println("p2(" + p2.getX() + "," + p2.getY() + ")" );
if(!p1.memePosition(p2))
System.out.println("p1 et p2 n'ont pas la m^eme position");
Point p3 = new Point(-5, -3);
System.out.println("p3(" + p3.getX() + "," + p3.getY() + ")" );
if(p1.estSymetrique(p3))
System.out.println("p1 et p3 sont symètriques");
System.out.println("La distance entre p1 et p2 est " + p1.distance(p2));
}
}

Aymen FERJANI page 10 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

Exercice 2
On souhaite modéliser une date caractérisée par un jour, un mois et une année.
1. Écrire la classe Date avec les attributs nécessaires ainsi qu’un constructeur qui
initialise une date.
2. Pour chaque attribut, ajouter une méthode accesseur (get) pour retourner la valeur de
l’attribut, et une méthode mutateur (set) pour modifier la valeur de l’attribut.
3. Redéfinir la méthode public String toString() qui retourne une date sous la forme:
”jour/mois/année”.
4. Ajouter la méthode private boolean annéeBissextile() qui vérifie si l’année d’une date
est bissextile ou pas. Une année est bissextile dans les cas suivants:
— Elle est divisible par 4 et non par 100.
— Elle est divisible par 400.
5. Ajouter la méthode private int nombreJoursDuMois() qui retourne le nombre de jours
du mois (exemple: mois = 1 ⇒ nombre de jours = 31). Utiliser la méthode précédente.
6. Écrire la méthode public boolean estValide() permettant de vérifier si une date est
correcte ou pas. Utiliser la méthode précédente.
7. Ajouter la méthode public boolean plusRécente(Date d) qui indique si une date est
plus récente que la date d.
8. Dans le même package, créer la classe TestDate contenant la méthode main afin de tester
les méthodes de la classe Date:
public class TestDate
{
public static void main(String[] args)
{
Date d1 = new Date(28, 2, 2018);
if(d1.estValide())
System.out.println(d1 + " est valide");
Date d2 = new Date(30, 2, 2017);
if(!d2.estValide())
System.out.println(d2 + " n'est pas valide");
Date d3 = new Date(17, 10, 2020);
if(d3.plusRécente(d1))
System.out.println(d3 + " est plus récente que " + d1);
}
}

Exercice 3
On souhaite modéliser une pile d’entiers stockée sous forme d’un tableau.
1. Définir la classe Pile ayant comme attributs un entier taille (la taille de la pile), un
autre entier nommé tailleMax (la taille maximale de la pile, une constante) et un tableau
d’entiers nommé p.
2. Ajouter un constructeur, prenant un paramètre entier noté n, qui initialise taille à zéro
et tailleMax à n, puis créé le tableau p avec la taille tailleMax.
3. Ajouter la méthode accesseur public int getTaille() permettant de retourner la taille de
la pile.
4. Écrire la méthode public boolean estVide() qui indique si la pile est vide ou pas.
5. Ajouter la méthode public boolean estPleine() qui indique si la pile est pleine ou pas.

Aymen FERJANI page 11 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

6. Ajouter la méthode public void afficher() qui affiche les éléments de la pile.
7. Écrire la méthode public void empiler(int x) qui ajoute x à la fin de la pile et incrémente
taille de 1 si la pile n’est pas pleine. Afficher un message si la pile est déjà pleine.
8. Écrire la méthode public void dépiler() qui dépile le dernier élément (il suffit de
décrémenter la taille de 1) si la pile n’est pas vide. Afficher un message si la pile est déjà
vide.
9. Dans le même package, définir la classe TestPile avec la méthode main et tester les
méthodes de la classe Pile.

Exercice 4
On souhaite modéliser une liste chaı̂née composée par plusieurs nœuds où chaque nœud
contient un entier.
1. Écrire la classe Noeud ayant comme attributs un entier val et une référence sur le nœud
suivant nommée suivant (type Noeud).
2. Ajouter un constructeur à la classe Noeud, prenant un paramètre entier, qui initialise val
à la valeur du paramètre. La référence suivant pointera sur null.
3. Ajouter des méthodes accesseurs et mutateurs à la classe Noeud permettant de récupérer
et de modifier les attributs de cette classe.
4. Ajouter, dans le même package, la classe Liste avec comme attributs une référence sur la
tête de liste nommée tête (type Noeud) et un entier taille qui est la taille de cette liste.
5. Ajouter un constructeur à la classe Liste, sans paramètre, qui initialise la référence tête
à null et taille à zéro.
6. Ajouter des méthodes accesseurs et mutateur à la classe Liste permettant de récupérer la
tête et la taille et de modifier uniquement la tête.
7. Ajouter la méthode public boolean estVide() qui indique si la liste est vide ou pas.
8. Ajouter la méthode public void afficher() qui parcourt la liste et affiche les valeurs de
ses nœuds.
9. Ajouter la méthode public void ajouterEntier(int val) qui ajoute un nœud, ayant la
valeur entière val, à la fin de la liste et incrémente taille de 1.
10. Écrire la méthode public void supprimerEntier(int val) qui supprime le premier nœud
rencontré depuis la tête ayant la valeur val, et décrémente taille de 1 si ce nœud a été
trouvé.
11. Dans le même package, ajouter la classe TestListe contenant la méthode main avec le
code suivant:
Liste lst = new Liste();
lst.ajouterEntier(15);
lst.ajouterEntier(-9);
lst.ajouterEntier(5);
lst.ajouterEntier(-26);
lst.ajouterEntier(42);
lst.afficher();
System.out.println("Suppression de -26 puis 15:");
lst.supprimerEntier(-26);
lst.supprimerEntier(15);
lst.afficher();
System.out.println("Ajout de 103:");
lst.ajouterEntier(103);
lst.afficher();
System.out.println("La liste contient " + lst.getTaille() + " noeuds");

Aymen FERJANI page 12 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

TP4: Héritage, Polymorphisme et classe abstraite


Objectifs

— Utilisation de l’héritage.
— Comprendre le polymorphisme.
— Comprendre l’utilité d’une classe abstraite.
— Création et utilisation d’un tableau dynamique.

1 Notions de cours
1.1 Création et manipulation d’un tableau dynamique
Pour créer un tableau redimensionnable, on peut utiliser la classe ArrayList:
// Importer la classe ArrayList au début du fichier
import java.util.ArrayList;
...
// Création d'un tableau dynamique de String
ArrayList<String> tab = new ArrayList<>();

Il faut tenir en compte que cette classe ne permet pas de créer des tableaux de types primitifs.
Pour remédier à ce manque, on peut utiliser les classes enveloppes.

1.2 Classes enveloppes (Wrappers)


Les classes enveloppes ou wrappers encapsulent les types primitifs. Chaque type primitif
possède donc sa classe qui lui permet de se comporter comme un objet:

Type primitif Classe enveloppe


boolean Boolean
char Character
byte Byte
short Short
int Integer
long Long
float Float
double Double

1.3 Quelques méthodes de la classe ArrayList


Voici quelques méthodes pratiques de la classe ArrayList:

Aymen FERJANI page 13 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

Méthode Rôle

add(Object e) Ajoute l’objet e à la fin du tableau.

add(int i, Object e) Ajoute l’objet e à l’index i du tableau.

remove(int i ) Supprime l’élément ayant l’index i du tableau.

size() Retourne la taille du tableau.

get(int i ) Retourne l’élément du tableau ayant l’index i.

set(int i, Object e) Affecte l’objet e à l’index i du tableau.

1.4 Exemple
// Importer la classe ArrayList au début du fichier, juste après le package
import java.util.ArrayList;
...
ArrayList<String> tab = new ArrayList<>();

tab.add("Bonjour");
tab.add("Salut");
tab.add(0, "Coucou"); // ajoute au début du tableau
tab.add("Au revoir");
tab.add("Merci");

tab.remove(2); // supprime l'élément d'indice 2 ("salut")

for(int i = 0; i < tab.size(); i++) {// parcourt le tableau


System.out.println(tab.get(i)); // affiche chaque élément
}

2 Exercices pratiques
Exercice 1
Une entreprise souhaite gérer la liste de ses employés avec une application Java. Il y a
principalement deux types d’employés : les cadres et les ouvriers.
1. Sachant qu’un employé est décrit par son matricule, son nom, son âge et son salaire, définir
la classe Employé ayant un constructeur avec paramètres qui initialise tous ses attributs.
2. Ajouter un attribut entier statique nombre initialisé à 0 et qui sera incrémenté de 1
chaque fois qu’un employé est créé.
3. Ajouter les méthodes getAge, getSalaire et setSalaire, ainsi que la méthode statique
getNombre.
4. Redéfinir la méthode publique toString qui retourne les informations d’un employé selon
cette forme:
matricule nom, ^
age ans, salaire dt
//Exemple: E10268 Ahmed SASSI, 34 ans, 1200 dt

Aymen FERJANI page 14 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

5. Définir, dans le même package, la classe Ouvrier sachant qu’un ouvrier a les mêmes
propriétés d’un employé. Ajouter un constructeur avec paramètres qui initialise les valeurs
des attributs.
6. Définir, dans le même package, la classe Cadre sachant qu’en plus des propriétés d’un
employé, chaque cadre a une fonction. Ajouter un constructeur avec paramètres qui
initialise les valeurs des attributs.
7. Redéfinir la méthode toString dans la classe Ouvrier en ajoutant le mot ”Ouvrier” à la
fin de la chaı̂ne retournée. Exemple:
E10270 Mounir DRIDI, 36 ans, 900 dt, Ouvrier

8. Redéfinir la méthode toString dans la classe Cadre en ajoutant la fonction du cadre à


la fin de la chaı̂ne retournée. Exemple:
E10268 Ahmed SASSI, 34 ans, 1200 dt, Analyste

9. L’entreprise a décidé d’augmenter les salaires de ses employés selon cette formule :
— Pour les ouvriers, une augmentation de 100 dt.
— Pour les cadres :
— Une augmentation de 200 dt si l’âge est inférieur à 35 ans.
— Une augmentation de 300 dt si l’âge est compris entre 35 ans et 45 ans.
— Une augmentation de 400 dt pour les autres.
Déclarer la méthode abstraite publique augmenter dans la classe Employé. Ainsi, la
classe Employé deviendra abstraite, et la méthode augmenter devra être définie dans
les classes Ouvrier et Cadre.
10. Afin de tester ces classes et leurs méthodes, créer, dans le même package, la classe
TestEmployé ayant la méthode main avec le code suivant:
Employé[] liste = new Employé[5];
liste[0] = new Cadre("E10268", "Ahmed SASSI", 34, 1200, "Analyste");
liste[1] = new Cadre("E10269", "Ridha DRIDI", 46, 1350, "Comptable");
liste[2] = new Ouvrier("E10270", "Mounir DRIDI", 36, 900);
liste[3] = new Ouvrier("E10271", "Alia ARBI", 29, 850);
liste[4] = new Cadre("E10272", "Amal TOUATI", 38, 1850, "Directeur RH");

for(int i = 0; i < liste.length; i++) {


liste[i].augmenter();
System.out.println(liste[i]);
}

System.out.println("On a créé " + Employé.getNombre() + " employés");

11. Transformer le tableau liste en ArrayList.

Aymen FERJANI page 15 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

Exercice 2
On souhaite modéliser les concepts véhicule, voiture et avion.
1. Définir la classe Véhicule qui a pour attributs des informations valables pour tout type
de véhicule: son modèle, son année d’achat, son prix d’achat et son prix courant.
2. Ajouter un constructeur avec 3 paramètres (modèle, année d’achat et prix d’achat) qui
initialise tous ces attributs. Le prix courant sera fixé au prix d’achat.
3. Redéfinir la méthode toString qui retourne les informations d’un véhicule selon la forme
suivante:
modèle, annéeAchat, prixAchat dt, prixCourant dt
//Exemple: Peugeot 206, 2005, 16000 dt, 12000 dt

4. Ajouter les méthodes accesseurs et mutateur getAnnéeAchat, getPrixAchat et


setPrixCouant.
5. Définir, dans le même package, la classe Voiture qui hérite de Véhicule et ayant les
attributs supplémentaires suivants:
— nombre de portes
— puissance fiscale
— kilométrage
Ajouter un constructeur avec paramètres qui initialise tous les attributs. Là encore, le
prix courant sera fixé au prix d’achat.
6. Définir, dans le même package, la classe Avion qui elle aussi hérite de Véhicule et ayant
les attributs supplémentaires suivants:
— nombre de passagers
— heures de vol
Ajouter un constructeur avec paramètres qui initialise tous les attributs. Là aussi, le
prix courant sera fixé au prix d’achat.
7. Redéfinir la méthode toString dans la classe Voiture en ajoutant les informations propres
à la voiture à la fin de la chaı̂ne retournée. Exemple:
PEUGEOT 206, 2005, 20000.0 dt, 10000.0 dt, 4 portes, 5 cv, 200000 km

8. Redéfinir la méthode toString dans la classe Avion en ajoutant les informations propres
à l’avion à la fin de la chaı̂ne retournée. Exemple:
CESSNA CITATION II, 1982, 4000000.0 dt, 2200000.0 dt, 9 passagers, 15300 heures

9. Déclarer la méthode abstraite publique modifierPrixCourant(int annéeActuelle) dans


la classe Véhicule.
10. Définir la méthode précédente dans les deux sous-classes Voiture et Avion de sorte à
calculer le prix courant en fonction de certains critères, et mettre à jour l’attribut
correspondant au prix courant:
— Pour une voiture, le prix courant est égal au prix d’achat:
— moins 2% pour chaque année depuis l’achat jusqu’à annéeActuelle.
— moins 1% pour chaque tranche de 10000km parcourus.
— Pour un avion, le prix courant est égal au prix d’achat moins 3% pour chaque
tranche de 1000 heures de vol, et moins 1% pour chaque année depuis l’achat jusqu’à
annéeActuelle.
Attention, dans ces deux méthodes, si le prix devient négatif on le met alors à zéro.
Aymen FERJANI page 16 de 19 AU: 2021/2022
Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

11. Afin de tester ces classes et leurs méthodes, créer, dans le même package, la classe
TestVéhicule ayant la méthode main avec le code suivant:
ArrayList<Véhicule> tab = new ArrayList<>();

tab.add(new Voiture("PEUGEOT 206", 2005, 20000, 4, 5, 200000));


tab.add(new Voiture("SUZUKI SWIFT", 2016, 30000, 4, 4, 38000));
tab.add(new Voiture("FIAT 500", 2010, 20000, 4, 4, 150000));
tab.add(new Avion("CESSNA CITATION II", 1982, 4000000, 9, 15300));
tab.add(new Avion("DAHER-SOCATA TBM 700", 2001, 3500000, 5, 18000));

for(Véhicule v: tab) {// boucle foreach


v.modifierPrixCourant(2020);
System.out.println(v);
}

Aymen FERJANI page 17 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

TP5: Implémentation des interfaces et gestion des


exceptions
Objectifs

— Créer et implémenter des interfaces.


— Gérer les exceptions.

1 Exercice pratique
On veut implémenter le diagramme de classe suivant :

En respectant les données du diagramme :


1. Créer l’interface Additionnable.
2. Définir la classe Reel qui représente un nombre réel.
La méthode plus(Object o) devra retourner un nouvel objet de type Reel qui représente
la somme des deux réels (l’objet courant et le paramètre o).
3. Dans la méthode racineCarree() de la classe Reel, lever une nouvelle exception (de type
Exception) avec le message ”Impossible d’effectuer la racine du nombre negatif n” (n à
remplacer par la valeur du réel) lorsque le nombre est négatif.
4. Définir la classe Complexe qui représente un nombre complexe.
La méthode toString() devra retourner la représentation suivante du nombre complexe:

(pReele + pImaginaire*i)
exemple: (5.2 + 3.6*i)

La méthode plus(Object o) devra retourner un nouvel objet de type Complexe qui


représente la somme des deux nombres complexes (l’objet courant et le paramètre o).
5. Afin de tester ces classes et leurs méthodes, créer la classe Test ayant la méthode main
avec le code suivant :

Aymen FERJANI page 18 de 19 AU: 2021/2022


Fascicule TP Département Informatique
et Télécoms
Programmation Orientée Objet Niveau: 2ème SEIoT/IRS

Complexe c1 = new Complexe(2, 3.6);


Complexe c2 = new Complexe(5.1, 10.22);
Complexe c3 = (Complexe)c1.plus(c2);
System.out.println(c1 + " + " + c2 + " = " + c3);

Reel r1 = new Reel(9.0);


Reel r2 = new Reel(-2.1);
try {
System.out.println("La racine carree de " + r1 + " est " + r1.racineCarree());
}
catch (Exception e) {
System.out.println(e.getMessage());
}
try {
System.out.println("La racine carree de " + r2 + " est " + r2.racineCarree());
}
catch (Exception e) {
System.out.println(e.getMessage());
}
Reel r3 = (Reel)r1.plus(r2);
System.out.println(r1 + " + " + r2 + " = " + r3);

6. Définir l’exception personnalisée ExceptionValeurNegative avec la méthode redéfinie


public String getMessage() qui devra retournée le message ”Impossible d’effectuer la
racine du nombre negatif n” (n à remplacer par la valeur du réel).
Modifier la méthode racineCarree() de la classe Reel pour qu’elle lève cette exception
lorsque le nombre est négatif.
Modifier aussi la méthode main de la classe Test en remplaçant Exception par
ExceptionValeurNegative.

Aymen FERJANI page 19 de 19 AU: 2021/2022

Vous aimerez peut-être aussi