USDB, Département d'Informatique L2 Date : Janvier 2019

Nom :
Prénom :
Section /groupe : Examen de POO (1h30 min)
Exercice 1 : (5 points) Questions de cours
1. Donner pour chacun des mots clés suivants la liste de directives pour savoir quand il doit être utilisé.
a. super: 0.25*4
1. super est utilisé dans le constructeur de la sous classe pour appeler le constructeur de la classe mère.
2. super préfixe le nom d'une méthode redéfinit dans une sous classe pour appelé la méthode de la classe mère.
3. super préfixe le nom d'attribut dans la sous classe pour référence un attribut de la super classe qui porte le
même nom (duplication de champs).
4. Une nouvelle utilisation de super dans une classe qui implémente deux interfaces déclarent la même méthode
default mais proposent des implémentations incompatibles. Pour appeler la méthode default d’une des deux
interfaces, on utilise NomInterface.super.nomMethode().
b. final. 0.25*3
1. final dans la déclaration d'une classe veux dire la classe ne peut pas être dérivée.
2. Une méthode déclarée finale ne peut pas être redéfinie dans une classe dérivée.
3. Lorsque le mot clé final est appliqué à une variable ou à des champs d’une classe, il interdit la modification
de leur valeur (constante).
2. Quelles sont les méthodes default en Java? Pourquoi avons-nous besoin des méthodes default dans les
interfaces? 0.75+0.5
 Depuis Java 8, ils ont introduit aux interfaces des méthodes par défaut (le mot clé default dans la
déclaration ) avec une implémentation. Une classe implémentant une interface comportant une
méthode par défaut (default) peut utiliser directement cette méthode et/ou redéfinir cette méthode.
De même une interface dérivant d’une autre interface peut hériter de l’implémentation de la
méthode par défaut et / ou redéfinir une méthode par défaut ou bien la déclarer à nouveau, ce qui
la rend abstraite.
 Traditionnellement, une interface Java regroupe des méthodes abstraites. Toute classe qui
implémente une interface doit fournir une implémentation pour chaque méthode définie par
l’interface ou hériter de l’implémentation d’une superclasse. Mais cela pose un problème lorsque
les concepteurs de bibliothèques doivent mettre à jour une interface pour ajouter une nouvelle
méthode. En effet, les classes concrètes existantes (qui peuvent ne pas être sous leur contrôle)
doivent être modifiées pour refléter le nouveau contrat d’interface. Les méthodes par défaut
permettent de faire évoluer une interface sans que cela pose problème au niveau des classes qui
l’implémentent.
3. Citer les différences entre Comparable et Comparator dans Java.
Comparable 0.25*4 Comparator 0.25*4
1
 Comparable appartient au package java.lang
Comparable fournit la méthode int compareTo(Object
o) pour trier les objets
L'interface Comparable est utilisée pour trier les objets
selon l'ordre naturelle.
Nous pouvons trier les éléments d’une liste L de type
Comparable avec la méthode Collections.sort(L) et les
éléments d'un tableau T avec Arrays.sort(T)
Comparable affecte la classe d'origine (celle qui
implémente l'interface comparable), c'est-à-dire que la
classe actuelle est modifiée.
Comparator appartient au package java.util
Comparator fournit la méthode int compare(Object
o1,Object o2) pour trier les objets et la méthode
boolean equals(Object o) pour tester l'égalité des objets
L'interface Comparator peut être utilisée pour définir
plusieurs autres critères d'ordres.
Nous pouvons trier les éléments d’une liste L de type
Comparator avec la méthode Collections.sort(L,
Comparator c) et les éléments d'un tableau T avec
Arrays.sort(T, Comparator c)
Le comparateur n'affecte pas la classe d'origine (celle
qui implémente l'interface comparator), c'est-à-dire que
la classe actuelle n'est pas modifiée.

Exercice 2 : ( 7.5 points)

Nous voulons simuler une machine à vote électronique très simplifiée. On vous demande d'implémenter
la classe MachineAVote décrite par une liste de candidats et les méthodes suivantes:
 void ajouterCandidat(Candidat c): ajoute le candidat c à la liste des candidats.
 void voter(String nom): voter pour le candidat qui porte le nom "nom".
 void afficherResultatsVote(): affiche le résultat de vote ordonné par ordre décroissant du nombre
de votes.
 void afficherCandidats(): affiche la liste des candidats ordonnée par nom.
Pour ce faire, implémenter également la classe Candidat. Nous supposons que la classe Candidat possède
deux attributs: le nom du candidat et le nombre de vote. Rajouter à la classe Candidat les méthodes que
vous jugez nécessaires. Tester dans un programme principal la machine à vote.
public class Candidat implements Comparable{//0.25
private String nom;
private int nbvote=0;
public Candidat(String nom) {//0.25
this.nom = nom;
}
public String getNom() {//0.25*2 pour les gets
return nom;
}
public int getNbvote() {
return nbvote;
}
public void incrVote(){//0.25
nbvote++;
}
public void razNbVote() {//0.25
nbvote = 0;
}
public int compareTo(Object o){ //0.5
return nom.compareTo(((Candidat)o).nom);
}
}
import java.util.*; //0.25

public class MachineAVote {//0.25

private LinkedList<Candidat>liste=new LinkedList<Candidat>();//0.25
2
 public void ajouterCandidat(Candidat c){
liste.add(c); //0.25
}
public int rech(String nom)
{
for(int i=0;i<liste.size();i++){//0.25
if (nom.equals(liste.get(i).getNom()))//0.5
return i;
}
return -1;

}
public void voter(String nom){
int i=rech(nom); //0.25
if(i!=-1) liste.get(i).incrVote();//0.25
}
public void afficherCandidats(){
Collections.sort(liste); //0.25
for(int i=0;i<liste.size();i++)//0.25
System.out.println(liste.get(i).getNom()+" "+
liste.get(i).getNbvote());//0.25
}
public void afficherResultatsVote(){
Collections.sort(liste,new VoteComparator());//0.25
for(int i=0;i<liste.size();i++)//0.25
System.out.println(liste.get(i).getNom()+" "+
liste.get(i).getNbvote());//0.25
}
}
import java.util.Comparator; //0.25

public class VoteComparator implements Comparator{//0.25

public int compare(Object o1,Object o2){ //0.5
return (((Candidat)o2).getNbvote() - ((Candidat)o1).getNbvote());
}
}
public class Test {//1

public static void main(String[] args) {

MachineAVote m = new MachineAVote();
m.ajouterCandidat(new Candidat("Mohamed"));
m.ajouterCandidat(new Candidat("Adam"));
m.ajouterCandidat(new Candidat("Samy"));
m.ajouterCandidat(new Candidat("Nassim"));
System.out.println("L'ordre par Nom:");
m.afficherCandidats();
m.voter("Samy");m.voter("Samy");m.voter("Samy");
m.voter("Samy");
m.voter("Samy");
m.voter("Samy");
m.voter("Mohamed");m.voter("Mohamed");

m.voter("Adam");m.voter("Adam");m.voter("Adam");m.voter("Adam");m.voter("Adam");
m.voter("Nassim");m.voter("Nassim");
System.out.println("L'ordre par Nom:");
m.afficherCandidats();
System.out.println("L'ordre par nombre de votes:");
m.afficherResultatsVote();
}
}

3
Exercice 3: (7.5 points)
1. Implémenter en respectant le principe d'encapsulation la classe Vecteur qui permet de gérer un tableau
dont la capacité augmente automatiquement quand celui-ci est plein. Cette classe contient deux attributs:
un tableau d’entiers tab et un entier taille qui représente le nombre de cases occupé dans le tableau tab.
Au moment de la construction d'une instance de la classe Vecteur, le nombre de case du tableau peut être
fixé par défaut à 10 cases ou pourra aussi être indiquée comme argument du constructeur. Si la longueur
du tableau tab ne permet plus d'insérer d'autres éléments au tableau tab, elle est automatiquement
augmentée à l’aide de la méthode privée augmenteCapacite( ). La méthode augmenteCapacite( )
augmente la capacité du tableau tab à deux fois plus la capacité actuelle. Par exemple, si le nombre de
cases du tableau tab égale à 10, après l'appel de la méthode augmenteCapacite ( ) le nombre de case du
tableau tab devient 20. La classe Vecteur fournit en plus les méthodes publiques suivantes :
 int longueur() retourne la taille actuelle du vecteur.
 void ajouter(int val) ajoute l’entier val à la fin du vecteur.
 void ajouter(int pos, int val) ajoute l’entier val à la position pos. Si le tableau contient moins de
pos+1 éléments, l'entier val est inséré à la fin.
 void modifier(int pos, int val) affecte l’élément val à la position pos dans le tableau. Si le tableau
contient moins de pos+1 éléments, la méthode ne fait rien.
 int retourne(int pos) retourne l’élément à la position pos dans le vecteur. Si le vecteur contient
moins de pos+1 éléments, la méthode retourne 0.
 int supprimer( int pos) supprime et retourne l’élément qui est dans la case pos. Si le vecteur
contient moins de pos éléments, la méthode retourne 0.
public class Vecteur {//0.25
private int [] tab; //0.25
private int taille=0; //0.25
public Vecteur() {//0.25
tab = new int[10];
}
public Vecteur(int n) {//0.25
tab = new int[n];
}
private void augmenteCapacite(){//0.75
int t[]=new int[2*taille];
for(int i=0;i<taille;i++)
t[i]=tab[i];
tab=t;
}
public int longueur(){//0.25
return taille;
}
public void ajouter(int val){ //1
if(taille == tab.length )
augmenteCapacite();
tab[taille]=val;
taille++;
}
public void ajouter(int pos, int val){ //1
int i=taille;
if(taille<pos+1)
ajouter(val);
else{
if(taille == tab.length )
augmenteCapacite();
while(i!=pos){

4
 tab[i]=tab[i-1];
i--;
}
tab[pos]=val;
taille++;
}
}
public void modifier(int pos, int val){ //0.25
if (taille>=pos+1)
tab[pos]=val; }
public int retourne(int pos){ //0.25
if (taille<pos+1) return 0;
return tab[pos]; }
public int supprimer( int pos){ //0.75
if (pos<taille)
return 0;
int x=tab[pos];
for(int i=pos;i<taille-1;i++)
tab[i]=tab[i+1];
taille--;
return x;
}
}

2. Implémenter l'interface Lifo qui fournit les prototypes des méthodes suivantes:
 boolean pileVide( );
 void empiler( int val);
 int depiler( );
public interface Lifo {//0.5
boolean pileVide( );
void empiler( int val);
int depiler( );
}
3. A partir de l’interface Lifo et de la classe Vecteur, donner l’implémentation d’une Pile qui définit une
pile d’entier implémentée par un vecteur.
public class Pile extends Vector implements Lifo{//0.25
private int sommet=-1; //0.25
public Pile(int n){ //0.25
super(n);
}
public Pile(){
super();
}
public boolean pileVide( ){ //0.25
return (taille()==0);
}
public void empiler( int val){ //0.25
sommet++;
ajouter(val);
}
public int depiler( ){ //0.25
int x=supprimer(sommet);
sommet--;
return x;
}
}
Indications:

5
- ArrayList <Type> Tab = new ArrayList<Type> ( ) : pour la création d'un objet vide Tab de type
Type (Type peut être Integer (entier), Double (double), etc.)
- LinkedList <Type> L = new LinkedList<Type> ( ) : pour la création d'un objet vide L de type
Type (Type peut être Integer (entier), Double (double), etc.).
- add (Object o): pour ajouter un élément o a une structure de type ArrayList/LinkedListe à la fin.
- get(i): retourne l'objet à la position i.
- size(): donne le nombre d'éléments d'un objet de type ArrayList/LinkedList.
- Utiliser la méthode statique sort de la classe java.util.Collections pour le trie.