Ministère de l'Enseignement Supérieur et de la Recherche Scientifique

Université M'hamedBougara de Boumerdès

Faculté des Sciences, Département Informatique

TP4 Filière : LMD –L2 Info

Préparation : Gaceb
Module : POO Année : 2ème année –S4

Important : Chaque étudiant doit envoyer par email sa propre solution de la série de TP 4 à
son chargé de TP avant le 10 octobre, pour son évaluation. Elle sera comptabilisée dans la note
de module. Les groupes G1 et G2 à l'adresse miec.infodz@gmail.com, les autres groupes à
l'adresse: chaouche007@gmail.com. Notez bien votre nom, prénom et N° de groupe.

Exercice 1. Gestion de la scolarité

1. Création de la classe Personne

a) Dans un nouveau projet, Créer la classe Personne représentant une personne qui a les
caractéristiques suivantes : nom, prenom et age.
b) Ajouter à cette classe un constructeur qui initialise tous ses attributs et une méthode afficher
qui affiche les caractéristiques d’un objet de type Personne.
c) Créer la classe MainApp contenant la méthode main() qui crée un objet de type Personne en
initialisant ses attributs à des valeurs saisies par l’utilisateur (la lecture des valeurs se fait dans
la fonction main() et pas dans le constructeur de la classe Personne). Tester votre code.

2. Héritage, redéfinition et polymorphisme

a) Créer la classe Enseignant qui hérite de la classe Personne et ayant deux attributs
supplémentaires : nss numéro de sécurité sociale de type long, modules un tableau de
chaines de caractères représentant les modules qu’il enseigne.
b) Ajouter un constructeur dans cette seconde classe appelant celui de la classe mère et
initialisant les champs spécifiques à la classe Enseignant.
c) Créer la classe Etudiant héritant de la classe Personne et ayant comme attributs spécifiques:
matricule de type entier, notes un tableau de type double indiquant les notes de l’étudiant
dans les différents modules qui sont au nombre de 3.
d) Ajouter un constructeur dans la classe Etudiant appelant celui de la classe mère et initialisant
les champs spécifiques à la classe Etudiant.
e) Ajouter dans la classe Etudiant la méthode double claculMoyenne(double[] notes) qui
calcule la moyenne de l’étudiant en supposant que tous les modules ont un coefficient 1.
f) Redéfinissez la méthode afficher() de la classe Personne dans les deux classes Enseignant et
Etudiant afin d’afficher leurs attributs (la nouvelle méthode peut invoquer en partie la
méthode afficher() de classe mère pour afficher les attributs hérités).
g) Créer au niveau de la méthode main() un tableau de 5 éléments de type Personne contenant
deux éléments de type Enseignant et 3 de type Etudiant.
h) Afficher pour chaque élément du tableau les informations le concernant.

POO, TP4, GACEB Page 1/5

 3. Classes abstraites et interface Comparable

On désire obliger les programmeurs qui conçoivent des classes héritant de la classe Personne à
doter ces classes de certaines méthodes :

a) Transformer la classe Personne en classe abstraite et y’ajouter la méthode abstraite de

signature afficherType() qui affiche le type de l’objet.
b) Implémenter cette méthode dans les classes dérivées Enseignant et Etudiant.
c) Tester le programme modifié dans la méthode main().
d) Modifier le programme afin que les classes Enseignant et Etudiant implémentent l’interface
prédéfinie Comparable (Consultez la documentation Java). La méthode compareTo sera
redéfinie dans la classe Enseignant afin de pouvoir classer les enseignants dans l’ordre
alphabétique de leurs noms et sera redéfinie dans la classe Etudiant afin de classer les
étudiants dans l’ordre décroissant de leurs moyennes.
e) Modifier la méthode main() de sorte à avoir un tableau d’étudiants trié et un autre tableau
d’enseignants trié. (Utilisez la méthode statique sort de la classe Arrays)

Exercice 2. Héritage et Polymorphisme : traitement d’images

Dans cet exercice nous implémenterons un ensemble de classes permettant de traiter des images
numériques et d’appliquer des filtres, tels que le lissage, le passage à l’image négative et la détection
de contours. L’exemple suivant illustre un extrait d’un programme principal typique se servant de
cette fonctionnalité:

// Création d’un objet de type Image

// à partir d’un fichier sur le disque.
Image im = new Image ("Scanner_thoracique_COVID19.png");

// Création d’un filtre de type « Négatif »

Filter f = new NegativeFilter();

// Filtrer l’image avec le filtre

im.filter(f);

// Enregistrer les résultats dans un fichier

im.save("resultat_Negatif.png");

Un exemple d’images d’entrée et de sortie est donné ci-dessous:

Image originale Image résultat

Scanner_thoracique_COVID19.png Resultat_Negatif.png

POO, TP4, GACEB Page 2/5

Ici nous traitons des images dites « de niveaux de gris « où chaque pixel peut prendre des valeurs entre
0 (noir) et 255 (blanc). Une image est représentée comme un tableau 2D de int.
La classe Image est à implémenter par vous. Pour vous aider à démarrer, nous vous fournissons une
classe mère ImageRoot qui implémente une partie de la fonctionnalité (Le fichier ImageRoot.java se
trouve dans le dossier « Outils\ », à ajouter dans le dossier « \src » de votre projet, les images de test
sont à mettre dans le dossier racine de votre projet). Elle contient le tableau (la matrice) dans lequel on
stocke les niveaux de gris des pixels de l’image, les méthodes pour charger une image (le constructeur)
et pour sauvegarder une image (méthode save()).

public abstract class ImageRoot {

protected int[][] data;
protected int width, height;

// Méthode à implémenter
abstract public void filter(Filter f);

// Méthode fournies
public ImageRoot (String filename) { … }
public int getWidth () { … }
public int getHeight () { … }
public void save (String filename) { … }
}

La classe Image peut être dérivée de la classe ImageRoot. Il reste donc la méthode filter() à
implémenter. Elle doit être générale, c.à.d. elle doit être compatible avec plusieurs types de filtres.
Le principe d’un filtre (le comportement commun) est simple : à partir de 9 valeurs, correspondant aux
niveaux de gris d’un pixel donné et de ses 8 voisins, le filtre va calculer une nouvelle valeur à l’aide
d’une méthode filterPixel() spécifique à lui. La fonction de filtrage filter() de l’image applique cette
méthode à tous les pixels de l’image.

Notre système comprend les trois types de filtres suivants :

- Filtre « négatif » : la valeur de chaque pixel i est remplacée par 255 – i. Les valeurs des
voisins sont ignorées.

- Filtre linéaire : la valeur de chaque pixel i est remplacée par une somme pondérée impliquant
sa valeur d’origine et les valeurs I des voisins. Les poids w de cette combinaison linéaire sont
les paramètres de ce filtre à fournir au constructeur lors de sa création. L’opération est
complétée par la multiplication par un facteur f et par l’addition d’une constante a :

Un exemple pour la création d’un filtre linéaire:

float [] c = {-1,0,1,-1,0,1,-1,0,1};
// Paramètres :
// 1) tableau de coefficients ;
// 2) facteur ;
// 3) constante additive
f = new LinearFilter(c,(float)(1.0/6.0),127.5);

POO, TP4, GACEB Page 3/5

 - Filtre Gaussien : le filtre Gaussien est un cas spécifique d’un filtre linéaire dont les poids sont
donnés par le masque suivant :

Le poids le plus important est donc associé au pixel à traiter, les poids des voisins étant moins élevés.
Le point commun de tous les filtres du système est la fonction filterPixel() dont la signature est la
suivante :

public int filterPixel(int v0, int v1, int v2, int v3, int v4, int
v5, int v6, int v7, int v8);

Les valeurs de v0 à v8 correspondent aux niveaux de gris du pixel à filtrer (v4) et ses voisins (v0 à v3
et v5 à v8). Chaque filtre doit définir sa propre version de filterPixel().

Plan de travail :
1. Créer une hiérarchie de classe de filtres en précisant quel filtre hérite de quel autre filtre.
Quelle classe se trouve à la racine de la hiérarchie ? Veuillez spécifier la visibilité des
différents attributs.
2. Implémenter un type de filtre.
3. Implémenter la méthode filter() de la classe Image. Elle va parcourir tous les pixels de
l’image et pour chaque pixel elle appellera la méthode filterPixel() du filtre f donné en
argument. Deux remarques :
a) Lors du calcul du résultat pour un pixel donné, les valeurs des voisins doivent
correspondre aux valeurs avant le traitement. Pour cette raison, les résultats du calcul sont
temporairement stockés dans un deuxième tableau. A la fin du traitement, l’image est
mise à jour à partir de ce deuxième tableau.
b) Les pixels aux bords de l’image ne disposent pas de voisins. Pour ces pixels, les résultats
seront égaux aux entrées (aucun traitement pour ces pixels).
4. Implémenter les autres filtres (non traités dans la question 2).

Exercice 3. Interfaces Java: traitement d’images (suite)

Nous continuerons avec l’application de l’exercice 2 (sur les images) en ajoutant une simple fonction
cherchant l’image la plus petite dans un tableau d’images.

1. Créer une nouvelle classe FindMinMain comprenant une nouvelle fonction principale main()
(en static). Dans cette fonction, créer un tableau de type Image de taille 4, et charger les 4
images fournies («Scanner_thoracique_COVID19.png», « Pneumonie.png »,
«Cameraman128.png », et « Baboongray.png »).
2. Prendre la fonction FindMin() donnée comme ci-dessus et adapter la pour qu’elle puisse
traiter des objets différents. En état, la fonction traite des tableaux de «int» uniquement.
Ajouter la comme méthode static à la classe FindMinMain.

POO, TP4, GACEB Page 4/5

 a) Remplacer le type du paramètre «tab» par un tableau de «Comparable ». La fonction
prend donc en entrée des tableaux d’objets compatibles avec le type Comparable (des
types « implémentant l’interface Comparable).
b) Remplacer la comparaison avec « < » par une comparaison à l’aide de la méthode
compareTo(). Remarque: tous les objets implémentant l’interface Comparable
doivent connaître cette méthode.

public static int findMin (int [] tab, int size) {

int argmin=0;
int min=tab[0];

for (int i=1; i<size; ++i) {

if (tab[i] < min) {
min = tab[i];
argmin=i;
}
}
return argmin;
}

3. Modifier la classe Image pour la rendre comparable :

a) Ajouter le mot clé implements à la classe « Image » pour indiquer qu’elle implémente
l’interface Comparable.
b) Ajouter la méthode public int compareTo (Object other) à la classe Image. Cette
fonction renverra un entier avec la signification suivante:
 si l’objet destinataire est égal à l’objet passé en paramètre (other)
 <0 si l’objet destinataire est inférieur à l’objet passé en paramètre
 >0 si l’objet destinataire est supérieur à l’objet passé en paramètre
Le critère choisi sera la taille de l’image (hauteur * largeur).

4. Ajouter un appel à FindMin à la méthode main(). Tester le code.

POO, TP4, GACEB Page 5/5