Envoyé par
Khalfe
Une autre question pour le cas d'une pile dynamique pour empiler
1 2 3 4 5 6 7 8 9 10 11 12 13 14
|
public void empiler(int valeur){
Noeud nouveau = Noeud(valeur);
nouveau.setSuivant(tete);
tete = nouveau;
}
//Pour depiler
public int depiler(){
Noeud nouveau = this.tete;
this.tete = this.tete.getSuivant();
return nouveau;
} |
Elle est où la question ? Parce que je ne vois qu'un code, là... Si la question est "Est-ce correct ?", alors la réponse est oui pour la méthode empiler. La méthode depiler est presque juste :
- le premier problème est que son retour est un int, pas un Noeud : tu dois donc faire return nouveau.getValeur();
- le second problème est moins important : il faut que tu penses que ta pile peut-être vide, et que dans ce cas, ça fera une NullPointerException, alors qu'il vaudrait mieux que ça fasse une java.util.NoSuchElementException
Envoyé par
Khalfe
Une troisième question:
C'est ma question principale, comment je dois faire pour tester c'ette file ou pile?
Comme c'est pas un tableau, ou bien je dois le mettre dans un tableau dynamique de type vector ou ArrayListe?
Et bien ça dépend, si tu veux faire du vrai test (avec JUnit), ou si c'est juste pour montrer rapidement que ça fait le job (donc à la main on va dire).
Envoyé par
Khalfe
Exemple:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|
//Supposons que j'initialise un objet de ma classe file comme suit:
File f = new File();
ArrayList<Object>Liste = new Liste<Object>();
Liste.add(f.enfiler(15));
Liste.add(f.enfiler(12));
Liste.add(f.enfiler(20));
Liste.add(f.enfiler(30));
for(int i=0; Liste.size(); i++){
Syste.out.println(Liste(i));
} |
C'est code est il correcte?
Bon là, non, et ce n'est pas un problème de test ou pas :
- la méthode enfiler ne retourne pas de résultat, donc impossible de l'ajouter dans une liste ou autre chose ;
- on accède pas à un élément de liste, par des parenthèses, mais pas un appel de méthode (en l'occurence la méthode get()).
Maintenant, pour répondre à ta question :
- pour faire des tests JUnit il faut faire en général des classes plus complètes, car il faut au moins asserter une égalité avec quelque chose d'attendu : on ajoute des éléments dans la liste chainée et on teste si elle est égale à quelque chose qui est ce qu'on sait ce que ça devrait être. Et là, ce n'est jamais évident, et il te faudra ajouter des méthodes un minima.
- pour faire des pseudos tests pour voir si ça marche ce qu'on a écrit, souvent, le plus simple, c'est d'intégrer juste une méthode toString() qui affiche ce qu'on veut sous une forme qui nous permet de vérifier rapidement de visu que ça ne fait pas n'importe quoi.
Par exemple :
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
| public class File {
private Noeud tete;
public void enfiler(int valeur){
/*...*/
}
public int defiler() {
/*...*/
}
public String toString() {
if ( tete==null ) {
return "Vide";
}
StringBuilder sb = new StrinbBuilder();
Noeud premier = tete;
do {
sb.append("->");
sb.append("(");
sb.apppend(premier.getValeur());
sb.append(")");
premier = premier.getSuivant();
} while( premier!=null );
return sb.toString();
} |
Bien sûr, si on se plante dans l'écriture de la méthode toString(), on peut afficher aussi n'importe quoi et penser qu'on a fait une erreur dans enfiler ou defiler, mais c'est facile à déboguer toString(), plus que les deux autres, et, en tout cas, on a une probabilité très très faible qu'on se trompe au point que toString() nous fasse croire que enfiler et defiler fonctionne, alors que ce n'est pas le cas (sauf si on le fait exprès).
Et donc, si tu écris ton main :
1 2 3 4 5 6 7 8 9 10 11 12
| File f = new File();
int[] valeurs = {15,12,20,30};
for(int valeur : valeurs) {
System.out.println("Avant ajout " + valeur + " : " + f);
f.enfiler(valeur);
System.out.println("Après ajout " + valeur + " : " + f);
} |
Tu devras voir s'afficher :
Avant ajout 15 : vide
Après ajout 15 : ->(15)
Avant ajout 12 : ->(15)
Après ajout 12 : ->(15)->(12)
Avant ajout 20 : ->(15)->(12)
Après ajout 20 : ->(15)->(12)->(20)
Avant ajout 30 : ->(15)->(12)->(20)
Après ajout 30 : ->(15)->(12)->(20)->(30)
Ce qui est déjà pas mal comme test. Ensuite, pour tester plus en détail, on pourra utiliser le débogueur en pas à pas.
Partager