Discussion :

[nouga2009]

Bonjour à tout le monde,
J'ai un tp à faire en pile(par tableau de taille fixe),interface et généricité.
J'ai réussi(je crois) à écrire ma classe pile en suivant l'interface suivante:

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
18
19
20
public interface Pile {
	public boolean estVide();
 
	  public boolean estPleine();
 
	  public int nbElement();
 
	  public void empiler (int x);
 
	  public int depiler(); 
 
	  public int sommetPile();
 
	  public boolean appartient(int e);
 
	  public void inverse ();
 
	  public String toString();
 
}

mais je ne sais pas comment faire pour implémenter une classe Pile générique, s'il vous plait aidez moi pour réussir mon tp que je dois rendre demain avant 14h , bon je vous donne ce que j'ai fait pour voir si j'ai pas fais d'erreur en ce qui concerne la classe Pile:

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
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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 public class PileArray implements Pile{
    private int [] P;
    private int sommet;
public PileArray () {
	P= new int [1000];
	sommet=0;
}
public PileArray (int taille){
	P= new int [taille];
	sommet=0;
}
public PileArray ( PileArray p){
	P= new int [p.P.length];
	sommet = p.sommet;
	for (int i=0; i<sommet; i++){
		P[i]=p.P[i];
	}
}
public boolean estVide(){
	return sommet<=0;
}
public boolean estPleine(){
 
	return sommet>P.length;
}
public int nbElement(){
	return sommet;
}
public void empiler (int x){
	if (estPleine()){
		System.out.println("PileArray :: empiler: Erreur la pile est pleine");
		System.exit(-1);
	}
	else
	{
		P[sommet]=x;
		sommet= sommet+1;
	}
}
public int depiler() {
	if (estVide()){
		System.out.println("on peut pas dépiler quand il n'ya pas d'éléments");
		System.exit(-1);
	}
		sommet= sommet-1;
		return (P[sommet]);
	}
 
 
public String toString(){
	String result="[";
	for (int i=0; i<nbElement()-1; i++){
		result+=" "+P[i]+",";
	}
	if((! estVide())){
		result+=" "+ P[nbElement()-1]+" ";
	}	
	result +="]\n";
	return result;
 
}
public int sommetPile(){
	return (P[sommet-1]);
}
public boolean appartient(int e){
for (int i=0; i<sommet; i++){
	if(P[i]==e){
		return (true);
	}//if
}//for
 
     return (false);
	}
 
public void inverse (){
int tmp;	
PileArray P2 = new PileArray(this);
for (int i=0; i<sommet; i++){
	P[i]=P2.depiler();
}
}
public static void main (String args[]){
	PileArray P1 = new PileArray();
	P1.empiler(1);
	P1.empiler(2);
	P1.empiler(3);
	System.out.println("P1="+P1);
    P1.inverse();
    System.out.println("L'inverse de P1="+P1);
    System.out.println("est ce que 5 appartient à P1?");
    System.out.println(P1.appartient(5));
    System.out.println("est ce que 2 appartient à P1?");
    System.out.println(P1.appartient(2));
}
}

Il me reste à faire la généricité que je comprends pas et que je souhaite comprendre alors s'il vous plaît guidez moi car j'ai beau lire sur la généricité mais j'arrive pas à faire mon tp et voilà le plan:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class PileGene<T> {
	// à compléter
 
 
	private Object[] P;// il n'est pas possible de déclarer un tableau générique càd écrire privateT[]P
	// à compléter
 
	public static void main (String args[]){
		// création d'une pile d'entier(attention utilisayion du type Integer et non int
		PileGene<Integer> p= new PileGene<Integer>();}
	// à compléter
	}

et merci à tout le monde.

[X-plode]

Bonsoir,

Et avec ceci, ca ne t'aide pas plus ?

[hibour]

Bonjour
Contrairement au C++ on ne peut pas appeler le constructeur d'un type générique T càd : T obj = new T() est impossible car au runtime la JVM ne sait pas quelle constructeur appelé. On peut néanmoins instancier un tableau de type T par
T[] array = (T[]) new Object[nbElement];

Exemple d'implémantation de ta pile

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
 
class PileTableau<T> implements Pile {
  private T arr[];
  private int index = 0;
 
  public PileTableau() {
    T arr[] = (T[]) new Object[100];
  }
 
 public void add(T elem) {
    arr[index++] = elem;
  }
  //....
 
}

J'espere que c'est un peu + claire.
Salut

[nouga2009]

Salut
Merci X-plode pour ton site mais j'ai pas pu comprendre car on n'a pas encore fait la notion d'exception et le site que tu m'as donné ils ont travaillé avec cette notion alors rien pigé mais merci quand même pour ton aide.
Merci hibour mais je ne sais pas qu'est ce que j'ai ça me parait flou et en fait le prof nous a dit de ne pas mettre le mot implements car cette classe ne sera pas une implémentation Java de l'interface Pile; par contre il nous a dit d'utiliser les mêmes signatures pour les méthodes. et que c'est impossible de créer en Java un tableau générique (pas possible d'écrire private T[] P)alors il nous a dit de prendre la notion (dépassée) de "tableau d'Object" et d'utiliser le cast.
merci à tout le monde

[hibour]

Tu peux déclarer dans une classe générique X<T>

Code :

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

private T[] array;

Ce que je t'ai cité est correct, tu peux vérifier sur ton EDI (éclipse).
Cdlt

[JohnNC]

Ce n'est pas clair pour moi non plus : Il est souvent dis qu'on ne peut pas avoir de tableau générique, à cause d'un contrôle à la compilation et d'un autre à l'exécution (créant un ArrayStoreException). De quoi s'agit-il ?

[tchize_]

Tu peux déclarer dans une classe générique X<T>

Code :

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

private T[] array;

Cdlt

Oui tu peux déclarer un tableau générique, mais tu ne pourra pas l'instancier, ce qui limite fortement son usage en tant que champ privé. D'ailleurs, List<T>.toArray() retourne à ce titre un type Object[] et pas T[].

[tchize_]

Ce n'est pas clair pour moi non plus : Il est souvent dis qu'on ne peut pas avoir de tableau générique, à cause d'un contrôle à la compilation et d'un autre à l'exécution (créant un ArrayStoreException). De quoi s'agit-il ?

L'arrayStoreException se produit dans le cas suivant:

Code :

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

1
2
     Object x[] = new String[3];
     x[0] = new Integer(0);

Rien à voir avec les génériques. LE gros problème avec les génériques et les tableaux, c'est que ceci est impossible:

Code :

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

1
2
private T[] tableau;
tableau = new T[32];

On pourrais bien sur faire çà:

Code :

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

1
2
3
private T[] tableau;
tableau = (T[])new Object[32];
public T[] getTableau(){return tableau;}

Mais au moment de retourner ce tableau à un appelant, on risquerait çà:

Code :

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

1
2
3
4
5
 
MaPile<Integer> pile = new MaPile<Integer>();
//.....
Integer[] leTableau = pile.getTableau(); 
// compilera mais à l'exécution lancera java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

Donc, quand on travaille avec tableau + générique, on marche sur des oeufs

[hibour]

Code :

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

1
2
3
4
5
 
MaPile<Integer> pile = new MaPile<Integer>();
//.....
Integer[] leTableau = pile.getTableau(); 
// compilera mais à l'exécution lancera java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;

Comme si bien cité par tchize_ ,le code généré par le compilateur perdra toutes les informations sur le type générique (à cause de compatibilité avec les ancienne JVM). DOnc chaque référence a un type générique et remplacer par Object...

a++

[tchize_]

précision, de toutes manières, écrire çà:

Code :

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

T[] tableau = (T[])new Object[500];

est relativement faux. Même si ca passe à la compilation, et peut etre a l'exécution, c'est logiquement incohérent. Object[] n'est et ne pourra jamais être correctement type casté en T[] lorsque T sera connu (sauf si T est explicitement Object). Il vaut encore mieux préférer ça:

Code :

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

1
2
3
4
5
Object[] tableau = new Object[500];
....;
public T getElement(i){
  return (T)tableau[i];
}

Au moins, on est sur que personne essaierai jamais de renvoyer à l'appelant "tableau" sous forme de T[].