Generics. L9 Linguaggi Progr.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. L9 Linguaggi Progr.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; L9 Linguaggi Progr.II Unina 3

4 In questo modo pero 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! L9 Linguaggi Progr.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 L9 Linguaggi Progr.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 L9 Linguaggi Progr.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; L9 Linguaggi Progr.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 L9 Linguaggi Progr.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) { L9 Linguaggi Progr.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 L9 Linguaggi Progr.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'agoritmo type inference è in grado di determinare come tipo più specifico String. L9 Linguaggi Progr.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 L9 Linguaggi Progr.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) { In questo esempio A utilizza come tipo parametrico oltre che T, anche un parametro ti tipo U L9 Linguaggi Progr.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 L9 Linguaggi Progr.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. L9 Linguaggi Progr.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 L9 Linguaggi Progr.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é L9 Linguaggi Progr.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 L9 Linguaggi Progr.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; L9 Linguaggi Progr.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(); L9 Linguaggi Progr.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);... L9 Linguaggi Progr.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 L9 Linguaggi Progr.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; L9 Linguaggi Progr.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 per conservare la peculiarità del metodo della classe che estende la classe parametrica, dopo la type erasure. Il metodo Bridge con il cast assicura che in ovverriden venga invocato il metodo della sottoclasse public void setsecond(object second) { this.setsecond((date) second); L9 Linguaggi Progr.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 può ospitare tipi primitivi (in questo caso double). L9 Linguaggi Progr.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! L9 Linguaggi Progr.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(...) L9 Linguaggi Progr.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; L9 Linguaggi Progr.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>> L9 Linguaggi Progr.II Unina 29

30 Istanziare i tipi genenirici 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). L9 Linguaggi Progr.II Unina 30

31 Metodi Statici 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 avrebbe però solo la classe Singleton, ed un solo membro singleinstance. L9 Linguaggi Progr.II Unina 31

32 La Conflitti type erasure da può cancellazione introdurre dei conflitti tipi generici 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> L9 Linguaggi Progr.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 {... L9 Linguaggi Progr.II Unina 33