NOM : Université de Montpellier

Prénom : IUT département informatique

Date : 22 décembre 2017
Épreuve : Programmation 1 bis
Durée : 2 h
Autorisations : Pas de notes, pas de machine

Chaque feuille sera corrigée par un enseignant différent. Si vous n’avez pas de place pour finir un
exercice, ne continuez donc pas sur une autre feuille du sujet, mais demandez plutôt une feuille
supplémentaire !

1 Simulation de vols d’avions

On souhaite écrire un programme de simulation de vols d’avions entre des aéroports. Chaque vol
est représenté par deux événements : événement « décollage » à l’aéroport de départ et événement
« atterrissage » à l’aéroport d’arrivée. Chaque événement (instance de la classe Evenement) est
caractérisé par sa date, un aéroport, un avion, et un booléen noté decol égal à vrai s’il s’agit
d’un décollage et à faux s’il s’agit d’un atterrissage. Chaque aéroport contient la liste de tous les
événements à venir se passant à cet aéroport, triée par ordre chronologique croissant. Une date est
constituée d’un jour et une heure, par exemple le 22 décembre 2017 à 13h30.
Pour simplifier, on suppose que chaque aéroport n’a qu’une piste et que chaque décollage ou
atterrissage peut s’effectuer en une minute. Il en résulte que deux événements se passant dans
le même aéroport doivent avoir des dates différentes, mais peuvent se suivre d’une minute. La
contrainte sur la liste d’événements à venir dans un aéroport est donc qu’elle est triée par ordre
chronologique strictement croissant (instance de la classe ListeTrieeEvent).
Pour simplifier aussi, on suppose qu’un avion n’effectue qu’un seul vol. Un avion est créé par
l’aéroport de départ du vol qu’il va effectuer au moment de l’ajout du vol (et ne sera plus utilisé
une fois que son vol est achevé).
On définit les classes Avion, Aeroport, Evenement et ListeTrieeEvent, ainsi qu’une classe Test
pour tester ces classes, que vous aurez à compléter. Les dates des événements sont des instances
d’une classe Date que vous n’avez pas besoin de connaître. La classe ListeTrieeEvent utilise une
classe MaillonEvent, similaire à la classe Maillon vue en cours et en TD, qui est donnée dans le
sujet.
Pour écrire les constructeurs et méthodes demandés, vous pouvez (et devez) utiliser d’autres
constructeurs ou méthodes définis dans le sujet (même si vous n’avez pas su les écrire ou s’ils
se trouvent dans des pages suivantes du sujet), mais vous ne pouvez pas en définir d’autres, sauf
pour la question 17 où on vous le demande explicitement. Vous ne devez écrire aucune instruction
d’affichage (sauf pour la méthode de la classe Test).
Pour laisser plus de place pour l’écriture des constructeurs et méthodes, la spécification des pré-
requis est omise quand il n’y en a aucun.

La classe Avion
La classe Avion possède un attribut de classe (static) et deux attributs d’instance :

1
private static int numProchain = 1; // numéro du prochain avion à créer
private int numero; // 1, 2, 3, ... au fur et à mesure des créations d’avions
private boolean enVol; // vrai si et seulement si l’avion est en vol

La variable de classe Avion.numProchain contient le numéro du prochain avion à créer, de sorte

que le premier avion créé ait le numéro 1, le deuxième avion créé ait le numéro 2, etc.
Écrire le constructeur et les méthodes suivants de la classe Avion :

Question 1 (1 point)

// action : crée un avion au sol

public Avion(){

Question 2 (0,5 point)

/* résultat : retourne une chaîne de caractères de la forme "avion numero 3

en vol" si this est en vol et de la forme "avion numero 3 au sol" sinon */
public String toString(){

Question 3 (0,5 point)

/* pré-requis : this est au sol

action : fait décoller this */
public void decolle(){

Question 4 (0,5 point)

/* pré-requis : this est en vol

action : fait atterrir this */
public void atterrit(){

2
NOM :
Prénom :

La classe Aeroport
La classe Aeroport possède les attributs d’instance suivants :

private String nom; // exemple : "Paris Orly"

private Avion[] tabAvions;
private int nbAvions;
private ListeTrieeEvent events;

Le tableau tabAvions contient les avions se trouvant actuellement à l’aéroport. La longueur de ce

tableau est le nombre maximum d’avions pouvant se trouver à l’aéroport en même temps et est
définie par le constructeur de l’aéroport. Le nombre d’avions se trouvant actuellement à l’aéroport
est donné par l’attribut nbAvions. Ces avions sont rangés dans les nbAvions premières cases du
tableau tabAvions dans un ordre arbitraire. L’attribut events contient la liste des événements
(décollage/atterrissage) à venir à l’aéroport, triée par ordre chronologique strictement croissant.
Le constructeur et les méthodes concernant les événements utilisent les constructeurs et méthodes
des classes Evenement et ListeTrieeEvent que vous pouvez consulter dans les pages suivantes de
ce sujet.
La classe Aeroport possède la méthode suivante que l’on ne vous demande pas d’écrire :

/* résultat : retourne une chaîne de caractères contenant l’état actuel de

this */
public String toString(){...}

Écrire le constructeur et les méthodes suivants de la classe Aeroport :

Question 5 (1 point)

/* pré-requis : nbMax > 0

action : crée un aéroport de nom n, sans avion ni événement et pouvant
contenir au maximum nbMax avions */
public Aeroport(String n, int nbMax){

3
Question 6 (1 point)

/* pré-requis : l’avion a n’est pas dans this et

this.nbAvions < this.tabAvions.length
action : ajoute l’avion a à this (lors de la création ou de l’atterrissage
de a) */
public void ajoutAvion(Avion a){

Question 7 (2 points)

/* pré-requis : l’avion a est dans this

action : enlève l’avion a de this (lors du décollage de a)
Remarque 1 : on rappelle que l’ordre des avions dans this.tabAvions est
arbitraire.
Remarque 2 : on peut tester l’égalité de deux avions à l’aide de l’opérateur
== ou != (le constructeur de la classe Avion ne pouvant créer deux instances
de même numéro, un avion n’est représenté que par une seule référence). */
public void enleveAvion(Avion a){

Question 8 (0,5 point)

/* résultat : retourne vrai si et seulement si this est disponible à la date d,

c’est-à-dire qu’aucun des événements de this.events ne se passe à la date d
Remarque : utiliser une ou des méthodes demandées plus loin */
public boolean dispo(Date d){

4
Question 9 (0,5 point)

/* pré-requis : l’événement e se passe dans this et this est disponible à la

date de e
action : ajoute e à this.events (en conservant l’ordre chronologique
strictement croissant)
Remarque : utiliser une ou des méthodes demandées plus loin.
*/
public void ajoutEvent(Evenement e){

Question 10 (2 points)

/* pré-requis : d1 est strictement antérieure à d2

action : si this est disponible à la date d1 et a2 est disponible à la date
d2 alors crée un avion dans l’aéroport this, ajoute dans les 2 aéroports les
événements liés au vol de cet avion, dans l’aéroport this à la date d1, dans
l’aéroport a2 à la date d2, et retourne vrai, sinon retourne faux
Remarque : utiliser une ou des méthodes demandées plus loin.
*/
public boolean ajoutVol(Date d1, Date d2, Aeroport a2){

Question 11 (0,5 point)

/* pré-requis : la date d est antérieure ou égale à la date du premier

événement de this.events s’il existe
action : si this.events contient un événement se passant à la date d alors
exécute cet événement et le supprime de this.events
Remarque : utiliser une ou des méthodes demandées plus loin.
*/
public void execute(Date d){

5
NOM :
Prénom :

La classe Evenement
La classe Evenement a quatre attributs d’instance :

private Date date;

private Aeroport aero;
private Avion avi;
private boolean decol; // vrai si et seulement si l’événement est un décollage

Elle possède le constructeur et les méthodes suivants que l’on ne vous demande pas d’écrire :

// action : crée un événement dont les attributs sont donnés par les paramètres
public Evenement(Date d, Aeroport ae, Avion av, boolean dec){...}

// résultat : retourne vrai si et seulement si la date de this est égale à d

public boolean dateEgale(Date d){...}

// résultat : retourne vrai si et seulement si la date de this est strictement

// antérieure à d (c’est-à-dire avant d)
public boolean anterieur(Date d){...}

Écrire la méthode suivante de la classe Evenement :

Question 12 (1,5 points)

/* pré-requis : si this.decol alors this.avi est au sol à l’aéroport this.aero,

sinon this.avi est en vol
action : exécute l’événement this (décollage ou atterrisage de l’avion et
mise à jour de l’ensemble d’avions de l’aéroport) */
public void execute(){

6
NOM :
Prénom :

La classe ListeTrieeEvent
La classe ListeTrieeEvent utilise la classe MaillonEvent, qui est obtenue à partir de la classe
Maillon en remplaçant le type int de l’attribut valeur par Evenement. Son constructeur et ses
méthodes sont rappelés ci-dessous.

public class MaillonEvent {

private Evenement valeur;

private MaillonEvent suivant;

/** Constructeur avec une valeur */

public MaillonEvent (Evenement e) { this.valeur = e; this.suivant = null; }

public Evenement getVal() {return this.valeur;}

public void setVal(Evenement e) {this.valeur = e;}

public MaillonEvent getSuiv () {return this.suivant;}

public void setSuiv (MaillonEvent m) {this.suivant = m;}

La classe ListeTrieeEvent permet de gérer des listes d’événements, ces listes étant nécessairement
triées par ordre chronologique strictement croissant. Vous devez veiller à respecter et utiliser cette
contrainte dans l’écriture des méthodes de cette classe. La classe ListeTrieeEvent a un attribut
d’instance :

private MaillonEvent tete;

Elle a le constructeur et les méthodes suivants (l’écriture de la méthode insere fera l’objet de la
question 17 en page 10) :

// constructeur d’une liste vide

public ListeTrieeEvent () {this.tete == null;}

// resultat : retourne vrai si et seulement si this est vide

public boolean estVide () {return this.tete == null;}

/* pré-requis : aucun événement de this ne se passe à la date de e

action : ajoute e à this (en conservant l’ordre chronologique strictement
croissant) */
public void insere(Evenement e){...}

Écrire les méthodes suivantes de la classe ListeTrieeEvent :

7
Question 13 (1 point)

/* pré-requis : la date de e est strictement antérieure à la date du premier

événement de this s’il existe
action : ajoute e en tête de this
*/
public void ajoutTete (Evenement e) {

Question 14 (2 points)

/* résultat : retourne vrai si et seulement si l’un des événements de this se

produit à la date d
*/
public boolean existe(Date d){

Question 15 (1,5 points)

/* pré-requis : la date d est antérieure ou égale à la date du premier

événement de this s’il existe
action : si le premier événement de this existe et se produit à la date d
alors exécute cet événement et le supprime de this
*/
public void execute(Date d){

8
NOM :
Prénom :

La classe Test
La classe Test permet de tester les classes précédentes. Écrire un programme qui définit un vol le
22 décembre 2017 partant de l’aéroport Montpellier Méditerranée à 17h30 et arrivant à l’aéroport
Paris Orly à 18h45, puis simule le décollage (avec affichage de l’état de l’aéroport Montpellier
Méditerranée avant et après le décollage), puis simule l’atterrissage (avec affichage de l’état de
l’aéroport Paris Orly avant et après l’atterrissage). On suppose que la classe Date a un constructeur
de la forme

public Date (int jour, int mois, int annee, int heure, int minute)

créant la date définie par ses paramètres. Pour l’affichage, vous pouvez utiliser la méthode Ut.afficher.

Question 16 (2 points)

public static void main(String[] args){

9
QUESTION PLUS DIFFICILE
Écrire la méthode insere de la classe ListeTrieeEvent. Pour écrire cette méthode, vous devez
rajouter une méthode à la classe Evenement, que vous écrirez (définition complète) en bas du recto
ou du verso de cette feuille ou sur une feuille supplémentaire.

Question 17 (2 points)

/* pré-requis : aucun événement de this ne se passe à la date de e

action : ajoute e à this (en conservant l’ordre chronologique strictement
croissant) */
public void insere(Evenement e){

10