Generics. L8 Linguaggi prog. II Unina 2

Transcript

1 Classi parametriche

2 Generics Introdotti con JAVA 5 (2004), anche se si tratta di una delle prime specifiche di java (1999) Generic Programming > scrivere codice che può essere riutilizzato per oggetti di diverso tipo in maniera sicura. L8 Linguaggi prog. II Unina 2

3 ArrayList Prima di JAVA 5 generic programming era prodotto dall ereditarietà Esempio costruzione di una classe generica ArrayList public class ArrayList { public Object get(int i) {... } public void add(object o) {... }... private Object[] elementdata; } L8 Linguaggi prog. II Unina 3

4 In questo modo però si deve fare il cast per ottenere un oggetto, e non c è nessuno controllo dei tipi di oggetto inseriti nell ArrayList ArrayList files = new ArrayList(); files.add(new File( pippo")); String filename = (String) names.get(0); errore non in compilazione ma in esecuzione! L8 Linguaggi prog. II Unina 4

5 JAVA 5 -> tipi parametrici E possibile specificare con un parametro di tipo l elemento : ArrayList<String> files = new ArrayList<String>(); In questo modo il codice e più leggibile e i conflitti si scoprono a tempo di compilazione. Non c e bisogno di casting per ottenere gli oggetti dell array list String filename = files.get(0); files.add(new File("...")); // errore di // compilazione L8 Linguaggi prog. II Unina 5

6 La programmazione generica, classi parametriche e metodi parametrici Le classi parametriche possono essere utilizzate cosi come sono (come classi container evolute), oppure per usi più evoluti si può utilizzare la programmazione generica con oggetti complessi, utilizzando le wildcard Il nome generics può essere ingannevole in quanto si riferisce in realtà ad una regolamentazione nell uso di tipi generici rispetto le prime implementazioni L8 Linguaggi prog. II Unina 6

7 Classe parametrica Una classe parametrica ha una o più variabili di tipo (racchiuse tra <> ) public class Pair<T> { public Pair() { first = null; second = null; } public Pair(T first, T second) { this.first = first; this.second = second; } public T getfirst() { return first; } public T getsecond() { return second; } public void setfirst(t newvalue) { first = newvalue; } public void setsecond(t newvalue) { second = newvalue; } } private T first; private T second; L8 Linguaggi prog. II Unina 7

8 Utilizzo classi parametriche Le classi parametriche evitano il ricorso del cast: Pair p = new Pair( prima, seconda ); String a = a.getfirst(); Il tipo String si comporta come il parametro di tipo attuale, che sostituisce il parametro di tipo formale, come avviene per le variabili L8 Linguaggi prog. II Unina 8

9 Convezione per i nomi delle variabili di tipo <E> Elementi di collezioni K,V (Key, value), elementi per tabelle T (U,S,...) qualsiasi tipo Analogia con i template del C++ Sintatticamente si deve specificare la parola template, ci sono diverse differenze (es Boost) template <class T1, class T2> struct pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair() : first(t1()), second(t2()) {} pair(const T1& x, const T2& y) : first(x), second(y) {} template <class U, class V> pair (const pair<u,v> &p) : first(p.first), second(p.second) { } } L8 Linguaggi prog. II Unina 9

10 Metodi parametrici E possibile specificare le variabili di tipo anche per un singolo metodo di una classe class ArrayAlg { public static <T> T getmiddle(t[] a) { return a[a.length / 2]); } } Invocazione String[] names = { "John", "Q.", "Public" }; String middle = ArrayAlg.<String>getMiddle(names); Oppure semplicemente (ok a compilazione e esecuzione) String middle = ArrayAlg.getMiddle(names); I metodi parametrici possono appartenere ad una classe NON parametrica o parametrica L8 Linguaggi prog. II Unina 10

11 Nell'invocazione dei metodi parametrici non è obbligatorio specificare il tipo, il compilatore applica un algoritmo type inference simile a quello dell'assegnazione dei tipi del type system. String[] names = { "John", "Q.", "Public" }; String middle = ArrayAlg.getMiddle(names); In questo caso l'algoritmo type inference è in grado di determinare come tipo più specifico String. L8 Linguaggi prog. II Unina 11

12 Da Java 5 diverse classi di Java sono diventate parametriche. Il codice pregresso generalmente continua a funzionare grazie alla type inference, con messaggi di WARNING L8 Linguaggi prog. II Unina 12

13 ... } Costruttori parametrici Anche i costruttori possono essere parametrici, come un qualsiasi altro metodo public class A<T> { public <U> A(T x, U y) { } L8 Linguaggi prog. II Unina 13

14 Parametri di tipo ristretti Può essere necessario richiedere alcune condizioni sui tipi utilizzabili dai generics. Esempio class ArrayAlg { public static <T> T min(t[] a) { if (a == null a.length == 0) return null; T smallest = a[0]; for (int i = 1; i < a.length; i++) if (smallest.compareto(a[i]) > 0) smallest = a[i]; return smallest; } } Si deve richiedere che il tipo T generico abbia il metodo compareto L8 Linguaggi prog. II Unina 14

15 La soluzione generic è quella di restringere il tipo T alle classi derivate da un interfaccia Comparable (una interfaccia standard col solo metodo compareto) public static <T extends Comparable> T min(t[] a) L interfaccia Comparable è un tipo generico essa stessa. L8 Linguaggi prog. II Unina 15

16 Tipi ristretti Sintassi generica <T extends BoundingType> BoundingType può essere una classe o una interfaccia E possibile richiedere restrizioni multiple T extends Comparable & Serializable (al più una può essere una classe che deve trovarsi però al primo posto) ES L8 Linguaggi prog. II Unina 16

17 JVM e generics LA JVM non gestisce i tipi generici, ma solo classi ordinarie. In presenza di un generic il compilatore rimuove la parametrizzazione (come prima di JAVA5), ed in fase di compilazione effettua automaticamente il casting Il meccanismo del type reference può fallire anche in presenza di una soluzione, oppure puo' fornire la soluzione errata (non è corretto né L8 Linguaggi prog. II Unina 17 completo)

18 Implementazione dei generics e type inference I generics sono implementati con un meccanismo di riscrittura del codice (raw type e type erasure) da parte del compilatore. Il risultato è quello di ottenere delle classi ordinarie. Nella definizione ai tipi generici vengono sostituiti, a tempo di compilazione con i tipi raw, che corrisponde al tipo ristretto se presente, o al tipo object. ESEMPIO Pair L8 Linguaggi prog. II Unina 18

19 public class Pair { public Pair(Object first, Object second) { this.first = first; this.second = second; } public Object getfirst() { return first; } public Object getsecond() { return second; } public void setfirst(object newvalue) { first = newvalue; } public void setsecond(object newvalue) { second = newvalue; } private Object first; private Object second; } L8 Linguaggi prog. II Unina 19

20 Invocazione dei generics Nelle istruzioni di invocazioni dei metodi generici, il compilatore inserisce automaticamente istruzioni di cast in corrispondenza del tipo. Pair<Employee> staff2 =...; Employee employee1 = (employee)staff2.getfirst(); L8 Linguaggi prog. II Unina 20

21 Implementazione metodi generici: conseguenze ESEMPIO INTERVALLO DI DATE class DateInterval extends Pair<Date> { public void setsecond(date second) { if (second.compareto(getfirst()) >= 0) super.setsecond(second); }... } L8 Linguaggi prog. II Unina 21

22 Implementazione dei metodi generici public static <T extends Comparable> T min(t[] a) RAW TYPE public static Comparable min(comparable[] a) Bridge method In alcuni casi la cancellazione del tipo generico ha come conseguenza la creazione di metodi bridge ES L8 Linguaggi prog. II Unina 22

23 class DateInterval extends Pair<Date> { public void setsecond(date second) { if (second.compareto(getfirst()) >= 0) super.setsecond(second); }... } Si richiede ovviamente che la seconda data sia maggiore della prima La cancellazione trasforma la classe DateInterval a: class DateInterval extends Pair // after erasure { public void setsecond(date second) {... }... } Ovviamente esiste anche il metodo setsecond derivato da pair public void setsecond(object newvalue) { second = newvalue; } L8 Linguaggi prog. II Unina 23

24 Cosa accade nella sequenza di istruzioni? DateInterval interval = new DateInterval(...); Pair<Date> pair = interval; // OK--assignment to superclass pair.setsecond(adate); Il compilatore crea automaticamente un bridge method per prevenire le conseguenze del type erasure sui metodi overridden public void setsecond(object second) { setsecond((date) second); } L8 Linguaggi prog. II Unina 24

25 Generic: restrizioni nei tipi Ci sono alcune restrizione nell uso dei generics, dovute principalmente ai problemi di cancellazione TIPI PRIMITIVI Non si possono usare i tipi primitivi in una variabile di tipo: NO pair<double>, MA pair<double> La ragione è la type erasure. La classe pair,dopo la cancellazione del tipo, ha tipo riferimento Object, e non puo ospitare tipi primitivi (in questo caso double). L8 Linguaggi prog. II Unina 25

26 Operatore istanceof (a instanceof Pair<String>) <-> (a instanceof Pair ) Nella JVM il confronto avviene tramite il riferimento non tipato if (a instanceof Pair<T>) T viene ignorato Cast Pair<String> p = (Pair<String>) a; Nel caso di cast il compilatore emette un WARNING can only test that a is a Pair che ricorda che che il cast non include il tipo parametrico, ma solo il raw type. Allo stesso modo il metodo getclass restituisce il tipo raw Pair<String> stringpair =...; Pair<Employee> employeepair =...; if (stringpair.getclass() == employeepair.getclass()) // UGUALI! L8 Linguaggi prog. II Unina 26

27 Eccezioni Non si possono sollevare eccezione ne catturare eccezioni di una generic class, ne avere eccezioni parametriche. public class Problem<T> extends Exception { /* */} ERROR--can't extend Throwable Non si possono usare le variabili di tipo una clausola catch. public static <T extends Throwable> void dowork(class<t> t) { try { do work } catch (T e) // ERROR--can't catch type variable { Logger.global.info(...) } } L8 Linguaggi prog. II Unina 27

28 Si può usare una variabile di tipo che però estende Trowable public static <T extends Throwable> void dowork(t t) throws T /* OK! */ { try { do work } } catch (Throwable realcause) { t.initcause(realcause); throw t; } L8 Linguaggi prog. II Unina 28

29 Array Non si possono dichiarare array di tipi parametrizzati Pair<String>[] table = new Pair<String>(10); // ERRORE Dopo la type erasure, il tipo di table è Pair[], che ovviamente è convertibile in Object[] Object[] objarray = table; Per creare associazioni di tipi parametrizzati si può usare la collection ArrayList: ArrayList<Pair<String>> L8 Linguaggi prog. II Unina 29

30 Istanziare i tipi generici I tipi generici non possono essere istanziati Pair<T> constructor -> public Pair() { first = new T(); second = new T(); } // ERROR La Type erasure cambierebbe T in Object, l errore previene questo meccanismo public <T> T[] minmax(t[] a) { T[] mm = new T[2];... } // ERROR Si costruirebbe così un array di Object Gli oggetti generici possono essere creati con il meccanismo della riflessione (Class.newInstance Array.newInstance). L8 Linguaggi prog. II Unina 30

31 Metodi Static di classi parametriche Non si possono riferire variabili di tipo in metodi statici public class Singleton<T> { public static T getsingleinstance() // ERROR } { if (singleinstance == null) construct new instance of T return singleinstance; } private static T singleinstance; // ERROR Se fosse possibile, si avrebbe un pattern Singleton universale, da istanziare secondo le esigenze (es Singleton<Random> per condividere un generatore di numeri casuali). Con la type erasure si averbbe però solo la classe Singleton, ed un solo membro singleinstance. L8 Linguaggi prog. II Unina 31

32 Conflitti da cancellazione tipi generici La type erasure può introdurre dei conflitti public class ClassP<T> extends ClassNoP { public int method(t value) { }... } Se la classe ClassNoP ha anche essa un method(object o), avremmo int method(string) // da ClassP<T> int method(object) // ereditata da ClassNoP Mentre La type erasure del metodo parametrico int method(t) produce il metodo int method(object) Rimedi: rinominare il method oppure assicurare l'ovveride con la dichiarazione public class ClassP<T> extends ClassNoP <T> L8 Linguaggi prog. II Unina 32

33 Le specifiche di Java sui generics riportano la seguente regola: "To support translation by erasure, we impose the restriction that a class or type variable may not at the same time be a subtype of two interface types which are different parameterizations of the same interface." In questo modo è illegale il costrutto: class Calendar implements Comparable<Calendar> {...} class GregorianCalendar extends Calendar implements Comparable<GregorianCalendar> {...} // ERROR La versione non parametrica è invece legale class Employee implements Comparable {... } class Manager extends Employee implements Comparable {... } L8 Linguaggi prog. II Unina 33

34 Regole di ereditarietà per tipi generici L uso delle classi parametriche non tiene in conto le relazioni che ci possono essere tra le classi istanziate al posto delle variabili di tipo Non c e alcuna relazione tra pair<s> e pair<t> qualunque sia la relazione che c e tra S e T. E una restrizione necessaria per la corretta utilizzazione dei tipi. Con un esempio si può facilmente capire il perché di questa restrizione L8 Linguaggi prog. II Unina 34

35 Il fatto che per i tipi parametrici non valgono le relazioni di sottotipo, porta dei vantaggi pratici nella scrittura dei programmi Esempio Manager[] ma = new Manager[2]; Employee[] ea = ma; //== ok Manager[] è sottotipo di //==Employee[] ea[0] = new Employee(...); //== eccezione a run time! ArrayStoreException L8 Linguaggi prog. II Unina 35

36 Uso dei generics Pair<Manager> managerbuddies = new Pair<Manager>(ceo, cfo); Pair<Employee> employeebuddies = managerbuddies; // NON è possibile, non valgono le relazioni di sottotipo! employeebuddies.setfirst(lowlyemployee); Si ha un errore di compilazione molto più facile da scoprire e correggere L8 Linguaggi prog. II Unina 36

37 Per garantire il funzionamento del codice esistente, si può sempre convertire un tipo parametrico nel tipo raw Esempio Pair<Manager> managerbuddies= new Pair<Manager>(ceo,cfo); Pair rawbuddies = managerbuddies; // OK rawbuddies.setfirst(new String("???")); Si otterrebbe pero' solo un warning a compile time! L8 Linguaggi prog. II Unina 37

38 Le classi generiche possono estendere altre generiche classi, proprio come le classi ordinarie; per esempio la classe ArrayList<T> implementa la interfaccia List<T>. Cosi' un ArrayList<Manager> puo' essere convertita in List<Manager>, mentre non è possibile ArrayList<Manager> ArrayList<Employee> ne List<Employee>. L8 Linguaggi prog. II Unina 38

39 I tipi jolly (wildcard) Per facilitare l applicazione dei generics alle classi che hanno relazione di ereditarietà sono stati introdotti i tipo JOLLY (wildcard) Le limitazioni di tipo vengono adoperate per lo più con i parametri di tipo JOLLY Pair<? extends C> Identifica qualsia classe con tipo generico che eredita da C L8 Linguaggi prog. II Unina 39

40 Esempio Pair<? extends Employee> denota ogni Pair parametrica il cui parametro è una sottoclasse di Employee (es manager), ma non di tipi che non sono in relazione di ereditarietà (come Pair<String>). L8 Linguaggi prog. II Unina 40

41 Consideriamo ad esempio un metodo che stampa una coppia di impiegati public static void printpairemp(pair<employee> p) { Employee first = p.getfirst(); Employee second = p.getsecond(); System.out.println(first.getName() + " e " second.getname()+ "sono una coppia di impiegati."; } L8 Linguaggi prog. II Unina 41

42 IL metodo non è utilizzabile per una coppia di manager a meno che non usare un wildcard type : public static void printpairemp( Pair<? extends Employee> p) Il tipo Pair<Manager> è un sottotipo di Pair<? extends Employee> L8 Linguaggi prog. II Unina 42

43 Riprendiamo l'esempio Pair<Manager> managerbuddies = new Pair<Manager>(ceo,cfo); Pair<? extends Employee> wildcardbuddies = managerbuddies; // ORA è POSSIBILE wildcardbuddies.setfirst(lowlyemployee); // compile-time error (Type error)!!! ES Il compilatore si rifiuta di passare il tipo wildcard come un tipo specifico per prevenire malfuzionamenti. In effetti Pair<? extends Employee> non è convertibile in un tipo specifico. La seconda assegnazione è invece lecita I tipo wildcard permettono di distingure tra l'accesso sicuro ai sotto tipi, ed i modificatori di tipo non sicuri. L8 Linguaggi prog. II Unina 43

44 Parametri Jolly con restrizioni di sotto tipo L8 Linguaggi prog. II Unina 44

45 Parametri jolly con restrizioni di super tipo <? super Manager> Questo parametro jolly è ristretto a tutte le super classi di manager (es Employee, o Person o Object) Motivazione principale: gestire i tipi restituiti dai metodi generici Pair<? super Manager> ha i metodi void set(? super Manager)? super Manager get() In questo modo si introducono dei limiti inferiori di tipi parametrici L8 Linguaggi prog. II Unina 45

46 Il compilatore non conosce il tipo esatto da passare al metodo set, ma può invocarlo in effetti con qualsiasi oggetto cui Manager può essere convertito All'inverso, non c'e' certezza di quale sia il tipo restituito, se non Object Esempio: Supponiamo di avere un array di Manager e di voler costruire una coppia con i manager rispettivamente col bonus più alto e quello più basso, per avere una idea del range dei bonus. L8 Linguaggi prog. II Unina 46

47 public static void minmaxbonus(manager[] a, Pair<? super Manager> result) { if (a == null a.length == 0) return; Manager min = a[0]; Manager max = a[0]; for (int i = 1; i < a.length; i++) { if (min.getbonus() > a[i].getbonus()) min = a[i]; if (max.getbonus() < a[i].getbonus()) max = a[i]; } result.setfirst(min); result.setsecond(max); } L8 Linguaggi prog. II Unina 47

48 L8 Linguaggi prog. II Unina 48

49 Da un punto di vista intuitivo, i tipi JOLLY con limitazioni di super classe consentono di restituire un oggetto generico, i tipi JOLLY con restrizioni di sottoclasse consentono di leggere da qualsiasi oggetto. Blooch (effective java) parla di PECS Product Extends Consumer Super <? extends T> <? super T> Quando gli oggetti parametrici si usano come prodotti delle collezioni, delle classi parametri, va usata la restrizione di supertipo (le collezioni, le classi parametriche producono gli oggetti). Quando invece il codice la classe parametrico, il metodo parametrico si comporta da consumer (utilizza), allora bisogna assicurare gli il tipo parametrico sia castabile al super tipo

50 Ritornando all'esempio precedente Se vogliamo applicare il metodo printemploypair definito per una coppia di impiegati public static void printpairemp(pair<employee> p) ad una coppia di manager dobbiamo dichiarare il metodo public static void printpairemp(pair<? extends Employee> p) proprio per l'invarianza dei tipi parametrici, perché Pair<Manager> non è sottotipo di Pair<Employee>, ma è sottotipo di Pair<? Extends Employee>. L'estensione? extends Manager è una specifica classe di un tipo che estende Manager, che non è nota nel contesto della compilazione ma che può essere castata a Manager in lettura

51 Nell'esempio di restrizione di sotto tipo public static void minmaxbonus(manager[] a, Pair<? super Employee> result)? super Manager è una specifica classe che è super Tipo di Manager, quindi puo' ospitare tipi manager (in scrittura, o quando il tipo è trattato come consumer). Si puo' ovviamente riscrivere il metodo come public static void minmaxbonus(manager[] a, Pair<? super Employee> result) e passarli una coppia di Employee, quando pero' i manager vengono inseriti nella coppia vengono promossi impiegati, e si perde informazione sui bonus. Se il codice si comporta sia come producer che come consumer le estensioni di super tipo e sotto tipo non sono utilizzabili. Più che come quantificatori di classi, le restrizione di super e sotto tipo vanno interpretati in funzione del loro utilizzo

52 Restrizione di sottotipo/super tipo Un altro uso della restrizione di super tipo si ha con l'interfaccia Comparable, che è di tipo generico public interface Comparable<T> { public int compareto(t other); } Per esempio String implementa Comparable<String>, con il metodo compareto public int compareto(string other) Prima di Java 5, other era un oggetto Object, e si doveva ricorrere ad un cast nell'implementazione. L8 Linguaggi prog. II Unina 52

53 Applicazioni ad array Esempio il minimo universale di array di tipi che estandono l'interfaccia Comparable public static <T extends Comparable<T>> T min(t[] a) Potrebbe essere utile a calcolare il minimo di un array di String T sarebbe il tipo String e String sottotipo di Comparable<String>. L8 Linguaggi prog. II Unina 53

54 E' applicabile ad un array di date, per esempio GregorianCalendar? GregorianCalendar è una sottoclasse di Calendar che implementa Comparable<Calendar>. GregorianCalendar implementa Comparable<Calendar> MA NON Comparable<GregorianCalendar>. In una situazione come questa ci viene d'aiuto la restrizione di super tipo: public static <T extends Comparable<? super T>> T min(t[] a) In questo modo il metodo è effettivamente applicabile L8 Linguaggi prog. II Unina 54

55 Differenze tra <? extends T> e <? super T> Il primo dice un qualiasi tipo che deriva da T, (limite superiore), ovvero un tipo che puo' essere castato a T E rappresenta la famiglia di tutti i tipi che sono sottotipi di T (T incluso) il secondo un qualsiasi tipo da cui deriva T, e rappresenta la famiglia di tutti i tipi Che sono super tipo di T (limite inferiore), ovvero cui T puo' essere castato (T incluso).

56

57 Tipi JOLLY senza restrizioni Si possono usare i tipi JOLLY anche senza restrizioni, es. Pair<?>, che non è la classe Pair RAW, ma possiede i metodi? getfirst() void setfirst(?) Il valore restituito da getfirst può essere solo assegnato ad un Object. setfirst invece non può proprio essere invocato, neanche con Object, ma solo con null. Questa è la principale differenza col Pair row type L8 Linguaggi prog. II Unina 57

58 A cosa serve allora il tipo? senza restrizioni? Si puo' usare quando non si deve utilizzare il tipo attuale, ma solo il tipo null public static boolean hasnulls(pair<?> p) { return p.getfirst() == null p.getsecond() == null; } L8 Linguaggi prog. II Unina 58

59 Il parametro di tipo jolly intuitivamente rappresenta un tipo sconosciuto. Es due liste dello stesso tipo public static <T> void addall(list<t> l1, List<T> l2) {... } due liste qualsiasi public static void addall(list<?> l1, List<?> l2) {... } L8 Linguaggi prog. II Unina 59

60 Wildcard capture Consideriamo di volere scrivere un metodo per scambiare gli elementi di una coppia E' POSSIBILE USARE UN WILDCARD?: public static void swap(pair<?> p) Una wildcard non è una variabilie di tipo, quindi non si può usare un codice come:? t = p.getfirst(); // ERROR p.setfirst(p.getsecond()); p.setsecond(t); L8 Linguaggi prog. II Unina 60

61 Soluzione Costruire un metodo helper public static <T> void swaphelper(pair<t> p) { T t = p.getfirst(); p.setfirst(p.getsecond()); p.setsecond(t); } swaphelper è un metodo generico, mentre swap non lo è (ha un parametro di tipo Pair<?>). Si può invocare saphelper da swap: public static void swap(pair<?> p) { swaphelper(p); } In questo caso il parametro T cattura la wildcard. In generale il meccanismo della wildcard capture può essere usato solo quando alla wildcard corrisponde un tipo attuale ben definito. L8 Linguaggi prog. II Unina 61