LIP: 8 Marzo 2005 Vettori

Abbiamo visto L’uso di Vector come alternativa all’uso di arrays Rivediamo l’esercizio dell’altra volta

Commenti Arrays e Vector servono per risolvere problemi simili (quando si devono memorizzare sequenze di valori) La gestione di dati modificabilicon Vector e’ notevolmente piu’ semplice rispetto agli arrays (automaticamente vengono aggiunte o tolte posizioni) Per contro bisogna fare attenzione ai sottotipi ed usare cast per risolvere i problemi del compilatore E’ importante pero’ sapere che il tipo di dato Arrays e’ piu’ efficiente Usare Vector solo quando le sequenze da memorizzare hanno dimensione variabile (come nel caso dell’elenco) Si possono anche usare altre strutture (tipo le liste)

Commenti Abbiamo visto due implementazioni alternative dello stesso tipo di dato (l’elenco) Cosa succede al codice che usa il tipo di dato quando cambiamo l’implementazione (ex. Programma di testing)? Dipende da come lo abbiamo fatto (se per esempio accede alle variabili d’istanza e/o usa solo l’interfaccia pubblica) Per esempio il metodo di testing che avevo scritto io deve essere riprogettato se cambiamo l’implementazione Come vedremo questo e’un pessimo stile di programmazione Vedremo nel seguito (del corso di MP) cosa vuol dire interfaccia pubblica e come si deve invece astrarre dall’implementazione (ovvero mascherare l’implementazione)

Classe Object La classe Object è la superclasse, diretta o indiretta, di ciascuna classe in Java, quindi Object è supertipo di qualsiasi tipo (che definisce oggetti). Grazie al meccanismo dell'ereditarietà  i suoi metodi sono ereditati da tutti i tipi (che definiscono oggetti).  ad una variabile di tipo Object possiamo assegnare oggetti di qualsiasi tipo (principio di sostituzione)

Attenzione I tipi primitivi int, boolean, double non sono sottotipi di Object, non sono oggetti (vedi la differenza nella semantica di FP) String e’ un tipo primitivo sottotipo di Object Abbonato, Elenco sono esempi di tipi non primitivi sottotipi di Object

Problema Come si fa ad usare Vector per memorizzare tipi primitivi? Vector elements=new Vector(); elements.addElement(3); errore di tipo! int non e’ sottotipo di Object (il metodo addElement ha parametro Object) Analoghi problemi per gli altri tipi boolean, double…

La soluzione Ogni tipo ha un corrispondente tipo involucro di oggetti che memorizzano i valori corrispondenti Per esempio, Integer e’ la classe involucro di int Ogni Integer e’ un oggetto che memorizza un valore int La differenza e’ che Integer e’ sottotipo di Object oggetto che contiene il valore Classi analoghe per tutti gli altri tipi primitivi

Integer ha (oltre ai soliti metodi toString e equals ): un costruttore con parametro di tipo primitivo public Integer(int value){ \\EFFECTS: crea un Integer che contiene il valore value}\\EFFECTS un metodo che produce il valore di tipo primitivo corrispondente public int intValue(){ \\EFFECTS: restituisce il numero intero contenuto in this}\\EFFECTS

Quindi Per memorizzare il valore 3 in un Vector bisogna creare un Integer che contiene il valore Integer e= new Integer(3); //lo creo elements.addElement(e); //lo inserisco Per leggere un valore da un Vector di Integer e trasformarlo in int Integer i= (Integer) elements.elementAt(3); //Cast int x= i.intValue();//conversione

Ricordiamo che tutti gli oggetti ereditano da Object public boolean equals(Object obj) \\EFFECTS :verifica se l'oggetto this è uguale a obj.\\EFFECTS Il metodo ereditato e’ poco utile (verifica se il riferimento e’ uguale e non il valore contenuto) Ha la stessa semantica dell’operatore == Confronto tra oggetti

Esempio Abbonato a1 =new Abbonato(1,2); Abbonato a2 =new Abbonato(1,2); if (a1.equals(a2)) Viene eseguito il metodo piu’ specifico (quello ereditato da Object); Risultano diversi anche se contengono gli stessi valori, infatti sono in due locazioni diverse (vedi semantica di new) Analogo risultato se li confontassi con == Per avere un confronto significativo devo sovrascriverlo in modo da confrontare lo stato interno

Metodo da aggiungere alla classe Abbonato public boolean equals(Object o){ Abbonato a =(Abbonato)o; if (this.nome=a.nome && this.num=a.num) {return true;} else {return false;} } Il metodo overriden fa il confronto tra gli stati interni Di conseguenza nell’esempio precedente viene invocato questo invece di quello della superclasse (restituisce true)

Tipi primitivi Per i tipi primitivi il metodo equals e’ generalmente gia’ overridden Tipo per Integer o String Deve essere invocato per confrontarli L’operatore == e’ utile per fare il confronto con null (per verificare il riferimento)

Esercizio Proposto Definire una classe VectorOp che definisce alcune procedure stand-alone (metodi statici) che operano su Vector che contengono Integer In particolare

Metodi Statici public static int min(Vector v){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce il minimo di v o zero se il vettore e’ vuoto } Nota: dobbiamo mettere una precondizione sui dati di input (altrimenti non ha senso)

Metodi Statici public static Vector inc(Vector v, int i){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce un vettore che contiene tutti gli elementi di v (nello stesso ordine) incrementati di i} public static Vector reverse(Vector v){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce un vettore che e’ l’inverso di v} public static Vector sort(Vector v){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce un vettore che e’ una versione ordinata di v}

Sviluppare (in parallelo) un Tester Prende dei valori da console Costruisce un vettore che li contiene Testa i vari metodi, chiamandoli sul vettore Per “vedere” il contenuto di un vettore nelle varie fasi basta stampare tutti i suoi elementi Non fatelo alla fine (se no non serve a niente) Scrivete un metodo e testatelo (poi passate a quello successivo) Per i metodi che restituiscono un Vector e’ essenziale stampare i valori contenuti nel vettore

Classe di Procedure Statiche public class VectorOp{ public static int min(Vector v){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce il minimo di v o zero se il vettore e’ vuoto } if (v.size()==0) {return 0;} int min= ((Integer) v.elementAt(0)).intValue(); for (int i=1; i < v.size();i++) {Integer x=(Integer) v.elementAt(i); if (x.intValue() < min} {min=x.intValue();} } return min;}

Classe di Procedure Statiche public class VectorOp{ public static Vector inc(Vector v, int i){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce un vettore che contiene tutti gli elementi \\di v (nello stesso ordine) incrementati di i} Vector nuovo=new Vector(); for (int i=0; i < v.size();i++) {int x=((Integer) v.elementAt(i)).intValue(); nuovo.addElement(new Integer(x+i));} return nuovo;} Attenzione la specifica del metodo dice che v non deve essere modificato (altrimenti sarebbe riportato in MODIFIES) Le richieste espresse dai commenti informali devono essere soddisfatte dall’implementazione Non deve quindi modifacare v se non riportato nei commenti

Importanza dei commenti informali Descrivono quello che vogliamo che un metodo o tipo di dato faccia Sono fondamentali (oltre che per spiegarvi cosa dovete fare negli esercizi) Mettetevi dal punto di vista di chi deve usare il metodo inc che avete implementato E’ pensabile che debba andare a leggere il codice per sapere cosa fa? Per vedere quale algoritmo avete usato? Se dovete usare un metodo della classe primitiva Vector andate a vedere l’implementazione o leggete nel manuale la descrizione del suo comportamento? I commenti informali servono quindi per informare chi lo usa di cosa il metodo fa (non di come lo fa ) e sono tutto quello che sanno sul funzionamento del metodo coloro che lo usano Procedendo in questo modo (lo vedremo ad MP) saranno un meccanismo di astrazione fondamentale (permettono di astrarre dalle varie implementazioni)

Soluzione public static Vector reverse(Vector v){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce un vettore che e’ l’inverso di v} Vector nuovo=new Vector(); for (int i=v.size()-1; i >=0;i++) { nuovo.addElement(v.elementAt(i));} return nuovo;} }

public static Vector sort(Vector v){ \\REQUIRES\\REQUIRES: v contiene Integer non null \\EFFECTS\\EFFECTS: restituisce un vettore che e’ la versione ordinata di v} Vector nuovo=new Vector(); for (int i=0; i< v.size();i++) {Integer x=(Integer) v.elementAt(i); boolean inserito=false; for (int j=0; j< nuovo.size();j++) {Integer h=(Integer) nuovo.elementAt(j)); if (x.intValue() < h.intValue()) {inserito=true; nuovo.insertElementAt(j,x);} } if (! inserito) {nuovo.addElement(x);} } return nuovo;} } Conviene creare un nuovo vettore in cui ricopiare i valori di v (invece che in ordine casuale in modo che sia ordinato) Se ne troviamo uno piu’ grande lo inseriamo al suo posto (vengono tutti spostati di una posizione) Se non lo abbiamo trovato allora o il vettore e’ vuoto o e’ il piu’ grande di tutti (va in fondo) }