.. Il linguaggio Java: aggiunte in Java 1.5 Una breve presentazione
GENERICI Java 1.5 introduce i generici: classi che hanno un parametro di tipo. Nelle versioni precedenti a Java 1.5 si può definire: List mialista = new LinkedList(); mialista.add(new(integer(0)); Integer x = (Integer)miaLista.iterator().next(); Gli oggetti List possono contenere oggetti di qualunque tipo, e quindi quando si estrae un oggetto dalla lista è necessario fare il cast.
Nella nuova versione: List<Integer> mialista = new LinkedList<Integer>(); mialista.add(new(integer(0)); Integer x = mialista.iterator().next(); La mialista può contenere solo oggetti Integer. Non è più necessario il cast nell'ultima istruzione: il compilatore sa che l'oggetto estratto è un Integer.
L'interface List è specificata nel package java.util come: public interface List<E> { void add(e x);... Quando si dichiara una variabile di tipo List<Integer>, il parametro formale E viene legato ad Integer. E' come se si usasse una nuova interface: public interface ListofInteger { void add(integer x);...
Esempio In realtà la dichiarazione di un generico come List<Integer> non viene espansa come detto prima, cioè non vengono create copie multiple del codice di List, una per ogni valore del parametro. La dichiarazione di List<E> viene compilata una volta per tutte e genera un solo file class, come qualunque altra dichiarazione di classe o interfaccia.
Esempio public class Pila<T> { private LinkedList<T> list = new LinkedList<T>(); public boolean isempty() {return list.isempty(); public void push(t v) { list.addfirst(v); public T pop() {return list.removefirst(); public static void main(string[] args) { Pila<String> stack = new Pila<String>(); stack.push("a"); stack.push("bcd"); String s1 = stack.pop(); String s2 = stack.pop(); System.out.println(s1); System.out.println(s2);
GENERICI E SOTTOTIPI Con gli array è possibile scrivere: String[] as = new String[5]; Object[] ao = as; ao[0] = new Object(); il compilatore accetta questo programma, ma l'inteprete dà errore a runtime perché non si può assegnare un Object a un array di stringhe. Viceversa in List<String> ls = new ArrayList<String>(); List<Object> lo = ls; lo.add(new Object()); la seconda istruzione non è accettata dal compilatore, perché l'interprete non sarebbe in grado di scoprire l'errore a runtime nella istruzione successiva.
Il comportamento descritto prima è molto restrittivo. Ad esempio, il seguente metodo per stampare gli elementi di una collezione: void printcollection(collection<object> c) { Iterator<Object> i = c.iterator(); for(k=0; k<c.size(); k++) System.out.println(i.next()); può essere usato solo per stampare gli elementi di una Collection<Object>, ma non può avere come parametro, ad esempio, una Collection<Integer>.
Per definire una collection di qualunque cosa si può usare la notazione Collection<?>. void printcollection(collection<?> c) { Iterator<?> i = c.iterator(); for(k=0; k<c.size(); k++) System.out.println(i.next()); Tuttavia, in Collection<?> c = new ArrayList<String>(); c.add(new Object()); il compilatore accetta la prima istruzione, ma non la seconda, perché non può garantire la correttezza del tipo dell'elemento che viene inserito nella collezione.
FOR EACH L'iterazione sulle collezioni mediante un Iterator è abbastanza noiosa da scrivere. JDK 1.5 introduce al suo posto una nuova istruzione for. Invece di: void printcollection(collection<object> c) { Iterator<Object> i = c.iterator(); for(int k=0; k<c.size(); k++) System.out.println(i.next()); si può scrivere: void printcollection(collection<object> c) { for(object e : c) System.out.println(e);
LIMITAZIONI SUL? Consideriamo la classe astratta: public abstract class Forma { public abstract void disegna(); e diverse sue sottoclassi come Cerchio, Rettangolo,... che implementano il metodo disegna. Un metodo per disegnare le forme contenute in una lista potrebbe essere: public void disegnatutto(list<forma> forme) { for (Forma f: forme) f.disegna();
La definizione public void disegnatutto(list<forma> forme) { è restrittiva, perché il metodo disegnatutto può essere applicato solo a una List<Forma> e non, per esempio, a una List<Rettangolo>. D'altra parte public void disegnatutto(list<?> forme) { sarebbe troppo generale perché il? può essere legato a qualunque tipo, in particolare ad Object che non ha il metodo disegna.
Il? può essere limitato con la notazione public void disegnatutto(list<? extends Forma> forme) {// Body del metodo disegnatutto in cui il tipo degli elementi della lista può essere una qualunque sottoclasse di Forma, e quindi certamente avrà il metodo disegna.
AUTO-BOXING Le strutture come Collection possono contenere solo oggetti. Quindi per inserire un tipo primitivo (es. int) occorre convertirlo (boxing) nel corrispondente oggetto (es. Integer). Viceversa, quando si estrae un oggetto dalla collezione occorre riconvertirlo nel tipo primitivo (unboxing). Nella versione 1.5 boxing e unboxing sono fatti automaticamente dal compilatore. ArrayList<Integer> al = new ArrayList<Integer>(); PRIMA DI Java 1.5 IN Java 1.5 al.add(0, new Integer(25)); al.add(0, 25); int x = (al.get(0)).intvalue(); int x = al.get(0);
ESERCIZI (FACOLTATIVI) Riscrivere, usando i nuovi costrutti presenti in Java 1.5, il codice relativo ai seguenti esercizi svolti in laboratorio: E6 E7 E8 E9 E12 F. Damiani - Alg. & Lab. 04/05