Teaching - 2i002 - (TME: sujets)


2i002 : Introduction à la programmation Objet


Exercice 1: plaque d'immatriculation

Un département attribue les plaques d'immatriculation (à l'ancienne): le département 1 attribue des plaques XXX AA 1, où XXX est un nombre en 1 et 999 et AA un code de lettre entre AA et ZZ. Le département gère les plaques de sorte que:

  • Toutes les plaques terminent par le numéro du département
  • Il ne génère jamais deux fois la même plaque
  • Il respecte les règles d'incrément décrites dans l'exemple suivant

Exemple de séquence de génération dans le détail:

 1 AA 1 // première plaque
 2 AA 1 // deuxième plaque
 ...
 999 AA 1
 1 AB 1
 ...
 999 AZ 1
 1 BA 1

Au niveau de la modélisation générale: IL N'Y A QU'UNE CLASSE (plus une de test)

  • Departement possède une méthode genere qui génère des plaques
  • TestDepartement instencie un (ou plusieurs) département puis génère des plaques et les affiche

Classe Departement

Concernant le numéro de département: il est unique et représentatif du département et de l'ordre de création. Le premier département à toujours le numéro 1, le deuxième département toujours le numéro 2 (en fait, il s'agit d'un compteur d'instance classique).

Chaque plaque générée est de la forme: NUM LettreLettre NUM_DEPARTEMENT

  • Attributs
    • NUM_DEPARTEMENT le numéro du département est unique (il sera géré à l'aide d'un compteur static)
    • NUM est géré à l'aide d'un attribut
    • LettreLettre est géré à l'aide de 2 attributs de type char
  • La méthode String getPlaque() retourne une plaque d'immatriculation sous forme de chaine de caractères.
    • Il faut donc créer la plaque,
    • puis incrémenter proprement tous les compteurs
 après 999 AA 1, on a 1 AB 1
après 999 AZ 1, on a 1 BA 1...

NB: le cas de ce qui se passe après 999 ZZ 1 n'est pas géré ici.

Classe Test

Pour tester votre classe commencer par créer plusieurs département et plusieurs plaques dans chaque département.

Vous vous concentrerez ensuite sur un département et demanderez plusieurs milliers de plaques à l'aide d'une boucle pour vérifier le défilement des lettres


Exercice 2: les moutons dans le pré

Le but: dessiner un pré et des moutons (numérotés) se promenant dedans...

______________________________________________________________
|  0 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .   1 .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .   2 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .   3 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .   4 .  .  .  .   5  6 .  .  .  .  .  .  .  .  .  .  . |
|  7 .  .  .  .  .  .  .  .  .  .  .  .   8 .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .   9|
| .  .  .  .  10 .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  11 .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  12 .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  13 .  .  .  .  .  14 .  .  . |
| .  .  .  15 16 .  .  .  .  .  .  .  .  17 18 .  .  .  .  . |
| 19 .  .  .  .  .  .  .  .  20 .  .  .  .  .  .  .  .  .  21|
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  22 .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  23 .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| 24 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  25 .  .  .  .  .  .  . |
| .  .  .  .  .  .  26 .  .  .  .  .  .  .  .  .  .  .  .  . |
______________________________________________________________

Un terrain est composé de cases qui contiennent des moutons (ou pas)

La classe Case

La classe Case a un attribut Mouton: cet attribut est null si la case est vide.

La Case possède un accesseur Mouton getMouton() et un setter void setMouton(Mouton m)

La case possède une méthode toString() qui renvoie " . " si elle est vide et l'id du mouton si elle est pleine.

NB: pour afficher l'id du mouton sur 3 caractères, on utilisera la commande suivante:

  String.format("%3d", mouton.getId())

La classe Mouton

possède donc un identifiant id (le premier mouton a un id=0, le second id=1...). Vous utiliserez un attribut static compteur pour initialiser les id.

La classe Terrain

possède une matrice de Case.

Une constante définie la taille du terrain (20x20 par exemple)

Le constructeur du terrain initialise le tableau et place un mouton dans les cases avec une probabilité de 5% (95% des cases sont vide et 5% contiennent des moutons).

Une méthode toString() permet de renvoyer une chaine dessinant le terrain en entier.

Une méthode update() parcourt toutes les cases et déplace les moutons d'une case vers la droite avec une probabilité 1/5.

  • S'il y a un mouton dans la case
    • Si la case de droite est vide (pas de mouton et case pas au bord)
      • Si la proba est respectée
on déplace le mouton!

Classe de test

La classe de test consiste à créer un terrain, l'afficher puis appeler 10 fois:

  • update()
  • effectuer un affichage
  • prendre une pause

NB pour la gestion de la pause (à utiliser en aveugle...)

  try{
     Thread.sleep(100); // 100 ms
  }catch(Exception e){
     e.printStackTrace();
  }

Exercice 3 : Bomberman

Plus dur maintenant: les moutons explosent et provoquent des réactions en chaine...

Les moutons deviennent des bombes qui ne bougent plus

Les bombes possède:

  • leur position (qui leur est donnée dans le constructeur)
  • un timer initialisé aléatoirement entre 2 et 7 (à 0, la bombe explose)
  • une portée en nombre de case (3 par exemple)
  • une méthode update qui décrémente le timer
  • des accesseurs vers le timer, l'id...

Les cases possèdent maintenant un attribut booléen explose

  • cet attribut est false par défaut
  • il devient true si une explosion a lieu sur la case
  • la méthode toString() renvoie:
    • " . " pour une case vide non explosée
    • " # " pour une case explosée
    • l'id de la bombe pour une case non explosée contenant une bombe

Le terrain est toujours composé de cases... Mais sa mise à jour update change complètement:

  • on parcours toutes les cases
  • si la case contient une bombe non explosée
    • on vérifie le timer
    • si timer == 0 alors explosion de la bombe (cf procédure suivante)
    • sinon update de la bombe
  • cette méthode compte le nombre de bombes non explosées et retourne ce nombre vers le programme principal

La méthode d'explosion est complexe:

  • Elle met à jour la case ou se trouve la bombe (->explosée)
  • Elle parcours toutes les cases en ligne dans la portée de la bombe à l'aide d'une boucle... Vous utilisez éventuellement un code de la forme suivante:
   for(int i=Math.max(0, b.getX()-b.getPortee()) 
           ;i<Math.min(dim, b.getX()+b.getPortee()); i++){
			if(i==b.getX())
				continue;
			if(terrain[i][j].isExplosion())
				continue;

où b est une bombe et terrain la matrice de cases.

  • mettre la case dans l'état explosé
  • si la case contient une bombe, la faire exploser

Vous gèrerez une classe de test pour illustrer le fonctionnement des méthodes

Après quelques bombes explosées, on se retrouve dans la situation suivante:

______________________________________________________________
| .   0 .  .  .  .  .  .  .  #  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  #  .  .  .  #  .  .  .  .  .  . |
| .  .  .  .   1 .  .  .  .  #  .  .  .  #  .  .  .  .  .  . |
| .  .  .  .  .  #  #  #  #  #  #  #  #  #  .  .  .  .  .  . |
|  3 .  .  .  .  .  .  .  .  #  #  #  #  #  #  #  #  .  .  . |
| .  .  .  .  .  .  .  .  .  #  .  .  .  #  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  #  .  .  .  #  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  #  .  .  .  #  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .   5 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .   6 .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  #  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  #  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  #  #  #  #  # |
| .   8 .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  #  .  . |
| .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  #  .  . |
______________________________________________________________