Class Pile, exceptions Résolu/Fermé

Question

Bonjour, 

j'ai créé une clase pile avec des exceptions et voici un main de test:

package PileTest;
import java.util.Vector;
import tp2ex1.Pile;
import tp2ex1.PilePleineException;
import tp2ex1.PileVideException;
/**
 *
 * @author FOUFA
 */
public class PileTest {
    
    public static void main(String[] args) {
        
        Pile pile = new Pile();
        
        Object pile1=1;
        Object pile2=2;
        
        try {
            pile.empiler(pile1);
            pile.empiler(pile2);
            pile.depiler();
            }
        
        catch (PileVideException v) {
            System.out.println("La pile est vide"+v);
        }
        
        catch (PilePleineException p) {
            System.out.println("La pile est pleine");
        }

    }
}

-Est-ce correct ?
-Puis je faire un autre try (pour empiler un nombre infni d'object) si non, ou le faire ?
-Comment creer un nombre infini d'objects (tres grand) ?
Merci ! (en attente de tksteph ^^)

KX · Answer

L'exception "pile pleine" ne devrait pas être gérée. Par définition une pile n'a pas de limite, si tu en as une alors ce n'est pas une pile.
Éventuellement, avec une "infinité" d'objets tu auras une OutOfMemoryError qui sera directement générée par la machine virtuelle, mais ce ne sera pas forcément sur l'instruction empiler, donc ce deuxième catch ne sers à rien.

La seule exception à gérer tu l'as déjà faite c'est PileVide.

(tksteph est absent pour le moment mais vous pouvez lui laisser un message ^^)

hedii · Answer

Bonjour, merci pour votre reponse, 

je l'ai rajouté (exception pilepleine) car sinon j'ai une erreur aux lignes ou j'empile

et comment faire pour faire un autre try ?

hedii · Answer

Ce serait un try pour tester l'exception pile pleine en empilant l'infinité d'objets. On a defini un maxPile a 10.
Merci KX

tksteph · Answer

Salut,

syntaxiquement ton code n'as pas de problème ,
Par contre il ya quelques petits éléments à redire conceptuellement (On y reviendra).

Comme précisé précédement (par  KX) Par définition une pile n'a pas de limite, si tu en as une alors ce n'est pas une pile Alors le tout dépend de ce que tu as comme implémentation de Pile dans ta classe Pile (Celle tu package tp2ex1).

Si effectivement ta Classe Pile a une limite, alors oui tu as le droit de traiter l'exception Pile pleine,
Si par contre elle n'a pas de limite alors Non pas la peine de la traiter

Puis je faire un autre try (pour empiler un nombre infni d'object) si non, ou le faire ?  

A priori, dans la définition même du bloc try{}catch(){}
tu peux faire dans un même programme autant que possible,
L'idée c'est de mettre toutes les instructions succeptible de générer des erreurs dans ces blocs (Donc tu peux t'amuser à mettre chaque instruction dans un bloc).

Mais l'idée d'une bonne conception/programmation c'est justement de regrouper ces instructions dans un seul bloc try, avec plusieurs catch permettant alors de distinguer/Personnaliser la gestion des erreurs (Comme ce que t'as fait. C déja bien!)

Mais attention!! (Pour revenir à ton code)
Puisque tu attrapes les Exceptions de type PileVide et PilePleine, Il faut que dans ta classe pile que les méthodes empiler(Object o){} et depiler(){} popagent ces exceptions (Sinon il ne sert à rien de les attraper à l'exterieur)
 
Comment creer un nombre infini d'objects (tres grand) ?
Peux tu reformuler?
Si non tu peux utiliser des Listes/ tableaux avec une taille "tres grande", Tables de hachages,...
J'espère avoir t'avoir apporté quelques éclaircissements,

Bon Courage!

hedii · Answer

Ah bah c'est bon ca marche ! Merci KX ! bonne soiree a bientot

hedii · Answer

Bonjour tksteph,
il y avait bien un maximum d'objets, j'ai resolu le probleme de l'infinité d'objets avec le while de KX. Et pour les try c'est bien compri merci.

Merci pour votre reponse a bientot.

hedii · Answer

Bonjour,

dans les classes pilevideexception et pilepleineexception j'ai redefini les methodes toString:

public String toString() {
    return "La pile est vide";
}

public String toString () {
    return "Pile pleine, taille:"+Pile.getMaxPile()+",objet non ajouté:"+objet.toString();
}


J'essai maintant de les utiliser dans les catch du main de la class piletest:

public class PileTest {
    
    public static void main(String[] args) {
        
        Pile pile = new Pile();
        
        Object pile1=1;
        
        try {
            pile.empiler(pile1);
            pile.depiler();
            pile.depiler();
            }
        
        catch (PileVideException v) {
            System.out.println(pile.toString());
 //utilise la methode toString redefinie dans PileVideException
        }
        
        catch (PilePleineException p) { 
            System.out.println(pile.toString());
//utilise la methode toString redefinie dans PilePleineException
        }
            
        
        try
        {
            while (true)
                pile.empiler(new Object()); 
        }
        catch (PilePleineException p)
        { 
            System.out.println(pile.toString());
        }
    }
}


Ma question est, comme cela, le toString du premier catch utilise la methode redefinie dans pilevideexception et celui du deuxieme celle de pilepleineexception ? Si non comment faire pour que ce soit le cas :).

Merci !

hedii · Answer

C'est corrigé, je vous montre les resultats si vous voulez ^^:

package tp2ex1;
import java.util.Vector;

/**
 *
 * @author FOUFA
 */
public class Pile extends Vector {
    private static final int maxPile=10; 
    /**
     *
     */
    public Pile() {
        
    }
    
    static public int getMaxPile () {
    return maxPile;
}
    private boolean pileVide () {
        if (this.isEmpty()) {
            return true;
        }
        else {
            return false;
        }
        }
    
    private boolean pilePleine () {
        if (this.size()>maxPile) {
            return true;
        }
        else {
            return false;
        }
    }
    
    public void empiler (Object o) throws PilePleineException {
        if (!pilePleine()) {
            this.add(o);
        }
        else {
            throw new PilePleineException (o);
        }
    }
    
    public String depiler () throws PileVideException {
        if (this.size()!=0){
            this.remove(this.size()-1);
            return "Element supprime:"+this.elementAt(this.size()-1);
        } 
            else
        {
            throw new PileVideException ();
        }
    }
    
}


package tp2ex1;

/**
 *
 * @author FOUFA
 */
public class PilePleineException extends Exception {
    
    private Object objet;
    
public PilePleineException (Object o){
    this.objet=o;
}

public PilePleineException (String message){
    super(message);
}

public String toString () {
    return "Pile pleine, taille:"+Pile.getMaxPile()+",objet non ajoute:"+objet.toString();
}
}


package tp2ex1;
/**
 *
 * @author FOUFA
 */
public class PileVideException extends Exception {
    

public PileVideException (){

}

public PileVideException (String message){
    super(message);
}

public String toString() {
    return "La pile est vide";
}
}


package PileTest;
import java.util.Vector;
import tp2ex1.Pile;
import tp2ex1.PilePleineException;
import tp2ex1.PileVideException;
/**
 *
 * @author FOUFA
 */
public class PileTest {
    
    public static void main(String[] args) {
        
        Pile pile = new Pile();
        
        Object pile1=1;
        
        try {
            pile.empiler(pile1);
            pile.depiler();
            pile.depiler();
            }
        
        catch (PileVideException v) {
            System.out.println(v.toString()); //utilise la methode toString redefinie dans PileVideException
        }
        
        catch (PilePleineException p) { 
            System.out.println(p.toString()); //utilise la methode toString redefinie dans PilePleineException
        }
            
        
        try
        {
            while (true)
                pile.empiler(new Object()); 
        }
        catch (PilePleineException p)
        { 
            System.out.println(p.toString());
        }
    }
}

Class Pile, exceptions

8 réponses

Discussions similaires