Mardi 3/11 prochain

Programmation Avancée

Modérateur : douinj

douinj
Messages : 204
Inscription : 18 mars 2009 15:46

Mardi 3/11 prochain

Message par douinj » 29 oct. 2020 13:21

Bonjour, mardi 3/11 sera une correction du tp3q2, une synthèse des premiers cours à la demande suivi d'un cours sur la généricité (ou l'inverse)

N'hésitez pas à utiliser ce fil de discussions afin de noter les sujets que vous aimeriez approfondir.

Ce mardi débutera par une correction de la question2 du tp3, avec l'aide du patron Template Method, nous en profiterons pour ajouter l'invariant de classe et la fonction d'abstraction (repOk et af cf. Liskov)

la nouvelle interface PileI<T>

Code : Tout sélectionner

public interface PileI<T>{
  
  public final static int CAPACITE_PAR_DEFAUT=6;
    
  public void empiler(T t) throws PilePleineException;
  public T depiler() throws PileVideException;
  
  public T sommet() throws PileVideException;
  
  public int capacite();
  public int taille();
  public boolean estVide();
  public boolean estPleine();
  
  public boolean equals(Object o);
  public int hashCode();
  public String toString();
  
  public <A> A af();
  public boolean repOk();

douinj
Messages : 204
Inscription : 18 mars 2009 15:46

Re: Mardi 3/11 prochain

Message par douinj » 01 nov. 2020 11:37

Bonjour, afin de ne pas perdre de temps mardi prochain, nous partirons ensemble des classes incomplète ci-dessous,
l'architecture choisie s'inspire de l'architecture des collections vue mardi dernier, elle même issue du patron Template Method

Recopiez dans votre projet bluej, l'interface PileI, la classe abstraite et la classe de tests unitaires

Code : Tout sélectionner

public interface PileI<T>{
  
  public final static int CAPACITE_PAR_DEFAUT=6;
    
  public void empiler(T t) throws PilePleineException;
  public T depiler() throws PileVideException;
  
  public T sommet() throws PileVideException;
  
  public int capacite();
  public int taille();
  public boolean estVide();
  public boolean estPleine();
  
  public boolean equals(Object o);
  public int hashCode();
  public String toString();
  
  public <T> T af();
  public boolean repOk();

  
}

Code : Tout sélectionner

public class PilePleineException extends Exception{}

Code : Tout sélectionner

public class PileVideException extends Exception{}

Code : Tout sélectionner


import java.util.List;
import java.util.ListIterator;

import java.util.ArrayList;
import java.util.Stack;
import java.util.Collections;

public abstract class AbstractPile<T> implements PileI<T>{
  protected int   capacite;
 
  protected AbstractPile(int capacite){
    if(capacite<=0) capacite = CAPACITE_PAR_DEFAUT;
    this.capacite = capacite;
  }

  public AbstractPile(){
    this(PileI.CAPACITE_PAR_DEFAUT);
  }
  
  public int capacite(){
    return capacite;
  }
  
  public boolean estVide(){
    return taille() == 0;
  }
  public boolean estPleine(){
    return taille() == capacite();
  }
  
  @Override
  public boolean equals(Object o){
    if( !(o instanceof PileI)) return false;
    PileI p1 = ((PileI)o);
    return this.capacite() == p1.capacite() && false; // a completer
          
  }
  

  public int hashCode(){
    return toString().hashCode();
  }

  public String toString(){
  
    return null; // a completer
  }

  
  public abstract void empiler(T t) throws PilePleineException;
  public abstract T depiler() throws PileVideException;
  public abstract T sommet() throws PileVideException;
  public abstract int taille();
  
  //public abstract <A> A af();
  public Stack<T> af(){  // abstraction naturelle ?
      Stack<T> stk = new Stack<>();
     // a completer
      return stk;
  }
  
  public boolean repOk(){
      return taille() >=0 && taille() <= capacite && capacite>=0 && tousLesElementsNonNull();
  }
  
  private boolean tousLesElementsNonNull(){
      return false; // a completer
      //return true;
    }
  
}

Code : Tout sélectionner

public class TestsPileI extends junit.framework.TestCase {

    private PileI<Integer> pile;
    private PileI<Integer> pile2;
    private PileI<Integer> pile4;

    public void setUp() // throws java.lang.Exception
    {
        pile  = new Pile<Integer>(10);
        pile4 = new Pile4<Integer>(10);

    }

    public void tearDown() // throws java.lang.Exception
    {
        //Libérez ici les ressources engagées par setUp()
    }

     public void testPileEmpilerElementNull() throws Exception{
         pile.empiler(new Integer(2));
         pile.empiler(new Integer(4));
         pile.empiler(null);
         pile.empiler(new Integer(1));
         assertFalse("invariant de classe Pile n'est pas respecté",pile.repOk());
        }
        
    public void testPileEmpiler() throws Exception{
        assertTrue("invariant de classe Pile en échec",pile.repOk());
        assertTrue("invariant de classe Pile en échec",pile4.repOk());

        Stack<Integer> stk = pile.af();
        pile.empiler(3); assertTrue(pile.repOk());
        stk.push(3);
        assertEquals(pile.af(),stk);
        pile.empiler(1);assertTrue(pile.repOk());

        stk = pile4.af();
        pile4.empiler(3);assertTrue(pile4.repOk());
        stk.push(3);
        assertEquals(pile4.af(),stk);
        pile4.empiler(1);assertTrue(pile4.repOk());

    }

    public void testsSimples() {
        int element = 1;
        try{
            while(!pile.estPleine()){
                pile.empiler(element);
                assertEquals( element, pile.sommet().intValue());
                element++;
            }
        }catch(PilePleineException e){
            fail(e.getClass().getName() + " ne peut être levée ici ???");
        }catch(PileVideException e){
            fail(e.getClass().getName() + " ne peut être levée ici ???");
        }
         try{
             pile.empiler(element);
             fail("Une exception (PilePleineException) aurait dû être levée ???");
        }catch(Exception e){
            assertTrue(e instanceof PilePleineException);
        }
             
        try{
            while(!pile.estVide()){
                element = pile.depiler();
            }        
        }catch(PileVideException e){
            fail(e.getClass().getName() + " ne peut être levée ici ???");
        }

        try{
             pile.depiler();
             fail("Une exception (PileVideException) aurait dû être levée ???");
        }catch(Exception e){
            assertTrue(e instanceof PileVideException);
        }

    }

}
Une correction de Pile4

Code : Tout sélectionner

import java.util.Stack;
public class Pile4<T> extends AbstractPile<T> {
    private Maillon<T> stk;
    /** le nombre */
    private int nombre;

    /** Classe interne "statique" et memebre contenant chaque élément de la chaine
     */
    private class Maillon<T> {
        private T element;
        private Maillon suivant;

        public Maillon(T element, Maillon suivant){
            this.element = element;
            this.suivant = suivant;
        }

        public Maillon suivant(){
            return this.suivant;
        }

        public T element(){
            return this.element;
        }

    }

    /** Création d'une pile.
     * @param taille la taille de la pile, la taille doit être > 0
     */
    public Pile4(int taille){
        super(taille);
        this.stk = null;
    }

    public Pile4(){
        this(PileI.CAPACITE_PAR_DEFAUT);
    }

    public void empiler(T o) throws PilePleineException{
        if(estPleine()) throw new PilePleineException();
        stk = new Maillon(o, stk);
        nombre++;
    }

    public T depiler() throws PileVideException{
        if(estVide())  throw new PileVideException();
        T elt = stk.element();
        stk = stk.suivant();
        nombre--;
        return elt;
    }

    public T sommet() throws PileVideException{
        if(estVide())  throw new PileVideException();
        return stk.element();
    }

    public boolean repOk(){
        return super.repOk() && ((this.stk == null) ||(this.stk!=null && true/*TODO*/));

    }

    public java.util.Stack<T> af(){
        return copie(stk); 
    }

    private java.util.Stack<T> copie(Maillon m){

        if(m==null){
            return new java.util.Stack<T>();
        }else{
            java.util.Stack<T> stk = copie(m.suivant());
            stk.push((T)m.element);
            return stk;
        }

    }

    //   public Object clone() throws CloneNotSupportedException{
    //     Pile4 p = new Pile4(this.capacite());
    //     traversée(p,stk);
    //     return p;
    //   }
    //   
    //   private void traversée(Pile4 p, Maillon m){
    //     try{
    //       if(m!=null){
    //         traversée(p,m.suivant());
    //         p.empiler(m.element());
    //       }
    //     }catch(PilePleineException e){
    //     }
    //   }

    public int taille(){
        return nombre;
    }
}

Répondre