Insert che inserisce un elemento nella Structure un metodo remove



Scaricare 29.97 Kb.
21.12.2017
Dimensione del file29.97 Kb.


Structure


Si vuole definire una classe astratta Structure, che definisce strutture di oggetti omogenei con un’operazione di unione di due strutture e un concetto di contenimento di una struttura in un’altra.


(a) Si specifichi la classe astratta Structure dotandola di:
- un metodo insert che inserisce un elemento nella Structure.

- un metodo remove che rimuove un elemento dalla Structure.

- un metodo concatenate che unisce a una Structure una Structure passata come argomento.


  • un metodo substructure che dà vero se la Structure cui è applicato è contenuta nella Structure passata come argomento. Una struttura A è contenuta in una struttura B sse tutti gli elementi di A appaiono in B con almeno la stessa molteplicità




  • un iteratore elements che restituisce un generatore che genera gli elementi della Structure in ordine crescente, in base all’ordinamento fornito da un Comparator relativo.

public abstract class Structure {

// OVERVIEW: un Structure è una struttura // di oggetti omogenei. E’ modificabile.
// metodi

public abstract void insert (Object o) throws NullPointerException, ClassCastException;



// MODIFIES: this

// EFFECTS: se o e’ null solleva

// NullPointerException,

// se gli elementi contenuti in this non sono

// omogenei con o solleva

// ClassCastException, altrimenti aggiunge

// o a this .
public abstract void remove(Object o);

// MODIFIES: this

// EFFECTS: rimuove o da this se vi occorre

public abstract void concatenate(Structure s) throws NullPointerException, ClassCastException;



// MODIFIES: this

// EFFECTS: : se s è null solleva

// NullPointerException,



// se gli elementi contenuti in this non sono

// omogenei con quelli di s solleva



// ClassCastException, altrimenti aggiunge

// a this gli elementi di s.

public abstract boolean substructure(Structure s) throws NullPointerException, ClassCastException;

// MODIFIES: this

// EFFECTS: : se s è null solleva

// NullPointerException, se gli elementi

// contenuti in this non sono omogenei con

// quelli di s solleva ClassCastException,

// se this e’ contenuta in s restituisce true,

// altrimenti restituisce false .


public abstract Iterator elements() ;



// EFFECTS: restituisce un generatore che

// fornisce tutti gli elementi di this (una sola

// volta) in ordine crescente in base

// all’ordinamento fornito da un Comparator

}

(b) Si specifichi (dando rappresentazione, funzione di astrazione e invariante) la sottoclasse concreta ListStructure, che definisce liste di oggetti omogenei. Si implementino il costruttore, che riceve come argomento un Comparator per confrontare i dati della Structure, e i metodi concatenate, substructure, elements.


public class ListStructure extends Structure {

// OVERVIEW: un ListStructure è una lista

// di oggetti omogenei. E’ modificabile.

// rappresentazione

private Vector elements;

private Comparator comp;
// costruttore

public ListStructure (Comparator c) throws NullPointerException{

elements=new Vector();

if (c==null) throw new NullPointerException(“ListStructure”);

comp=c;}
public void concatenate (Structure s) throws NullPointerException, ClassCastException{

if (s==null) throw new NullPointerException(“ListStructure.conc”);

Iterator t = s.elements();

while t.hasNext() {Object v = t.next();

if(this.elements.size() > 0) int res =

comp.compare (this.elements.get(0),v);

this.elements.add(v);} }

public boolean substructure (Structure s) throws NullPointerException, ClassCastException {

if (s==null) throw new NullPointerException (“ListStructure.sub”);

for (int i=0; i

{Iterator t=s.elements();

boolean trovato=false;

while (! trovato && it.hasnext())

{int res = comp.compare(elements.get(i),

it.next());

if (res==0) {trovato=true}

}

if (! trovato) return false;



}

return true;}


public abstract Iterator elements() {return new Gen(this);}

//generatore


private static class Gen implements Iterator {

private ListStructure io;

private int index;
// costruttore

public Gen (ListStructure x) {io=x;

index=0;}
public boolean hasNext () {if (index < io.elements.size()) return true:

else return false;}


public boolean next () throws NoSuchElementException{

if (index >= io.elements.size()) throw new NoSuchElementException(“Liststructure.Gen”);

return io.elements.get(index);

index++;}

}
}
(c) Si dimostri che i metodi concatenate e substructure preservano l’invariante e soddisfano la specifica.

// Funzione di astrazione


alpha(d)=[ d.elements.get(0),…., d.elements.get(d.elements.size()-1)]

// Invariante


I(d)= d.elements!=null & d.comp!null &

per ogni i,j (0 < i< j < d.elements.size()

d.elements.get(i) e d.elements.get(j) hanno lo stesso tipo

e

d.comp.compare(d.elements.get(i), d.elements.get(j)) <=0


Il metodo substructure soddisfa banalmente l’invariante perché non modica this e il parametro.
Il metodo concatenate soddisfa l’invariante perché per ipotesi induttiva this e il parametro la soddisfano. Inoltre insert soddisfa l’invariante.

(d) Si implementi il comparatore per il caso che gli oggetti siano Integer.

public class IntComp implements Comparator{
public IntComp()

{}
public int compare(Object x, Object y) throw ClassCastException{

int z= ((Integer)) x.intValue();

int w= ((Integer)) y.intValue();

if (z==w) return 0;

if (z

if (z >w) return 1;

}

}





©astratto.info 2017
invia messaggio

    Pagina principale