Public abstract class Table {



Scaricare 39.5 Kb.
21.12.2017
Dimensione del file39.5 Kb.

TABLE

Si consideri la seguente classe astratta che specifica il tipo di dato Table. Un oggetto di tipo Table ha un numero fisso di colonne e un numero variabile di righe. Gli elementi di una colonna devono essere tutti del medesimo tipo. E` non modificabile.
public abstract class Table {

// OVERVIEW: Un oggetto di tipo Table

// è una tabella bidimensionale con il

// numero di colonne fissato e il numero

// di righe variabile. Gli elementi di una



// colonna devono essere tutti del

// medesimo tipo. E` non modificabile.


public abstract boolean isempty ();

// EFFECTS: se this è vuota ritorna

// true, altrimenti ritorna false.


public abstract Table add (Object [] A) throws NullPointer Exception,

InvalidRowSizeException, ClassCastException;



// EFFECTS: se A è null solleva

// NullPointer Exception, se



// A.length è diversa dal numero di

// colonne della tabella solleva

// InvalidRowSizeException, se i tipi // degli oggetti in A non sono quelli

// attesi solleva ClassCastException,

// altrimenti restituisce la tabella



// ottenuta aggiungendo in this la //riga formata dagli elementi di A //nell’ordine.

public abstract Table remove (int i) throws InvalidRowIndexException;



// EFFECTS: se l’i-esima riga non

// esiste solleva

// InvalidRowIndexException,

// altrimenti restituisce la tabella

// ottenuta rimuovendo da this

// l’i-esima riga
public abstract Table reset (int i, int j, Object v) throws NullPointer Exception, InvalidEntryException,

ClassCastException;



// EFFECTS: restituisce la tabella

// ottenuta da this sostituendo l’oggetto v //all’oggetto nella i-esima riga e j-esima

// colonna; se questo non esiste solleva //InvalidEntryException, se v è null

// solleva NullPointer Exception, se v non

// è del tipo dell’oggetto

// che deve sostituire solleva

// ClassCastException.
public abstract Iterator elements ();

// EFFECTS restituisce un generatore

// che produrrà tutti gli elementi di this

// (come Objects) nell’ordine che

// hanno in this.

}

Si definisca un’implementazione gerarchica con due sottoclassi concrete che realizzano il caso tabella vuota e quello tabella non vuota, eseguendo quanto richiesto nel seguito:




  1. Si forniscano per ciascuna delle due classi specifica, funzione di astrazione e invariante di rappresentazione.

  2. Per la classe vuota si implementi il metodo add.

(c) per la classe non vuota si implementino il costruttore ed i metodi add e reset.

( c) Si dimostri che l’implementazione del metodo add del,caso non vuoto preserva l’invariante di rappresentazione e soddisfa la propria specifica.




  1. Per ciascuna delle due classi, si forniscano la specifica, la rappresentazione, la funzione di astrazione e l’invariante di rappresentazione.

Osservazione: Una tabella è una struttura [x11…x1n…xm1…xmn] con n, m≥=0


public class ETable extends Table{

// OVERVIEW: tabella vuota.

AF(c)=[]

I(c)=true

public Etable ();

// EFFECTS: costruisce una tabella vuota.


public boolean isempty ();

// EFFECTS: ritorna true.

public Table add (Object [] A) throws NullPointer Exception;

// EFFECTS: se A è null solleva

// NullPointer Exception, altrimenti restituisce

// la tabella ottenuta aggiungendo in this la riga // formata dagli elementi di A nell’ordine.

public Table remove (int i) throws InvalidRowIndexException;

// EFFECTS: solleva

// InvalidRowIndexException
public Table reset (int i, int j,Object v) throws InvalidEntry Exception;

// EFFECTS: solleva InvalidEntryException


public Iterator elements ();

// EFFECTS: ritorna un generatore che

// produrrà 0 elementi
public class FTable extends Table {

// OVERVIEW: tabella non vuota

private Object[] Vector Rep;
AF(c)=[x11…x1n…xm1…xmn] dove m=c.Rep.size(), n=c.Rep.get(0).length, xij=c.Rep.get(i-1)[j-1]

I(c) = (c.Rep<>Null) & ((i1..c.Rep.size-1) c.Rep.get(0).length== c.Rep.get(0).length) & ((i1..c.Rep.size-1) (j0..c.Rep.get(0).length-1) Class.getClass(c.Rep.get(0)[j]) ==

Class.getClass(c.Rep.get(i)[j])
protected Ftable(Object [] Vector R);

// REQUIRES: R una rappresentazione

// legale per Ftable (uso limitato al solo package e sottoclassi)

// EFFECTS: costruisce una tabella avente R

// come rappresentazione.
public boolean isempty ();

// EFFECTS: ritorna false.


public Table add (Object [] A) throws NullPointer Exception, InvalidRowSizeException, ClassCastException;

// EFFECTS: come da testo

public abstract Table remove (int i) throws InvalidRowIndexException;

// EFFECTS: come da testo

public Table reset (int i, int j, Object v) throws NullPointer Exception,

InvalidEntryException, ClassCastException;

// EFFECTS: come da testo

public Iterator elements();

// EFFECTS: come da testo
(b) Per la classe vuota si implementi il metodo add

if (A==Null) throw new NPE();

Vector R = new Vector;

R.add(A);

return new Ftable(R);



  1. Per la classe non vuota si implementino il costruttore ed i metodi add e reset.

private Ftable(Object [] Vector R){Rep = R;}


Public Table add(Object[]A){

if (A==Null) throw new NPE();

if (Rep.get(0).length != A.length) throw new IRSE();

if (!TypeCheck(Rep.get(0),A)) throw new CCE();

Vector R = new Vector();

for (int i=0; i

R.add(A);

return new Ftable(R);}

Public Table reset(int i, int j, Object v) throws NPE, IEE, CCE{

if (v==Null) throw new NPE();

if (! ((Rep.size() > i) && (Rep.get(0).length >j)) throw new IRSE();

if (Class.getClass(Rep.get(i-1)[j-1]) != Class.getClass(v)) throw new CCE();

Vector R = new Vector();

for (int k=0; k

Int L = Rep.get(i-1).length;

Object [] temp = new Object [L];

for (int k=0; k< L-1; k++)

temp[k]=Rep.get(i-1)[k];

temp[j] = v;

R[i-1] = temp;



return new Ftable(R);}


  1. Si dimostri che l’implementazione del metodo add del caso non vuoto preserva l’invariante di rappresentazione e soddisfa la propria specifica.




    • preserva invariante: dall’ipotesi induttiva che this soddisfi l’invariante, possiamo limitarci a verificare che i primi tre comandi del corpo mantengono l’invariante su this esteso con il nuovo array. In particolare, il secondo e il terzo comando verificano la seconda condizione, risp., la terza condizione.




    • soddisfa la specifica: I primi tre comandi soddisfano le clausole sul sollevamento delle eccezioni. I successivi comandi provvedono al calcolo della nuova tabella. In particolare, il quarto e quinto creano una copia R del vettore this.Rep. La nuova copia condivide gli array componenti che non possono, per la non modificabilità delle tabelle, essere modificati. Il sesto comando aggiunge alla copia R la nuova riga. Il settimo e ultimo invoca il costruttore che provvede a trasformare R in una tabella.



Condividi con i tuoi amici:


©astratto.info 2019
invia messaggio

    Pagina principale