TD4 - SoC

ELI4 - 2011/2012
TP solitaire Programmation Orientée Objet - langage Java
TP solitaire Programmation Orientée Objet
Langage Java
Durée 2h - Tous documents autorisés
Remarques importantes
Ce TP s’effectue de manière individuelle. Vous avez le droit d’utiliser l’ensemble des documents
que vous souhaitez, mais sachez que plus vous passez de temps à chercher, moins de temps
vous aurez pour composez ! Pour ce TP, vous serez évalué non seulement sur le fonctionnement
de votre programme, mais aussi sur la façon dont il est écrit, en utilisant au maximum les
principes de la programmation objet. Les questions doivent être traitées dans l’ordre donc lisez
bien l’ensemble du sujet avant de commencer et n’hésitez pas à commenter votre code ! Testez
votre code au fur et à mesure des questions.
Il n’est pas nécessaire, voire déconseillé, d’utiliser Netbeans. Utilisez plutôt un éditeur classique
de type gedit.
Mettez votre nom en commentaire en haut de chacun de vos fichiers.
A la fin de l’épreuve, vous devez déposer vos sources dans votre boı̂te de dépôt sur Sakaı̈.
Pour commencer récupérez le fichier robots.java dans les ressources de Sakaı̈. Ce fichier permet
de tester votre programme.
Sujet
Le but de ce TP est de créer une petite application permettant de simuler un monde dans lequel
vivent différents types de robots. Ces robots évoluent sur un plateau de 10x10 cases et sont fixes
ou mobiles. Ils ont également la propriété d’effectuer une action lorsqu’un autre robot entre en
collision avec eux. Chaque type de robot mobile est caractérisé par son déplacement (aléatoire
pour les robots fous, suivant un autre robot pour les robots suiveurs...). Lorsqu’un autre robot
entre en collision avec eux, il s’arrête sur la case précédente. Les robots fixes ne bougent pas,
mais ont une action plus importante sur les robots qui les cognent (les tuer pour les robots
tueurs, les expulser à un coin du plateau pour les robots répulseurs...). Dans le cadre de ce TP,
on se contentera de modéliser les robots fous et les robots tueurs, mais la modélisation se fera
comme s’il y en avait d’autres.
Les robots sont caractérisés par leurs coordonnées sur le plateau, leur nom (”F” pour les robots
fous et ”T” pour les robots tueurs), s’ils sont vivants ou non et leur action en cas de collision.
Le robot mobile peut se déplacer d’une certaine distance selon une direction (nord, sud, est,
ouest).
Question 1
Ajouter à l’interface graphique un bouton next qui permet de faire évoluer le plateau en appelant les méthodes update() du monde et de l’interface.
Polytech’Paris-UPMC
1
ELI4 - 2011/2012
TP solitaire Programmation Orientée Objet - langage Java
Question 2
Etablir le diagramme de classes, avec leurs champs et méthodes permettant de décrire les
différents types de robots. Pour cette question il n’est pas demander de schéma, le diagramme
sera visible à la lecture du code. Votre modélisation devra tenir compte au maximum des
principes de programmation objet (héritage, surcharge...).
Question 3
Ecrire les constructeurs aux niveaux de hiérarchie adéquates. Pour obtenir un nombre aléatoire
entre 0 et n-1, on utilise la méthode nextInt(n) qui s’applique sur un objet de type Random
défini dans le package java.util. Un objet de type Random utilise un constructeur sans paramètre pour être créé.
Question 4
Ecrire le code permettant de déplacer un robot fou selon une direction aléatoire.
Question 5
Ecrire le code correspondant à l’action du robot tueur, qui est de tuer le robot qui entre en
collision avec lui.
Question 6
Ecrire le code correspondant à l’action des robots mobiles, qui est de stopper le robot qui entre
en collision avec lui sur la case d’avant.
Question 7
Lorsque vous testez votre code, si un robot sort du plateau le programme s’arrête sur une
exception ArrayIndexOutOfBoundsException. Modifier le code de la méthode update() de la
classe Monde pour que cela ne se produise pas.
Polytech’Paris-UPMC
2
Printed by Roselyne Chotin Avot
mai 14, 13 13:42
import
import
import
import
import
import
robots.java
Page 1/3
java.util.ArrayList;
java.util.Iterator;
javax.swing.*;
javax.swing.border.LineBorder;
java.awt.*;
java.awt.event.*;
mai 14, 13 13:42
robots.java
Page 2/3
public Case(int x, int y){
this.x = x;
this.y = y;
r = null;
}
int x = r.getX(), y = r.getY();
// déplacement du robot
((RobotMobile)r).deplace();
plateau[x][y].removeRobot();
// tant qu’il y a collision et que le robot n’est pas mort action du
robot déjà présent sur la case
while((plateau[r.getX()][r.getY()].hasRobot()) && (! r.isMort())){
plateau[r.getX()][r.getY()].getRobot().action(r);
}
// si le robot est mort on le supprime sinon on met à jour le plate
au
if(! r.isMort())
plateau[r.getX()][r.getY()].setRobot(r);
else
lesRobots.remove(r);
}
}
}
}
public
public
public
public
// L’interface graphique
class Interface extends JFrame{
private JLabel [][] grille = new JLabel[Case.xMax][Case.yMax];
private Monde monde;
// Les cases du plateau : les coordonnées et le robot présent
class Case{
static int xMax, yMax;
private int x, y;
private Robot r;
Robot getRobot(){return r;}
void setRobot(Robot r){this.r=r;}
void removeRobot(){this.r=null;}
boolean hasRobot(){return (r != null);}
}
public Interface(final Monde monde){
super("Le monde des robots");
this.monde = monde;
setBounds(100,100,400,300);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Container pan = getContentPane();
pan.setLayout(new BorderLayout());
// le Jpanel p1 pour les boutons de commandes
// le Jpanel p2 pour l’affichage des robots
JPanel p1 = new JPanel(), p2 = new JPanel();
p1.setLayout(new FlowLayout());
p2.setLayout(new GridLayout(monde.xMax,monde.yMax));
pan.add(p1,BorderLayout.NORTH);
pan.add(p2,BorderLayout.CENTER);
// La classe Monde représente le monde cad les robots et le plateau
class Monde{
ArrayList<Robot> lesRobots = new ArrayList<Robot>();
Case [][] plateau;
public int xMax, yMax;
public Monde(int xMax, int yMax){
Case.xMax = this.xMax = xMax;
Case.yMax = this.yMax = yMax;
plateau = new Case[xMax][yMax];
// initialisation du plateau
for(int i=0;i < xMax;i++)
for(int j=0;j < yMax;j++)
plateau[i][j] = new Case(i,j);
// les robots sont une matrice de JLabel
for(int i=0;i < monde.xMax;i++)
for(int j=0;j < monde.yMax;j++){
grille[i][j] = new JLabel();
grille[i][j].setHorizontalAlignment(SwingConstants.CENTER);
grille[i][j].setBorder(LineBorder.createGrayLineBorder());
p2.add(grille[i][j]);
}
// update() permet d’afficher les robots dans les cases adéquates de la g
// creation des robots
lesRobots.add(new RobotFou(2));
lesRobots.add(new RobotFou(2));
lesRobots.add(new RobotFou(2));
lesRobots.add(new RobotTueur());
lesRobots.add(new RobotTueur());
lesRobots.add(new RobotTueur());
lesRobots.add(new RobotTueur());
lesRobots.add(new RobotTueur());
lesRobots.add(new RobotTueur());
rille
update();
// Bouton next Ã
// mise à jour du plateau en fonction des positions des robots
for(Robot r : lesRobots){
int x = r.getX(), y = r.getY();
plateau[x][y].setRobot(r);
}
}
// update() permet de déplacer l’ensemble des robots et de mettre Ã
plateau en conséquent
// elle est appelée à chaque nouvelle itération de la simulation
public void update(){
Robot r;
for(int i = 0; i < lesRobots.size(); i++){
r = lesRobots.get(i);
if(r instanceof RobotMobile){
Lundi mai 12, 2014
jour le
ajouter pour faire évoluer le monde et l’interface
}
// Mise à jour de l’interface en fonction de la position des robots sur le p
lateau
private void update(){
for(int i=0;i < monde.xMax;i++)
for(int j=0;j < monde.yMax;j++)
if(monde.plateau[i][j].hasRobot())
grille[i][j].setText(monde.plateau[i][j].getRobot().getName());
else
grille[i][j].setText("");
}
}
robots.java
1/2
Printed by Roselyne Chotin Avot
mai 14, 13 13:42
robots.java
Page 3/3
// Le main
public class robots{
public static void main(String [] args){
Monde monde = new Monde(10,10);
Interface fen = new Interface(monde);
fen.setVisible(true);
}
}
Lundi mai 12, 2014
robots.java
2/2