Licence 3 – MIDO – 2021–2022 Programmation Java

Examen UE Java-Objet

• Date de l’examen : 07/01/2022

• Durée de l’examen : 2h
• Documents et calculatrice non autorisés.
• Pour tous les exercices, on supposera que les import et package sont gérés (vous n’avez donc pas à les mentionner).
• Le barème est donné à titre indicatif et pourra être modifié.

Exercice 1 : Questions de cours. (8 points)

1. Ordonner ces types primitifs du moins expressif au plus expressif : short, long, byte, int.
2. Quelle est la différence entre un flux en entrée et un flux en sortie en Java ? Même question pour un
flux d’octets et un flux de caractères.
3. Quelle est la complexité pire cas de la méthode remove(int index) de l’interface List si la liste
en question est un ArrayList ? un LinkedList ? Cette méthode enlève l’élément à l’indice index
de la liste. Vous exprimerez cette complexité en fonction du nombre n d’éléments dans la liste et vous
justifierez votre réponse.
4. Citer trois annotations utilisées dans les tests JUnit.
5. Qu’est-ce que le mécanisme d’effacement utilisé pour gérer la généricité en Java ?
6. Ce code compile-t-il ? Si la réponse est non, expliquer toutes les erreurs. Si la réponse est oui,
qu’affiche-t-il ?

1 public abstract class Animal {

2 private int taille;
3 public int poids;
4

5 public Animal(int taille, int poids) {

6 this.taille = taille;
7 this.poids = poids;
8 }
9

10 public abstract void bruit();

11 }

1 public class Chien extends Animal {

2 public Chien(int taille, int poids) {
3 this.taille = taille;
4 this.poids = poids;
5 }
6

7 @Override
8 public void bruitChien() {
9 System.out.println("Miaou");//Ceci n'est pas une erreur Java
10 }
11

12 public static void main(String[] args) {

13 Chien c = new Chien(2,3);
14 c.bruit();
15 }
16 }
Licence 3 – MIDO – 2021–2022 Programmation Java

Exercice 2 : Election et délégations de vote (12 points)

Dans l’exercice, on vous demande d’implémenter des classes. Lisez d’abord l’ensemble du sujet, cela
vous aidera peut-être à faire des choix pertinents pour l’implémentation et à ajouter certaines méthodes
nécessaires. On supposera que les import sont gérés. L’annexe contient des informations sur certaines
méthodes des classes et interfaces Random et Comparator.

Dans certains processus de vote, chaque votant peut soit voter soit déléguer son vote. Dans ce second
cas, c’est un autre votant qui votera à sa place. Ainsi, certains votants ont plusieurs voix et d’autres ne votent
pas, ils ne font que choisir leur délégation. Une équipe de chercheurs souhaite développer un logiciel pour
modéliser un processus électoral où chaque votant peut déléguer son vote d’une manière un peu particulière
(ce qui est expliqué un peu plus loin) 1 . Une personne possède un nom (de type String). On suppose
également que le positionnement politique de chaque personne peut être modélisé par une valeur entière
positive entre 0 (extrême gauche) et 10 (extrême droite). Ces positionnements politiques définissent une
distance. Ainsi, un individu avec un positionnement politique de 3 sera à une distance de 2 d’un individu
avec un positionnement politique de 5.

Eddy Abel Bea Dany Fayza Carl

0 1 2 3 4 5 6 7 8 9 10

Figure 1 – Un exemple avec différentes personnes positionnées sur l’intervalle [0, 10] en fonction de leurs position-
nements politiques. Eddy a des idées très à gauche alors que Carl a des idées très à droite. Dany et Carl sont à une
distance idéologique de 4 ; Abel et Bea sont à une distance idéologique de 2.

Question 1 : Ecrire une classe Personne qui représentera une personne avec un constructeur qui prend en
paramètre un String nom et qui initialise le positionnement politique de la personne aléatoirement. Vous
pouvez laisser de l’espace pour compléter cette classe plus tard, notamment avec des getters et setters.

Un votant est une personne qui peut voter lors de l’élection. Chaque votant possède comme attribut un
double precision à valeur dans [0,1) et qui représente la capacité du votant à identifier le candidat le plus
proche de ses convictions politiques. Un votant pourra également déléguer son vote à un autre votant. Pour
gérer cette phase de délégation, nous rajoutons trois attributs :
— Un attribut delegation précisant le votant à qui il délègue son vote. Cet attribut sera égal à this
si le votant vote directement (et donc ne délègue pas).
— Un attribut entier poids égal au nombre de délégations reçues (en comptant le propre vote du votant).
Avant la phase de délégation, qui est expliquée plus en détail par la suite, on suppose cette valeur
fixée à 0.
— Enfin, un votant ne voudra pas déléguer son vote à une personne avec des idées politiques trop
différentes des siennes. Ainsi, chaque votant possède un attribut entier delDist appartenant à [0, 3]
et qui spécifie la distance maximale à laquelle le votant accepte de déléguer son vote.

Question 2 : Ecrire une classe Votant possédant les attributs mentionnés ci-dessus et un constructeur
public Votant() initialisant les attributs precision et delDistance aléatoirement et le nom du votant
à "VotantID" où ID doit être compris comme une valeur entière identifiant le votant de manière unique.

Un candidat est une personne qui concourt à l’élection et ne peut donc pas voter. Un candidat possède
un attribut entier nbDeVotes qui représente le nombre de votes reçus par le candidat.

Question 3 : Ecrire une classe Candidat avec l’attribut nbDeVotes et un constructeur public Candidat()
initialisant le nom du candidat à "CandidatID" où ID doit être compris comme une valeur entière identifiant
1. Si vous êtes intéressé.e.s par les concepts qui ont inspirés ce sujet, vous pouvez consulter ce lien après l’examen https:
//en.wikipedia.org/wiki/Liquid_democracy
Licence 3 – MIDO – 2021–2022 Programmation Java

le candidat de manière unique. Ajouter également une méthode public void receptionVote(int n) qui
rajoute n votes en faveur du candidat.

On cherche maintenant à choisir la délégation d’un votant.

Question 4 : Ecrire une méthode d’instance public void setDelegation(List<Votant> listeDeVotants)

dans la classe Votant qui fixe la délégation du votant (la valeur de son attribut delegation) de la manière
suivante. On supposera que le votant cherche parmi les votants qui sont 1) dans la liste listeDeVotants
et 2) à une distance inférieure ou égale à delDist de lui, celui qui à la valeur precision maximale. On
supposera que le votant v fait lui même partie de listeDeVotants si bien qu’il est lui même une option
possible pour sa propre délégation. Vous utiliserez un iterator pour parcourir la liste de votants.

Eddy Bea Dany Fayza

0.3 0.8 0.7 0.6
0 1 2 3 4 5 6 7 8 9 10

Figure 2 – On illustre ici le processus de délégation. Bea, Dany, Eddy, et Fayza sont les votants de l’élection et
Abel et Carl sont des candidats. Dany a un attribut delDist = 2, l’intervalle des délégués possibles pour lui contient
donc Fayza, Bea, et Dany lui même. La valeur de l’attribut precision pour chaque votant est écrite en dessous de son
prénom. Dany choisira donc le délégué le plus expert, ici Bea (délégation représentée par une flèche bleue en pointillés).

Notez qu’un votant A peut déléguer à un votant B qui délègue à un votant C et ainsi de suite. Dans ce
cas là, on suppose que les délégations se transmettent de manière transitive. Ainsi, si A délègue à B qui
délègue à C, alors le vote de A sera délégué à C de manière indirecte (peu importe la distance idéologique
entre les votants A et C). Dit autrement, les délégations des votants peuvent former des chaînes (ici, par
construction, il ne peut y avoir de cycle dans les délégations), et les délégations sont transmises au votant
à la fin de la chaîne de délégations.

Eddy Bea Dany Fayza

0.3 0.8 0.7 0.6
0 1 2 3 4 5 6 7 8 9 10

Figure 3 – Bea, Eddy et Fayza ont un attribut delDist = 1. Ainsi, par la règle de délégation précédente Bea et Eddy
votent et Fayza délègue à Dany qui lui délègue à Bea (donc Fayza délègue par transitivité à Bea ). En fin de compte,
Fayza et Dany ont un poids = 0, Eddy a un poids = 1 et Bea a un poids = 3.

Question 5 : Ecrire dans la classe Votant une méthode d’instance public void delegationAuProxy().
Cette méthode trouve la personne à la fin de la chaîne de délégations dans laquelle se trouve le votant et
augmente l’attribut poids de cette personne (qui est en fait aussi un votant) de 1, pour prendre en compte
la délégation (possiblement indirecte) du votant. Dans l’exemple, précédent, si on applique cette méthode à
l’instance correspondant à Fayza, alors cela augmentera l’attribut poids de Bea de 1.

Question 6 : Ecrire dans la classe Votant une méthode public void vote(List<Candidat> listeCandidats).
Si le votant vote directement (il ne délègue pas), alors il votera de la manière suivante :
— Avec une probabilité precision, il votera pour le candidat le plus proche de lui en termes de
convictions politiques dans la liste listeCandidats.
— Avec une probabilité (1 - precision), il votera pour le second candidat le plus proche (on suppose
qu’il y a au moins deux candidats).
Pour réaliser cette opération vous allez trier la liste avec la méthode void sort(Comparator<? super E> c)
de l’interface List. En votant, il rajoutera this.poids votes au candidat soutenu. Si le votant délègue, cette
Licence 3 – MIDO – 2021–2022 Programmation Java

méthode ne fait rien. Dans l’exemple précédent, Bea et Eddy voteront pour Abel (le candidat le plus proche
d’eux) avec une probabilité 0.8 et 0.3 respectivement et pour Carl sinon.

Question 7 : Ecrire une classe Main qui teste votre programme. La méthode main initialisera une liste de 4
votants et une liste de deux candidats, puis elle exécutera les phases de délégation et de vote.
Annexes
Certaines méthodes de la classe Random :
Modifier and Type Method Description
Random()
Creates a new random number generator.
boolean nextBoolean()
Returns the next pseudorandom, uniformly dis-
tributed boolean value from this random number
generator’s sequence.
double nextDouble()
Returns the next pseudorandom, uniformly dis-
tributed double value between 0.0 and 1.0 from
this random number generator’s sequence.
int nextInt(int bound)
Returns a pseudorandom, uniformly distributed
int value between 0 (inclusive) and the speci-
fied value (exclusive), drawn from this random
number generator’s sequence.

Méthode requise de l’interface Comparator<T> :

Modifier and Type Method Description

int int compare(T o1,T o2)
A negative integer, zero, or a positive integer as the first
argument is less than, equal to, or greater than the second.