nouvel exercice personne suivante

Version imprimable

Bonjour,

je suis sur un exercice :

Le but de cet exercice est de vous faire manipuler les listes chaînées par un exemple concret : une file d'attente.
Supposons une file d'attente de cinéma. Sa capacité de stockage est illimitée (c'est un cinéma géant). Une personne est définie par son nom et son prénom.

1. Créer une classe Personne contenant un champ pour le nom et un champ pour le prénom, un constructeur prenant en paramètre deux String pour le nom et le prénom, et une fonction toString retournant le nom et le prénom sous forme de String.

2. Compléter cette classe pour ajouter une référence sur la personne suivante dans la file (celle qui attend derrière). Ajouter une fonction setSuivant(Personne p) qui définit le suivant de la personne et une fonction getSuivant() qui retourne la Personne suivante dans la file.

Créer une classe FilleAttente. Cette classe possède deux champs de type Personne : un champ tete (début de la file d'attente) et un champ queue (fin de la file d'attente). Le constructeur prend en paramètre 1 objet de type Personne et remplit tete et queue (la premiere personne est la tête et la queue en même temps).Créer une fonction ajouter(Personne p) qui ajoute une personne en bout de file.

3. Créer la fonction afficherFile() qui affiche les personnes qui attendent dans la file d'attente. Un exemple d'affichage de cette fonction pourrait être :
Jojo Lafrousse - Pierre Delacroix - Jean Lartige - Fin de la file !
Créer une classe AppliFile. Cette classe crée une file d'attente contenant une personne, y ajoute 5 personnes (faut bien faire bosser le caissier) avec les noms de votre choix, et l' affiche.

+------------------------------------------------------------------------------------------------------------------------------------------------------+

Pour la question 2 j'ai cree le get et le set ,j'ai aussi cree une methode personne suivante mais je n'arrive pas a la definir

pour le raisonnement je me suis dis que "en gros" personne suivante =Objet Personne+1
Deja est ce la bonne facon de proceder???
apres pour le detail je ne sais pas si en faisant comme ca je dois passer pas un compteur d'instance ou si je peux faire qqc du "genre" :
Code:

1 2 3 4 5 6 7 public boolean equals(Object Personne){ if (this == new Personne()){ return true; } else { return false; } }
en ensuite l'inclure dans ma methode personne suivante.
ou s'il y a une autre solution en faisant autre chose???

je cherche plus une technique ou un mode de reflexion que du code si possible car j'ai vraiment besoin de comprendre...

le reste est basique et ressemble a ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public void psuivante() { //la grande inconnue???? } //get personne suivante public String getPsuivante() { return psuivante; } //set personne suivante public void setPsuivante(String ppsuivante) { this.psuivante = ppsuivante; }
merci a vous

23/10/2016, 06h21
joel.drigo
Salut,

La première partie de la question 2 est pourtant claire et explicite : tu dois faire 2 méthodes, une méthode setSuivant(Personne) et une méthode getSuivant(), qui doit renvoyer une instance de Personne. La première affecte un attribut de type Personne (la personne suivante de this en gros), et la seconde retourne cette même personne. Toi, tu as fait 1 méthode dont l'argument est un String, et une qui retourne du String : déjà problème de type. Ensuite, je ne vois nulle part où il est question d'une troisième méthode (ce que tu appelles "personne suivante").

Ensuite, je ne sais pas pourquoi tu parles de "personne suivante =Objet Personne+1". Comment pourrais-tu ajouter 1 à une instance de type Personne ? Et à quoi ça pourrait bien servir ?

Quant à ça :
Code:

1 2 3 4 5 6 7 public boolean equals(Object Personne){ if (this == new Personne()){ return true; } else { return false; } }
c'est absurde : si tu compares this à une nouvelle instance de Personne, elles ne risquent pas d'être égales, puis que this c'est this, et new Personne, forcément une autre instance. Le contrat de equals est de tester si l'argument est égal à this, pas autre chose.

Quant à la seconde partie de la question, on parle de faire une autre classe, dont le but de de mettre en file les personnes entre elles, et, ce, par appel de setPersonne(Personne) et Personne getPersonne(). Il s'agit de gérer une liste chaînée. Chaque personne (instance de Personne) dans la file a une personne (autre instance de Personne) qui la suit (le suivant). On stocke dans cette autre classe, le premier de la file, et le dernier (celui-ci étant le premier lorsqu'il y a une seule personne dans la file. Tu dois écrire donc un constructeur qui initialise cette classe avec une instance de personne, et écrite une méthode qui ajoute une personne à la fin de la file. Cette méthode va donc faire :
Code:

1 2 3 on appelle nouveau la personne qu'on passe en argument de cette méthode : je dis que le suivant du dernier est le nouveau je dis que désormais le dernier est le nouveau

Salut,

Pour tout dire ,je debute en programmation donc j'ai du mal a appréhender certains concepts ...

En fait ,j'ai fais ca:
Code:

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 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 public class Personne { //stock le nom private String nom; //stock le prenom private String prenom; //constructeur par defaut public Personne() { System.out.println("creation nouvelle personne"); nom = "inconnu"; prenom = "inconnu"; } //constructeur par defaut avec parametres public Personne(String pnom,String pprenom) { nom=pnom; prenom=pprenom; } public String getNom() { return nom; } public String getPrenom() { return prenom; } public void setNom(String pnom) { this.nom = pnom; } public void setPrenom(String pprenom) { this.prenom = pprenom; } public String toString(){ return "\t"+"Nom : "+this.nom+" , Prenom : "+this.prenom; }
et donc ca ca marche mais est ce que jusque la c'est correct?

ensuite tu ecris :

tu dois faire 2 méthodes, une méthode setSuivant(Personne) <-------c'est ici l'objet personne que tu mets en argument???

dans ce cas est que je peux /dois faire ceci:
Code:

1 2 3 4 5 public void setPsuivante( Personne psuivante) { psuivante=new Personne() ; }
et une méthode getSuivant(), qui doit renvoyer une instance de Personne<-----Est ce que la methode get ne renvoi pas le "parametrage" du set??

merci a toi pour ta reponse et pour ta patience.

Citation:

Envoyé par flyman29600

Salut,

Salut,

Citation:

Envoyé par flyman29600

Pour tout dire ,je debute en programmation donc j'ai du mal a appréhender certains concepts ...
[...]
et donc ca ca marche mais est ce que jusque la c'est correct?

Jusque là, oui, ta classe personne est correcte.
Citation:
Envoyé par flyman29600
ensuite tu ecris :

tu dois faire 2 méthodes, une méthode setSuivant(Personne) <-------c'est ici l'objet personne que tu mets en argument???

dans ce cas est que je peux /dois faire ceci:
Code:

1 2 3 4 5 public void setPsuivante( Personne psuivante) { psuivante=new Personne() ; }
Non : là, ta ligne psuivante=new Personne() ; modifie l'arguement en attribuant une nouvelle instance de Personne qui ensuite n'est utilisée nulle part, et ne sert strictement à rien.

Il te faut d'abord avoir un attribut pour stocker l'instance, exactement comme tu as fait pour le nom et le prénom :
Code:

1 2 3 4 5 6 7 8 9 10 11 public class Personne { //stock le nom private String nom; //stock le prenom private String prenom; //stock la personne suivante private Personne personneSuivante; /**... je n'ai pas reproduit le reste du code ...**/
La méthode setSuivant(Personne) sert à donner une valeur à cet attribut, exactemetn comme ta méthode setNom(String) ou ta méthode setPrenom(String) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Personne { //stock le nom private String nom; //stock le prenom private String prenom; //stock la personne suivante private Personne personneSuivante; /**... je n'ai pas reproduit le reste du code ...**/ public void setSuivant(Personne suivant) { personneSuivante=suivant; }
Citation:

Envoyé par flyman29600

et une méthode getSuivant(), qui doit renvoyer une instance de Personne<-----
.

Oui, l'instance qui se trouve dans l'attribut qu'on affecte avec la méthode setSuivant().

Ainsi, à ce stade, sans parler de file d'attente, ou autres trucs plus compliqués qu'une simple classe qui a trois attributs, on peut déjà faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public class Test { public static void main(String[] args) { // on créé 4 personnes : Personne personne1 = new Personne("Stark", "Brandon"); Personne personne2 = new Personne("Reed", "Meera"); Personne personne3 = new Personne("Reed", "Jojen"); Personne personne4 = new Personne("", "Hodor"); personne4.setSuivant( personne2 ); // Meera suit Hodor personne2.setSuivant( personne3 ); // Jojen suit Meera // et Brandon n'a pas de suivant // si on fait : System.out.println(personne2 + " est suivi par " + personne2.getSuivant()); // on obtiendra : Nom : Reed, Prenom : Meera est suivi par Nom : Reed, Prenom : Jojen } }
Citation:

Envoyé par flyman29600

Est ce que la methode get ne renvoi pas le "parametrage" du set??

Je ne comprends pas ce que tu veux dire... par ""paramétrage" du set", tu veux dire "les paramètres du set" ? Un getter retourne ce qu'on veut. Un setter affecte ce qu'on veut. Mais pas logique, et pour éviter d'embrouiller tout le monde, on s'assure de préférence que getTruc() retourne ce qui est affecté par setTruc(Truc). Mais justement, c'est bien ce qu'on essaye de faire pour "personne suivant", et, ce, exactement comme tu as fait pour nom & prénom. A ce niveau de l'exercice, il n'y a aucune différence (plus tard, c'est différent, personneSuivante/setSuivant(Personne)/Personne getSuivant() vont servir à quelque chose de particulier (lorsque tu vas coder ta classe FilleAttente)

la suite ...

Me revoila tout en code et en BUG!!!

La classe Personne :

Code:

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
 
 
public class Personne {
 
 
 
 
	//stock le nom
	private String nom;
	//stock le prenom
	private String prenom;
	//stock la personne suivante
	public Personne pSuivant;
 
 
	//constructeur par defaut
	public Personne()
	{
		System.out.println("creation nouvelle personne");
		nom = "inconnu";
		prenom = "inconnu";
 
	}
 
	//constructeur par defaut avec parametres
	public Personne(String pnom,String pprenom)
	{
		nom=pnom;
		prenom=pprenom;
	}
	public String getNom() {
		return nom;
	}
 
	public String getPrenom() {
		return prenom;
	}
 
	public void setNom(String pnom) {
 
 
		this.nom = pnom;
	}
 
	public void setPrenom(String pprenom) {
		this.prenom = pprenom;
	}
	public String toString(){
 
		return "\t"+"Nom : "+this.nom+" , Prenom : "+this.prenom;
	}	
 
	//get  personne suivante
 
	public Personne getPsuivant() {
		return pSuivant;
 
	}
	//set
	public void setPsuivant( Personne suivante) {
 
	      pSuivant=suivante ;
 
	}
 
}

La classe file d'attente :

Code:

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
27
28
29
30
31
32
33
34
35
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
 
public class FileAttente {
 
 
	//init tableau
	public  List file;
	public Personne nouveau;
	public Personne suivante;
 
	public FileAttente(){
		List file = new LinkedList();
	}
 
	public FileAttente(Personne nouveau,Personne suivante){
 
		List file = new LinkedList<Personne>();
		Personne listend=nouveau;
		Personne listHead =suivante;
		for (Personne p = listHead; p != null; p = p.pSuivant);
 
 
			((LinkedList<Personne>) file).add(suivante);
 
			for(Personne s=listend;s !=null;s=s.getPsuivant());	
 
			((LinkedList<Personne>)file).add(nouveau);
		}
 
 
 
 
}

Le main :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class Monmain {
 
	public static void main(String[] args) {
                 Personne p1=new Personne("Dupont","Martin");
                 Personne p2=new Personne("dubois","martin");
                 Personne p3=new Personne("Dupond","Martine");
                 Personne p4=new Personne("hector","ator");
                 Personne p5=new Personne ("jean " ,"bondebayonne");
 
                 p2.setPsuivant(p1);
               	 p4.setPsuivant(p3);
                 p4.setPsuivant(p5);
	}
	}

et enfin j'ai essayer de faire une sortie mais comme tu vas certainement le dire et voir ca ne marche pas et evidement apres 3jours et nuits de recherche je ne trouve pas....

cela dit j'en profite pour que tu me dises j'ai fais une avec iterateur(java) et une sans :

Code:

1
2
3
4
5
6
7
8
 
 
      for(int i=0; i < file.size(); i++)
              			System.out.println("Élément à l'index " + i + " = " +file.get(i));
 
 ListIterator li= file.listIterator();
              		while(li.hasNext())
              			System.out.println(li.next());

Du coup ,merci pour la reponse....

27/10/2016, 09h49
joel.drigo
C'est quoi cette LinkedList ? Le but de la classe FileAttente est d'implémenter une liste chaînée, pas d'en utiliser une.

Ensuite,

Citation:

Envoyé par flyman29600

Créer une classe FilleAttente. [...] Le constructeur prend en paramètre 1 objet de type Personne[...]

1 c'est un. Un seul !

Il suffit de lire ce qui est écrit dans l'énoncé :

Citation:

Envoyé par flyman29600

Cette classe possède deux champs de type Personne : un champ tete (début de la file d'attente) et un champ queue (fin de la file d'attente).

Deux champs, tete et queue. Pas trois, nouveau, suivant et list !

Le reste est explicitement et clairement décrit :

Citation:

Envoyé par flyman29600

Le constructeur prend en paramètre 1 objet de type Personne et remplit tete et queue (la premiere personne est la tête et la queue en même temps).

"la premiere personne est la tête et la queue en même temps", sous entendu, dans le constructeur on met la valeur de l'unique paramètre du constructeur dans les deux attributs tete et queue.
Code:

1 2 3 constructeur : on passe p en paramètre tete <- p queue <- p
Ce n'est pas plus compliqué que ça.

Citation:

Envoyé par flyman29600

Créer une fonction ajouter(Personne p) qui ajoute une personne en bout de file.

Et ensuite, tu ajoutes une méthode ajouter(Personne p) dans FileAttente, qui va ajouter p à la suite du dernier actuel, donc dire que le suivant de dernier actuel est cette personne ajoutée (donc comme suivant de queue, queue devenant cette nouvelle personne ajoutée).
Code:

1 2 3 ajouter : on passe p en paramètre mettre p comme suivant de queue (appeler la méthode setSuivant() de queue) queue <- p
Et ensuite, tu fais la méthode demandée afficherFile, qui va commencer par afficher tete, puis prendre son suivant, l'afficher, prendre le suivant l'afficher, etc...
Code:

1 2 3 4 5 6 7 courant = tete faire afficher courant courant = suivant de courant tant que courant n'est pas null afficher fin de file