Pour la r�alisation du programme, nous avons d�compos� le probl�me en deux parties, qui ne sont pas enti�rement ind�pendantes l�une de l�autre. La premi�re partie concerne la cr�ation d�un r�seau routier et la seconde partie concerne le m�canisme de simulation.
Au d�part nous avons �t� lanc� au vif du sujet, � �tablir des sp�cifications, diagrammes de cas d�utilisation, de classes, d�objets.
Nous nous sommes vite rendu compte que le travail effectu� concernait essentiellement un aspect � cr�atif �, � savoir comment g�rer la cr�ation d�un feu ou bien d�une route, quelle objet d�pendait d�un autre, ou bien h�ritait t-il d�un autre, ou encore aurait il un r�le qui se rapproche du comportement d�un � thread � ? Puis petit � petit, on a commenc� � analyser l�aspect simulation du trafic routier, et nous avons d�tach� les contraintes du syst�me et analyser comment nous allions g�rer la simulation.
Nous d�taillons donc dans une premi�re partie la fa�on dont le programme va r�agir face aux actions de l�utilisateur, quelle type d�interface va �tre mis en place et comment se comportera le programme.
2. Cahier de charge :
Pour le programme que nous r�alisons, le langage de programmation retenu est JAVA. La conception est bien entendu orient�e objet, et � pour vocation � nous faire d�velopper un programme en passant par les �tapes n�cessaires de la conception logicielle. Il s�agit d�un simulateur de trafic routier. Une intersection entre deux route est cr�e par le programme. L�utilisateur pourra y placer des v�hicules et ajouter les feux dans les intersections. De plus, des param�tres seront r�glables tels que la dur�e concernant les feux, les comportements des v�hicules sur la route, aux feux, et ainsi de suite.
Pour d�velopper ce programme nous allons utiliser Eclipse.
3. Partie Analyse :
3.1. Diagramme de classe:
Classe Feu :
�La classe Feu h�rite de la classe Thread elle aussi, et contient des attributs caract�risant un Feu (le num�ro, la couleur et les coordonn�es), et le constructeur bien �videmment pour pouvoir cr�er des objets de la classe.
�Les getters pour retourner les attributs.
�Les setters pour modifier les attributs.
�La red�finition de la m�thode run() qui permet d�alterner les couleurs du feu apr�s une certaine dur�e.
Classe Vehicule :
�Cette classe h�rite de la classe Thread, et contient des attributs caract�risant un v�hicule, un constructeur d�initialisation des attributs qui sert � la construction d�objets de classe.
�Les getters dans la classe servent � retourner les valeurs des attributs de la classe.
�Les setters de la classe c�est pour modifier les attributs..
�La m�thode move() qui retourne void sert � faire avancer le v�hicule.
�La m�thode isRoule() retourne un bool�en montrant l��tat du v�hicule(le v�hicule roule ou en �tat d�arr�t).
�La red�finition de la m�thode run() qui permet de faire avancer le v�hicule selon l��tat voulu.
Classe Route :
�La classe Route contient un vecteur de Feu et un autre de v�hicule puisqu�une route poss�de des feux et des v�hicules.
�Cette classe contient des attributs servant � la caract�risation d�une route � savoir des v�hicules repr�sent�s par un vecteur et des feux aussi par des vecteurs, un num�ro et un nom.
�Les getters servent � retourner les diff�rents attributs.
�
�La m�thode addVehicule sert � ajouter un v�hicule qu�elle prend en argument.
Classe Fenetre:
� La classe Fen�tre h�rite de la classe JFrame, et contient un constructeur qui sert � d�terminer les param�tres de la fen�tre � savoir le titre, la taille, et le conteneur qui est bien �videmment un objet de Panneau.
� Cette classe est aussi compos�e de feux, v�hicules, et un panneau.
� La m�thode go ne retourne rien, et sert � cr�er des feux, et des v�hicules, et de les ajouter � une route.
Classe Panneau :
� La classe Panneau h�rite de la classe JPanel, et sert � remplir l�interface graphique puisqu�elle h�rite de JPanel (ses objets servent de conteneurs).
� La m�thode paintComponent ne retourne rien, et sert � dessiner les composants de l�interface � savoir les formes et les couleurs.
� La classe panneau contient des vecteurs de V�hicule et Feu puisqu�elle est associ�e � la classe Thread qui est la classe m�re de V�hicule et Feu.
� La m�thode setFeu ne retourne rien, et sert � modifier le vecteur Feu.
� La m�thode setV�hicule ne retourne rien aussi, et sert � modifier le vecteur V�hicule.
3.2. Diagramme de cas d�utilisation:
3.3. Diagramme de s�quence :
Le diagrammes de s�quence est la repr�sentation graphique des interactions entre les acteurs et le syst�me selon un ordre chronologique.
Pour notre cas l�application suit l�ordre suivant :
� L�instanciation des objets de type route, feu, v�hicule et panneau.
� Dessiner les formes graphiques pr�sentant ces objets.
� D�placer les v�hicules en respectant la couleur du feu.
� Changer les couleurs de feu apr�s une dur�e bien d�termin�e.
3.4. Diagramme d�objet:
Un diagramme d�objets repr�sente des objets (instances de classes) et leurs liens (instances de relations) pour donner une vue fig�e de l��tat d�un syst�me � un instant donn�.
� une route peut contenir plusieurs instances de Feu et V�hicules :
4. Partie pratique :
4.1. Les interfaces graphiques :
Les paquetages javax.swing et java.awt contient les classes utilis�es pour construire une interface graphique.
Nous utilisons ici les composants les plus communs d'une interface :
javax.swing.JFrame : la classe javax.swing.JFramemod�lise une fen�tre qui peut surgir � l'�cran. Elle peut avoir un titre, elle peut poss�der une barre de menu, c'est facultatif, elle poss�de toujours ce qu'on appelle un containeur.
javax.swing.JPanel : la classe javax.swing.JPanelmod�lise un composant destin� � contenir d'autres composants ou bien � faire des trac�s (dessins, images, cha�nes de caract�res...). Il sera mieux, dans une m�me instance de JPaneld'� la fois mettre des sous-composants et � la fois faire des trac�s.
java.awt.Graphics : la classe java.awt.Graphics contient des m�thodes permettant de dessiner du texte ou des formes sur un composant graphique comme une Applet ou, dans notre cas, un javax.swing.JPanel.
java.awt.Color : la classe java.awt.Color nous servira � travailler en Java avec les couleurs ; on y trouve en particulier un ensemble de constantes (Color.BLACK, Color.RED...) qui nous permettront d'attribuer des couleurs soit � une instance de Graphics, soit � l'arri�re-plan ou � l'avant-plan d'un composant graphique.
4.2. Les threads :
Si l��criture de programmes corrects est un exercice difficile, l��criture de programmes concurrents corrects l�est encore plus. En effet, par rapport � un programme s�quentiel, beaucoup plus de choses peuvent mal tourner dans un programme concurrent.
12 |
simple. En outre, les threads sont le moyen le plus direct d�exploiter la puissance des syst�mes multiprocesseurs. � mesure que le nombre de processeurs augmentera, l�exploitation de la concurrence prendra de plus en plus d�importance.
Pour notre application on a utilis� la notion des threads pour g�rer simultan�ment les feux, le d�placement des v�hicules et le tra�age dans la fen�tre graphique. Pour cela les classes Feu et V�hicules ont h�rit� � partir de la classe Thread, et en red�finissant la m�thode run() on a affecter a chaque thread son fonctionnement :
Classe Feu :
public void run()
{
while(true)
{
try {
sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(clr==Color.red)
clr=Color.green;
else
clr=Color.red;
try {
sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(clr==Color.red)
clr=Color.green;
else
clr=Color.red;
}
}
Classe Vehicule :
public void run()
{
while(true)
{
try {
sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(isRoule())
move();
}
}
4.3. Fonctionnement du programme :
R�le du v�hicule:
Son r�le se r�sume � : Avancer sur la route a l�aide de plusieurs m�thodes qui permettent de g�rer son d�placement dans la fen�tre.
Le v�hicule doit savoir sur quelle route, avec quelle vitesse il roule et son rapprochement vis-�-vis d�un feu.
R�le du feu :
Chaque feu est appartiennent obligatoirement � une intersection entre deux routes et apr�s une dur�e bien d�termin�e il change sa couleur.
R�le de la route :
Chaque route contient deux collection une pour les v�hicules et l�autre pour les feux, donc chaque v�hicule ou feu existe dans la fen�tre doit figurer dans la collection.
R�le du panneau :
Le panneau a pour r�le de r�cup�rer les collections de v�hicule et feu pour les tracer selon leurs coordonn�es.
5. Conclusion :
Le programme pr�sent� dans ce rapport est le fruit de deux mois de travail dont le volume horaire d�passe largement celui fix� par les enseignements.
Ceci r�sulte d�une volont� forte de r�aliser un d�veloppement logiciel r�fl�chi et justifiant l�utilisation de techniques de sp�cification afin d�acqu�rir une exp�rience dans ce domaine et de parfaire nos connaissances aussi bien du langage Java que de G�nie Logiciel.
M�me si le produit fini pr�sente quelques situations dans lesquelles sont ex�cution ne r�pondent pas totalement au cahier des charges que nous nous �tions fix�s, nous sommes satisfaits du r�sultat.
En effet, pendant le d�veloppement, nous avons �t� amen�s � d�couvrir des nouveaux aspects de programmation (les threads, g�n�ricit�, composants SWING et AWT) mais aussi des aspects qui rel�vent de techniques de conception (int�r�t d�encapsulation, polymorphisme, g�n�ricit� et h�ritage, visibilit�).
Code source
Classe Fenetre :
import java.awt.Color;
import java.util.Vector;
import javax.swing.JFrame;
public class Fenetre extends JFrame{
private Panneau pan = new Panneau();
privateRoute r1=new Route(1,"national");
publicFenetre(){
this.setTitle("Animation");
this.setSize(720,755);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setLocationRelativeTo(null);
this.setContentPane(pan);
this.setVisible(true);
go();
}
private void go(){
Feu f1=new Feu(20,Color.green,180,450);
Feu f2=new Feu(20,Color.red,220,180);
Feu f3=new Feu(20,Color.green,490,220);
Feu f4=new Feu(20,Color.red,450,490);
Vehicules v1=new Vehicules(50,Color.red,5,10,400);
Vehicules v2=new Vehicules(50,Color.red,-5,720,300);
r1.addFeu(f1);
r1.addFeu(f2);
r1.addFeu(f3);
r1.addFeu(f4);
r1.addVehicule(v1);
r1.addVehicule(v2);
Vector<Feu> f=r1.getF();
Vector<Vehicules> v=r1.getVehicules();
for(int i=0;i<f.size();i++)
{
f.get(i).start();
}
for(int i=0;i<v.size();i++)
{
v.get(i).start();
}
while(true)
{
System.out.println(f1.getClr());
try {
Thread.sleep(60);
} catch (InterruptedException e) {
e.printStackTrace();
}
pan.setFeu(r1.getF());
pan.setVehicule(r1.getVehicules());
v1.setRoule(true);
v2.setRoule(true);
if(v1.getX()==f1.getX()-20 && f1.getClr().equals(Color.red))
v1.setRoule(false);
if(v2.getX()>f3.getX() && v2.getX()<f3.getX()+20 && f3.getClr().equals(Color.red))
v2.setRoule(false);
if(v1.getX()>pan.getWidth())
v1.setX(0);
if(v2.getX()<0)
v2.setX(pan.getWidth());
pan.repaint();
}
}
public static void main(String[] args) {
Fenetre f=new Fenetre();
}
}
Classe Panneau :
importjava.awt.Color;
importjava.awt.Graphics;
importjava.util.Vector;
importjavax.swing.JPanel;
public class Panneau extends JPanel {
Vector<Feu> f;
Vector<Vehicules> v;
public void paintComponent(Graphics g){
g.setColor(Color.white);
g.fillRect(0, 0, this.getWidth(), this.getHeight());
/* route horizontale */
g.setColor(Color.black);
g.fillRect(0, 250, 720, 200);
g.setColor(Color.white);
g.fillRect(10,340,60,20);
g.fillRect(100,340,60,20);
/* passage du pieton*/
g.setColor(Color.white);
g.fillRect(190,420, 60,20);
g.setColor(Color.white);
g.fillRect(190,380,60,20);
g.setColor(Color.white);
g.fillRect(190,340,60,20);
g.setColor(Color.white);
g.fillRect(190,300, 60,20);
g.setColor(Color.white);
g.fillRect(190,260,60,20);
/*FIN PASSAGE*/
/* passage du pieton*/
g.setColor(Color.white);
g.fillRect(450,420, 60,20);
g.setColor(Color.white);
g.fillRect(450,380,60,20);
g.setColor(Color.white);
g.fillRect(450,340,60,20);
g.setColor(Color.white);
g.fillRect(450,300, 60,20);
g.setColor(Color.white);
g.fillRect(450,260,60,20);
/*FIN PASSAGE*/
g.setColor(Color.white);
g.fillRect(540,340,60,20);
g.setColor(Color.white);
g.fillRect(630,340,60,20);
/*fin route*/
/*route verticale*/
g.setColor(Color.black);
g.fillRect(250,0,200 ,720 );
g.setColor(Color.white);
g.fillRect(340,10,20,60);
g.setColor(Color.white);
g.fillRect(340,100,20,60);
g.setColor(Color.white);
g.fillRect(420,190,20,60);
g.setColor(Color.white);
g.fillRect(380,190,20,60);
g.setColor(Color.white);
g.fillRect(340,190,20,60);
g.setColor(Color.white);
g.fillRect(300,190,20,60);
g.setColor(Color.white);
g.fillRect(260,190,20,60);
/*FIN PASSAGE*/
/* passage du pieton*/
g.setColor(Color.white);
g.fillRect(420,450,20 ,60);
g.setColor(Color.white);
g.fillRect(380,450,20,60);
g.setColor(Color.white);
g.fillRect(340,450,20,60);
g.setColor(Color.white);
g.fillRect(300,450,20,60);
g.setColor(Color.white);
g.fillRect(260,450,20,60);
/*FIN PASSAGE*/
g.setColor(Color.white);
g.fillRect(340,540,20,60);
g.setColor(Color.white);
g.fillRect(340,630,20,60);
/*fin route*/
for(int i=0;i<f.size();i++)
{
g.setColor(f.get(i).getClr());
g.fillOval(f.get(i).getX(),f.get(i).getY(),30,30);
}
for(int i=0;i<v.size();i++)
{
g.setColor(v.get(i).getClr());
g.fillRect(v.get(i).getX(),v.get(i).getY(),30,30);
}
}
f=f1;
}
public void setVehicule(Vector<Vehicules> v1) {
v=v1;
}
}
Classe Route :
import java.util.*;
public class Route{
private int num;
private String nom;
private Vector<Feu> f;
private Vector<Vehicules> v;
public Route(int num, String nom) {
this.num = num;
this.nom = nom;
f= new Vector<Feu>();
v= new Vector<Vehicules>();
}
public Vector<Vehicules> getVehicules()
{
return v;
}
public int getNum()
{
return num;
}
public String getString()
{
return nom;
}
public Vector<Feu> getF() {
return f;
}
public void addFeu(Feu f1) {
f.add(f1);
}
public void addVehicule(Vehicules v1) {
v.add(v1);
}
Classe Feu :
importjava.awt.*;
public class Feu extends Thread {
private int num;
private Color clr;
int x,y,duree;
public Feu(int num, Color clr, int duree, int x, int y) {
this.num = num;
this.clr = clr;
this.x = x;
this.y = y;
}
public int getNum() {
return num;
}
public void setId(int num) {
this.num = num;
}
public Color getClr() {
return clr;
}
public void setClr(Color clr) {
this.clr = clr;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public void run()
{
while(true)
{
try {
sleep(duree);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(clr==Color.red)
clr=Color.green;
else
clr=Color.red;
try {
sleep(duree);
} catch (InterruptedException e) {
e.printStackTrace();
}
if(clr==Color.red)
clr=Color.green;
else
clr=Color.red;
}
}
}
Classe Vehicule :
import java.awt.*;
public class Vehicules extends Thread{
private int num;
private boolean roule=true;
private Color clr;
private int vitesse;
private int x,y;
public Vehicules(int num, Color clr, int vitesse, int x, int y) {
this.num = num;
this.clr = clr;
this.vitesse = vitesse;
this.x = x;
this.y=y;
}
public int getNum() {
return num;
}
public void setId(int num) {
this.num = num;
}
public Color getClr() {
return clr;
}
this.clr = clr;
}
public int getVitesse() {
return vitesse;
}
public void setVitesse(int vitesse) {
this.vitesse = vitesse;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public void move()
{
x=x+vitesse;
}
public boolean isRoule() {
return roule;
}
public void setRoule(boolean roule) {
this.roule = roule;
}
public void run()
{
while(true)
{
try {
sleep(100);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if(isRoule())
move();
}
}
}
No comments:
Post a Comment