Teaching - 2i002 - (TME: sujets)


2i002 : Introduction à la programmation Objet

Exercice 1 : Modélisation d'une liste (file ou pile)

Une liste est une structure de données qui permet de stocker un nombre dynamique d'objets. Les opérations usuelles des listes sont les suivantes :

  • ajouter un élément (méthode void push(Object o) )
  • enlever un élément (méthode Object pop() )
  • tester si la liste est vide (méthode boolean isEmpty() )
  • compter les éléments (méthode int size() )

Rappel de documentation: dans une ArrayList<Object> , les méthodes suivantes sont utiles:

  • void add(Object o) : ajouter un élément à la fin
  • Object remove(int i) : retirer l'élément et renvoyer l'élément à la position i
  • int size() : retourner la taille de la liste

Il faut ajouter la commande import java.util.ArrayList; en début de fichier pour utiliser les ArrayList .

Question 1 :

Donner le code de la classe abstraite Liste qui a pour attribut protected une ArrayList<Object> liste . Les méthodes isEmpty , size et push sont réalisables ici mais pas pop qui dépend du type de la liste concrète.

Question 2 :

Donner le code de la classe ListeLIFO qui est une pile.

Dans un pile, le dernier élément ajouté est celui qui est retiré en premier. En déduire l'implémentation de pop .

Question 3 :

Donner le code de la classe TestLIFO qui contient un main , instancie une pile et teste son bon fonctionnement en quelques affichages.

Exercice 2 : Robots

Le Monde est constitué d'une matrice carrée de cases... Et chaque case est une pile qui peut contenir plusieurs papiers gras. Différents types de robots agissent dans ce monde : des robots pollueurs et des robots nettoyeurs. Les robots pollueurs se baladent dans le monde et déposent des papiers gras sur les cases où ils se trouvent. Les robots nettoyeurs quant à eux ne supportent pas la vue d'un papier gras et l'enlèvent dès qu'ils en voient un sur la case où ils se trouvent.

Les robots pollueurs sont de deux sortes :

  • les robots idiots : à chaque tour ils décident au hasard où ils se déplacent et avec une probabilité de 20% déposent un papier gras sur la case.
  • les robots butés : ils se déplacent uniquement sur une ligne, d'une case à la fois en faisant des aller-retours. Ils déposent un papier gras sur la case avec une probabilité de 30%

Les robots nettoyeurs parcourent le monde en se déplaçant de deux façons :

  • les normaux : à chaque fin de ligne, le robot se déplace à la ligne suivante et la parcours en sens inverse;
  • les maniaques : vers la case sale la plus proche.

Question 1 : classe Robot

  • La classe mère gère les coordonnées entière (i,j).
  • Le constructeur de la classe mère prend des coordonnées en argument.
  • La classe mère dispose d'une méthode protected move(di, dj) effectuant une translation sur i et j .
  • Tous les robots ont un numéro de série unique (commençant à 0 pour le premier et incrémenté au fur et à mesure).
  • La classe mère dispose d'un accesseur sur le numéro de série.
  • Tous les robots ont au moins deux méthodes:
    • public void move(Monde m) pour se déplacer
      NB: il y aura des accesseurs sur la dimension du monde et les robots ne peuvent pas se déplacer en dehors du monde (vous choisissez la solution que vous voulez pour le gérer)
    • public void action(Monde m) pour laisser/récupérer des papiers

Implémenter la classe mère abstraite Robot et un seul Robot de chaque sorte (au choix). Vous interagirez avec le monde à l'aide des méthodes décrites au début de la question suivante.
NB: c'est à vous de déterminer les méthodes qui doivent être abstraites, celles qui doivent être redéfinies etc...
NB2: tous les robots sont créés en donnant les coordonnées (i,j) initial du robot.
NB3: tous les robots envoient un message dans la console lorsqu'ils mettent/enlèvent un papier dans le terrain

Question 2 : Classe PapierGras

Créer une classe PapierGras très basique:

  • Pas d'attribut
  • Constructeur sans argument

Cette classe servira simplement aux robots pour déposer/retirer des papiers...

Question 3 : Classe Monde

Rappel: plusieurs papiers peuvent être déposés sur une même case, on utilisera une pile pour les représenter.

La classe Monde possède:

  • attribut : dimension (le monde est carré)
  • un attribut ArrayList<Robot> robots (donné au constructeur),
  • un attribut terrain qui est une matrice de piles pour stocker les papiers dans chaque case,
  • un constructeur prenant en argument une arraylist de robots et une dimension. Ce constructeur initialise le terrain en déposant 0, 1 ou 2 papiers dans chaque case.

Aide: attention, dans chaque case, il faut instancier la pile avant de la remplir

  • une méthode retournant la pile de la case (i,j) Même si ce n'est pas très propre, les robots se servent de cette méthode pour ajouter/retirer des papiers dans la case (i,j).
  • Accesseur sur la dimension
  • une méthode toString() Le monde sera représenté par une chaîne de caractère où une case avec papier gras sera représentée par un entier (le nombre de papiers), une case vide par .
  • une méthode nextRound() qui fait jouer tous les Robots pour un coup (chaque robot agit et bouge une fois)

Donner le code de la classe Monde

  1  2  1  1  2 .   1  1  1  2 .  .   1  2  2  1  2  2 .   1
  1 .   2  2 .   1 .   2  1  1  2 .   1  1 .  I3  2 .   2 . 
  1 .   2 .   1  2 .   1 .   2  1  2 .   1 .   1 .   1  2  2
  2  1  1  2  1  1 .   2 .   2  2  2  1  1 .  .  .   2 .   1
  1  2 .  .   1  1  1  2  2 .   1 .   2  1  1  2  1  2 .  . 
 .   1  2  2  2  2  2 .   2  2  1  1  2  1 .   1  1  2 .   2
 .   2  1 .   1 .   2 .  .   1  2 .   2 .   2  2  2  1  2 . 
  2  1  1 .  .  .   2  1  2 .   1  2  1  1  1  2  1  2  1  2
  2 .   1  2 .   2  1 .   1  2 .  .   1 .   2 .  .  .  .  . 
  1  1 .   2  1  1 .   1  1 .   2  1  1  1  2 .  .  .  .   1
  2  1  2 .   1 .   2  1 .  .   1  1  1  1 .   2 .  .  .  B2
  2  1  2 .  .   1 .   1  1  1  1  2  2  2 .   2 .   2  2 . 
  2  1  2  2 .   2  1  2  2  2  1 .   2 .   2  2  1  1  1  2
 .   1 .   2  1  2 .   2  1  2  1 .  .   2 .  .   1 .   1 . 
  1  2  2  1  2  2  2  1 .  .  .  .   1  1 .   1 .   1  1  1
  2 .  .   2  1  1  1  1 .   1  1  1  1  1  1  1  2 .   2  1
 .   1 .   2  2  1  1  2  2  2  1  1  1  2  1  1  2  2 .   1
 .  .   2  2  1  1  2  2  1  2 .  .   1 .   1  1  1  2  1  2
 .   2  1 .  .  N1  2  1  2  1 .   2 .   2  1 .   1 .   1  1
  1  1 .   1 M0  2  2  2  1 .   1  1  2  1  2  1  2  1 .   2

Exemple de monde

Question 4 : classe de test

Donner le code de la classe TestMonde qui contient un main réalisant les opérations suivantes:

  • Choix d'une dimension pour le futur monde
  • Création de 3 Robots (avec des coordonnées aléatoires) + mettre les robots dans une ArrayList
  • Création d'un Monde m de 20x20 cases
  • Affichage du Monde m
  • Effectuer quelques itérations de mouvement/action des robots et afficher l'évolution du Monde.

Proposition de code pour attendre entre deux itérations:

import java.util.Scanner;
...
Scanner scan = new Scanner(System.in);
...
scan.next(); // attente d'une entree clavier

Question 5 :

Modifier la fonction d'affichage du monde pour afficher les Robots à leur position (avec une lettre particulière pour leur type et leur numéro de série)

Question 6 :

[Bonus] Coder les robots manquants et vérifier leur bon fonctionnement

Question 7 :

Coder une interface graphique conviviale pour mieux appréhender le déplacement des robots