TP3 - La Pile d'objets
Auteur: LEVEQUE Franck
Email : franck.leveque2@free.fr
Pour m'écrire, cliquez ici
Revenir à l'index
Ensemble des fichiers de la réponse(*.class,*.java, et docs) : TP3Q1_1.jar
Revenir à l'index
Résultat de l'éxécution de la classe TestPile :
la p1 = [<4,100>;<5,100>;polygone;100]
la p1 = [<4,100>;<5,100>;polygone;100;[1000]]
la p1 = [<4,100>;<5,100>;polygone;100;[1000]]
On voit ici que la pile d'objet accepte n'importe quel type d'objet au sein d'une même pile. De plus,
si l'instruction //p1.empiler(p1); // Attention au résultat ! n'avait pas été mise en commentaire, une boucle infinie aurait été éxécuter lors de l'éxécution de la méthode toString de l'objet p1(3ème ligne de résultat).
Reveinir à l'index
Documentation de la classe pile
Revenir à l'index
Une solution au problème est de lever une nouvelle erreur (CycleException) dans la méthode empiler si l'on essaye de passer l'objet lui-même en paramètre de cette méthode. Ce qui nous donne comme code pour la méthode empiler :
public void empiler(Object i) throws PilePleineException,CycleException
{
if(this!=i) // on vérifie que l'adresse de l'objet i est bien différente de celle de notre objet.
{
if(!this.estPleine())
x[++sommet]=i;
else
throw new PilePleineException();
}
else
throw new CycleException();
}
Revenir à l'index
Nouvelle classe Pile suite aux modification imposée par PileI :
<![CDATA[
/**
* class Pile - Permet d'instancier des piles d'objets
*
* @author (<A HREF=mailto:franck.leveque2@free.fr> LEVEQUE Franck </A>)
* @version (29/11/2002)
*/
public class Pile implements PileI
{
// instance variables - replace the example below with your own
private Object[] x; // Elements de la pile
private int sommet; // Index du dernier élément entré
private int tailleBuffer; // Taille du buffer
/**
* Constructor for objects of class Pile
*/
public Pile(int taille)
{
// initialise instance variables
x = new Object[taille];
sommet=-1;
tailleBuffer=taille;
}
/**
* Empiler - Mets l'objet i sur la pile
*
* @param i Objet à empiler
*/
public void empiler(Object i) throws PilePleineException
{
if(!this.estPleine())
x[++sommet]=i;
else
throw new PilePleineException();
}
/**
* Depiler - Retourne le dernier objet entré de la pile et le supprime de cette dernière
*
* @return dernier objet entré de la pile
*/
public Object depiler() throws PileVideException
{
if(!this.estVide())
return x[sommet--];
else
throw new PileVideException();
}
/**
* estVide - Indique si la pile est vide.
*
* @return vrai si la pile est vide, faux sinon
*/
public boolean estVide()
{
return sommet==-1;
}
/**
* estPleine - Indique si la pile est pleine.
*
* @return vrai si la pile est pleine, faux sinon
*/
public boolean estPleine()
{
return sommet==(tailleBuffer-1);
}
/**
* Sommet - Retourne le dernier objet entré de la pile
*
* @return dernier objet entré de la pile
*/
public Object sommet() throws PileVideException
{
if(!this.estVide())
return x[sommet];
else
throw new PileVideException();
}
/**
* toString - Transforme l'objet en chaine de caractère visionnable.
*
* @return La liste des objets contenus dans la pile (sous forme visualisable)
*/
public String toString()
{
String res;
res="[";
for(int i=0;i<=sommet;i++)
{
if(i<sommet)
res += x[i].toString() + ";";
else
res += x[i].toString();
}
res+="]";
return res;
}
}
]]>
Revenir à l'index
Première implementation de la classe Pile avec la classe Stack :
<![CDATA[
/**
* Write a description of class PileStack here.
*
* @author (<A HREF=mailto:franck.leveque2@free.fr> LEVEQUE Franck </A>)
* @version (29/11/2002)
*/
import java.util.Stack;
import java.util.EmptyStackException;
public class PileStack implements PileI
{
private Stack stk; // La PileStack est implémentée par délégation
private int tailleBuffer; // Permet de lever l'exception PilePleine ...
/**
* Constructor for objects of class PileStack
*/
public PileStack(int taille)
{
stk = new Stack();
tailleBuffer=taille;
}
/**
* Empiler - Mets l'objet i sur la pile
*
* @param i Objet à empiler
*/
public void empiler(Object i) throws PilePleineException
{
if(!this.estPleine())
stk.push(i);
else
throw new PilePleineException();
}
/**
* Depiler - Retourne le dernier objet entré de la pile et le supprime de cette dernière
*
* @return dernier objet entré de la pile
*/
public Object depiler() throws PileVideException
{
try
{
return stk.pop();
}
catch(EmptyStackException e)
{
throw new PileVideException();
}
}
/**
* estVide - Indique si la pile est vide.
*
* @return vrai si la pile est vide, faux sinon
*/
public boolean estVide()
{
return stk.empty();
}
/**
* estPleine - Indique si la pile est pleine.
*
* @return vrai si la pile est pleine, faux sinon
*/
public boolean estPleine()
{
return stk.size()==tailleBuffer;
}
/**
* Sommet - Retourne le dernier objet entré de la pile
*
* @return dernier objet entré de la pile
*/
public Object sommet() throws PileVideException
{
try
{
return stk.peek();
}
catch(EmptyStackException e)
{
throw new PileVideException();
}
}
/**
* toString - Transforme l'objet en chaine de caractère visionnable.
*
* @return La liste des objets contenus dans la pile (sous forme visualisable)
*/
public String toString()
{
return stk.toString();
}
}
]]>
Seconde implementation de la classe Pile avec la classe Vector :
<![CDATA[
/**
* Write a description of class PileVector here.
*
* @author (<A HREF=mailto:franck.leveque2@free.fr> LEVEQUE Franck </A>)
* @version (29/11/2002)
*/
import java.util.Vector;
public class PileVector implements PileI
{
private Vector v; // La PileVector est implémentée par délégation
/**
* Constructor for objects of class PileStack
*/
public PileVector(int taille)
{
v = new Vector(taille);
}
/**
* Empiler - Mets l'objet i sur la pile
*
* @param i Objet à empiler
*/
public void empiler(Object i) throws PilePleineException
{
if(!(v.size()==v.capacity()))
v.addElement(i);
else
throw new PilePleineException();
}
/**
* Depiler - Retourne le dernier objet entré de la pile et le supprime de cette dernière
*
* @return dernier objet entré de la pile
*/
public Object depiler() throws PileVideException
{
if(!v.isEmpty())
return v.remove(v.size()-1);
else
throw new PileVideException();
}
/**
* estVide - Indique si la pile est vide.
*
* @return vrai si la pile est vide, faux sinon
*/
public boolean estVide()
{
return v.isEmpty();
}
/**
* estPleine - Indique si la pile est pleine.
*
* @return vrai si la pile est pleine, faux sinon
*/
public boolean estPleine()
{
return v.size()==v.capacity();
}
/**
* Sommet - Retourne le dernier objet entré de la pile
*
* @return dernier objet entré de la pile
*/
public Object sommet() throws PileVideException
{
if(!v.isEmpty())
return v.lastElement();
else
throw new PileVideException();
}
/**
* toString - Transforme l'objet en chaine de caractère visionnable.
*
* @return La liste des objets contenus dans la pile (sous forme visualisable)
*/
public String toString()
{
return v.toString();
}
}
]]>
Revenir à l'index
Voici la classe Pile modifiée :
<![CDATA[
/**
* class Pile - Permet d'instancier des piles d'objets
*
* @author (<A HREF=mailto:franck.leveque2@free.fr> LEVEQUE Franck </A>)
* @version (04/12/2002)
*/
public class Pile extends java.lang.Object implements PileI
{
// instance variables - replace the example below with your own
private Object[] x; // Elements de la pile
private int sommet; // Index du dernier élément entré
private int tailleBuffer; // Taille du buffer
private class PileIterateur implements java.util.Enumeration
{
private int pointeur;
public PileIterateur()
{
pointeur=-1;
}
public Object nextElement()
{
if(hasMoreElements())
return x[++pointeur];
else
return null;
}
public boolean hasMoreElements()
{
return !(pointeur==sommet);
}
}
/**
* Constructor for objects of class Pile
*/
public Pile(int taille)
{
// initialise instance variables
x = new Object[taille];
sommet=-1;
tailleBuffer=taille;
}
/**
* Empiler - Mets l'objet i sur la pile
*
* @param i Objet à empiler
*/
public void empiler(Object i) throws PilePleineException
{
if(!this.estPleine())
x[++sommet]=i;
else
throw new PilePleineException();
}
/**
* Depiler - Retourne le dernier objet entré de la pile et le supprime de cette dernière
*
* @return dernier objet entré de la pile
*/
public Object depiler() throws PileVideException
{
if(!this.estVide())
return x[sommet--];
else
throw new PileVideException();
}
/**
* estVide - Indique si la pile est vide.
*
* @return vrai si la pile est vide, faux sinon
*/
public boolean estVide()
{
return sommet==-1;
}
/**
* estPleine - Indique si la pile est pleine.
*
* @return vrai si la pile est pleine, faux sinon
*/
public boolean estPleine()
{
return sommet==(tailleBuffer-1);
}
/**
* Sommet - Retourne le dernier objet entré de la pile
*
* @return dernier objet entré de la pile
*/
public Object sommet() throws PileVideException
{
if(!this.estVide())
return x[sommet];
else
throw new PileVideException();
}
/**
* elements - retourne une enumeration des objets de la pile.
*
* @return enumeration des objets contenus dans la pile
*/
public java.util.Enumeration elements()
{
return new PileIterateur();
}
/**
* getSommet - Retourne le sommet de la pile
*
* @return Nombre d'éléments de la pile - 1
*/
protected int getSommet()
{
return sommet;
}
/**
* getTailleBuffer - Retourne la taille du Buffer de la Pile
*
* @return Retourne la taille du Buffer de la Pile
*/
protected int getTailleBuffer()
{
return tailleBuffer;
}
/**
* equals - Détermine si deux piles sont égales. Cette égalité est déterminé par les critères suivants:
* Les piles contiennent le même nombre d'élément, et sont de même taille.
* Chaque références des objets des piles sont identiques et positionné de la même manière
*
* @param e Pile à comparer
* @return Résultat de la commparaison : Vrai si les Piles sont identiques, faux sinon.
*/
public boolean equals(Pile e)
{
if(e.getSommet()==sommet && e.getTailleBuffer()==tailleBuffer)
{
boolean res=true;
java.util.Enumeration p1 = this.elements();
java.util.Enumeration p2 = e.elements();
while(p1.hasMoreElements() && res)
{
res= (p1.nextElement() == p2.nextElement());
}
return res;
}
else
return false;
}
/**
* toString - Transforme l'objet en chaine de caractère visionnable.
*
* @return La liste des objets contenus dans la pile (sous forme visualisable)
*/
public String toString()
{
java.util.Enumeration e = this.elements();
String res;
res="[";
while(e.hasMoreElements())
res+=e.nextElement() + ";";
if(res.length()>1)
res=res.substring(0,res.length()-1);
res+="]";
return res;
}
}
]]>
Revenir à l'index
Voici la classe Pile modifiée :
<![CDATA[
/**
* class Pile - Permet d'instancier des piles d'objets
*
* @author (<A HREF=mailto:franck.leveque2@free.fr> LEVEQUE Franck </A>)
* @version (04/12/2002)
*/
public class Pile extends java.lang.Object implements PileI
{
// instance variables - replace the example below with your own
private Object[] x; // Elements de la pile
private int sommet; // Index du dernier élément entré
private int tailleBuffer; // Taille du buffer
private class PileIterateur implements java.util.Enumeration
{
private int pointeur;
public PileIterateur()
{
pointeur=-1;
}
public Object nextElement()
{
if(hasMoreElements())
return x[++pointeur];
else
return null;
}
public boolean hasMoreElements()
{
return !(pointeur==sommet);
}
}
public class PileIterator implements java.util.Iterator
{
private int pointeur;
public PileIterator()
{
pointeur = -1;
}
public Object first()
{
return x[pointeur = 0];
}
public Object next()
{
if(!isDone())
return x[++pointeur];
else
return null;
}
public void remove()
{
// nothing to do
}
public boolean hasNext()
{
return !(pointeur==sommet);
}
public boolean isDone()
{
return (pointeur==sommet);
}
public Object CurrentItem()
{
return x[pointeur];
}
}
/**
* iterator - retourne une iterator des objets de la pile.
*
* @return iterateur des objets contenus dans la pile
*/
public java.util.Iterator iterator()
{
return new PileIterator();
}
/**
* Constructor for objects of class Pile
*/
public Pile(int taille)
{
// initialise instance variables
x = new Object[taille];
sommet=-1;
tailleBuffer=taille;
}
/**
* Empiler - Mets l'objet i sur la pile
*
* @param i Objet à empiler
*/
public void empiler(Object i) throws PilePleineException
{
if(!this.estPleine())
x[++sommet]=i;
else
throw new PilePleineException();
}
/**
* Depiler - Retourne le dernier objet entré de la pile et le supprime de cette dernière
*
* @return dernier objet entré de la pile
*/
public Object depiler() throws PileVideException
{
if(!this.estVide())
return x[sommet--];
else
throw new PileVideException();
}
/**
* estVide - Indique si la pile est vide.
*
* @return vrai si la pile est vide, faux sinon
*/
public boolean estVide()
{
return sommet==-1;
}
/**
* estPleine - Indique si la pile est pleine.
*
* @return vrai si la pile est pleine, faux sinon
*/
public boolean estPleine()
{
return sommet==(tailleBuffer-1);
}
/**
* Sommet - Retourne le dernier objet entré de la pile
*
* @return dernier objet entré de la pile
*/
public Object sommet() throws PileVideException
{
if(!this.estVide())
return x[sommet];
else
throw new PileVideException();
}
/**
* elements - retourne une enumeration des objets de la pile.
*
* @return enumeration des objets contenus dans la pile
*/
public java.util.Enumeration elements()
{
return new PileIterateur();
}
/**
* getSommet - Retourne le sommet de la pile
*
* @return Nombre d'éléments de la pile - 1
*/
protected int getSommet()
{
return sommet;
}
/**
* getTailleBuffer - Retourne la taille du Buffer de la Pile
*
* @return Retourne la taille du Buffer de la Pile
*/
protected int getTailleBuffer()
{
return tailleBuffer;
}
/**
* equals - Détermine si deux piles sont égales. Cette égalité est déterminé par les critères suivants:
* Les piles contiennent le même nombre d'élément, et sont de même taille.
* Chaque références des objets des piles sont identiques et positionné de la même manière
*
* @param e Pile à comparer
* @return Résultat de la commparaison : Vrai si les Piles sont identiques, faux sinon.
*/
public boolean equals(Pile e)
{
if(e.getSommet()==sommet && e.getTailleBuffer()==tailleBuffer)
{
boolean res=true;
java.util.Enumeration p1 = this.elements();
java.util.Enumeration p2 = e.elements();
while(p1.hasMoreElements() && res)
{
res= (p1.nextElement() == p2.nextElement());
}
return res;
}
else
return false;
}
/**
* toString - Transforme l'objet en chaine de caractère visionnable.
*
* @return La liste des objets contenus dans la pile (sous forme visualisable)
*/
public String toString()
{
java.util.Enumeration e = this.elements();
String res;
res="[";
while(e.hasMoreElements())
res+=e.nextElement() + ";";
if(res.length()>1)
res=res.substring(0,res.length()-1);
res+="]";
return res;
}
}
]]>
Revenir à l'index
Voici l'applette permettant de testé la nouvelle méthode toString()
Télécharger le source
Voici l'applette utilisant la nouvelle implémentation de l'interface PileI à savoir PileStack
Télécharger le source
Revenir à l'index