Discussion :

[kohan95]

salut
pour ne pas mentir j'ai pas cherché sur le forum pour voir si il des sujets comme le miens,parce que moi Les collections d'objets je n'arrive pas à les maitriser donc je veux les comprendre mai avec mon problème
voila

je vous donne un simple code
soit les class suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
public class Etudiant  {
 
int num;
double moyenne ;
//.............
}
public class ListEudiant extends LinkedList {/........}

1-ce que je veux savoir c'est comment ajouter des etudiants

2 les autres questions à venir car je veux comprendre (un à un )

remarque je peus bien crier une list
avec ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Liste lis =new  LinkedList ();
puis 
Etudaint e =new Etudaint(); 
lis.add(e);

mais ca c'est un peux facile ce que moi je cherche c'est comprendre ce problème la

merci d'avance et je vous serai très reconnaissant;

[TheVirus2013]

Je suis débutant, mais je pense qu'étant donné que ta classe "ListEtudiant" hérite de LinkedList, tu peux directement instancier des objets de type "ListEtudiant", qui seront des LinkedList "améliorées" par ta sous-classe...
Donc :

Etudiant x = new Etudiant() //crée ton étudiant
ListEtudiant e = new ListEtudiant() //crée ta liste
e.add(x) // ajoute à la liste

Je vois pas de moyen plus court...

[Grimly_old]

TheVirus2013 as tout a fait raison ! De la part d'un dit "débutant", c'est même très bien

Juste une petite aide pour que le compilateur te dise un peu mieux si tu fait des bêtises ou pas :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public class ListEudiant extends LinkedList {/*........*/}

A remplacer par :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

public class ListEudiant extends LinkedList<Etudiant> {/*........*/}

[kohan95]

merci

mais une chose
pour moi ce code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Etudiant x = new Etudiant() //crée ton étudiant
ListEtudiant e = new ListEtudiant() //crée ta liste
e.add(x) // ajoute à la liste

c'est comment ce lui la

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Liste lis =new LinkedList ();   (List est rempaé par ListEtudiant);
Etudaint e =new Etudaint();
lis.add(e);

une autre chose avec c'est comme si je viens de crée une liste dans une liste
e dans la liste qui ListEtudiant non?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

ListEtudiant e = new ListEtudiant()

mais ce que j'ai voulus faire c'est ça

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
public class ListEudiant extends LinkedList<Etudiant> {
 
public ListeEtudiant(){  
Etudiant x = new Etudiant() ;
this.add(x);
 
}
               }

voila s'il vous plait n'hésitez pas à dire tout ce que vous voulez j'ai besoin de vous remarque pour comprendre

[nouknouk]

Pour détailler la notation avec les crochets, genre <Classe>

Depuis Java 1.5 sont apparus les 'generics', c'est à dire la possibilité de créer une instance de classe spécialisée pour un type particulier.

L'intérêt ? Regardons d'abord l'écriture sans 'generics':

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
Etudiant e = new Etudiant();
LinkedList list = new LinkedList();
 
// pour ajouter l'élément dans la liste
list.add(e);
 
// pour récupérer un élément de la liste:
Etudiant premierEtudiantDeLaListe = (Etudiant)list.get(0);

On voit dans la dernière ligne "list.get(...)" que comme la liste est prévue pour contenir des objets génériques, elle retourne un objet de type 'Object'. On est donc obligé de convertir (caster) l'objet en étudiant, d'où la notation '(Etudiant)list.get(0)'

avec les 'generics', lorsqu'on va instancier la liste, on va lui donner le type d'objets qu'elle va contenir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
Etudiant e = new Etudiant();
LinkedList<Etudiant> list = new LinkedList<Etudiant>();
 
// pour ajouter l'élément dans la liste
list.add(e);
 
// pour récupérer un élément de la liste:
Etudiant premierEtudiantDeLaListe = list.get(0);

On voit ici que la liste est paramétrée pour ne contenir que des étudiants. La fonction 'get' est alors capable de retourner directement un objet de type 'Etudiant', et on peut se passer de la conversion.
De même, la fonction 'add' est alors faite pour ne prendre en paramètre que des objets du bon type (Etudiant). Tu es donc certain que ta liste ne pourra contenir que des objets du bon type.

A lire: la section 'generics' dans la FAQ et le lien qui y est mentionné.

[TheVirus2013]

Si ce que tu veux faire c'est ajouter automatiquement les étudiants à une liste de manière simple, le mieux est de ne pas créer de classe dérivée de LinkedList, mais plutôt de mettre un attribut static dans ta classe Etudiant, qui ne serait rien d'autre que ta liste. Ensuite, dans le constructeur de Etudiant, tu rajoute la méthode add automatiquement à chaque création d'une instance.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
public class Etudiant{
     .....
     static LinkedList<Etudiant> e= new LindekList<Etudiant>
     .....
 
     public Etudiant(){
     e.add(this)
     }
}

[adiGuba]

Salut,

TheVirus2013 > Si tu utilises une collection en static, il faut la synchronisé car alors rien ne garantit qu'elle ne sera pas utilisé depuis plusieurs threads :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

static List<Etudiant> e = Collections.synchronizedList(new LindekList<Etudiant>());

kohan95 > Je n'arrive pas à comprendre ce qui te pose problème !

a++

[Bapt.ice]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
public class Generics extends LinkedList<DoPersonne> 
{
	/**
         * @see java.util.LinkedList#add(java.lang.Object)
         */
	@Override
	public boolean add(DoPersonne o)
	{
		// Traitement avant l'ajout à la liste
		boolean res = super.add(o);
		// Traitement après l'ajout à la liste
 
		return res;
	}
}

Dans ton éditeur java (eclipse pour ma part), tu peux demander l'auto-complétion (Ctrl+espace) et il te donnera les méthodes de LinkedList que tu peux surcharger.
Ici j'ai surchargé la méthode "add" et tu peux voir qu'on peux modifier le comportement de cette méthode en faisant des traitement avant et après l'ajout. Je sais pas si c'est ce que tu cherchais à faire, mais la meilleure façon de coder reste celle que t'ont indiqué TheVirus2013 et adiGuba.

++

[kohan95]

merci à vous tous

TheVirus2013 et adiGuba j'ai bien compris votre façon de faire
Bapt.ice je ne vois pas pourquoi il faut surcharger la méthode méthode add?
mais moi je tiens vraiment à utiliser une classe dérivée de LinkedList

c-à-d

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
public class ListEudiant extends LinkedList<Etudiant> {
 
public ListeEtudiant(Etudiant x){  // un constructeur pour ajouter 
                                                  //les étudiants à la liste 
 
ListTerateur it =x.listIterator();
while(it.hasNexte())
add (new Etudiant(it.next());
 
}

???(je ne sais pas c'est ce code est correcte ??)


n'hésitez pas avec vous remarques

[kohan95]

bon j'ai voulu juste vous dire que c'est bon merci