Tipos genéricos (cont)

Transcrição

1 Tipos genéricos (cont) Bruce Eckel, Thinking in Java, 4th edition, PrenticeHall, New Jersey, cf. Gilad Bracha, Generics in the Java Programming Language a.k.a The Generics Tutorial, Julho de 2004 cf. José Valente de Oliveira 18-1 Aula de substituíção da próxima semana José Valente de Oliveira

2 Sumário Noções chave Definição e utilização de tipos genéricos Hierarquias de subtipos Tipos com limites Especificação UML Métodos genéricos Desenvolvimento de tipos genéricos: O quicksort revisitado Rasura Polimorfismo revisitado jvo@ualg.pt José Valente de Oliveira 18-3 Tipos com limites Limite superior: <? extends T> Aceita T e todos os seus descendentes Ex: se T for Number, aceita também Integer, Float, Double Limite inferior: <? super T> Aceita T e todos os seus ascendentes Ex: se T for Integer, aceita também Number e Object jvo@ualg.pt José Valente de Oliveira

3 Generic type hierachy Desenvolvimento de tipos genéricos José Valente de Oliveira

4 class Point class Point { private int x, y; public Point(int ax, int ay) { class Point { x=ax; private double x, y; y=ay; public Point(double ax, double ay) { x=ax; public int getx() { return x; y=ay; public int gety() { return y; public double getx() { return x; public double dist(point p) { public double gety() { return y; int dx = x p.getx(); int dy = y p.gety(); public double dist(point p) { return Math.sqrt(dx*dx+dy*dy); double dx = x p.getx(); double dy = y p.gety(); return Math.sqrt(dx*dx+dy*dy); O que nós gostaríamos: Point<Integer> pi = new Point<Integer>(1, 2); Point<Double> pd = new Point<Double>(1.3, 2.4); jvo@ualg.pt José Valente de Oliveira

5 class Point como um tipo genérico class Point<T extends Number> { private T x, y; public Point(T ax, T ay) { x=ax; y=ay; public T getx() { return x; public T gety() { return y; public double dist(point p) { T dx = x p.getx(); T dy = y p.gety(); return Math.sqrt(dx*dx+dy*dy); Recalling quicksort jvo@ualg.pt José Valente de Oliveira

6 unchecked ) abstract class Quicksort { private Comparable[] data; /** pré-generics **/ interface Comparable { int compareto(object o); public final void quicksort(comparable[] d) { data = d; quicksort(0, data.length-1); /** quicksort method as the template method */ private final void quicksort(int left, int right) { if (right <= left) return; int i = partition(left, right); quicksort(left, i-1); quicksort(i+1, right); jvo@ualg.pt José Valente de Oliveira O que gostaríamos public class Main { public static void main(string[] args) { List<Fraction> lst = new ArrayList<Fraction>(); lst.add(new Fraction(1, 7)); lst.add(new Fraction(5, 2)); lst.add(new Fraction(1, 2)); GQuicksort<Fraction> qs = new ProbQuickSort<Fraction>(); qs.quicksort(lst); for(fraction f: lst) System.out.println (f); jvo@ualg.pt José Valente de Oliveira

7 O quicksort revisitado public abstract class GQuicksort<T extends Comparable<T>> { private List<T> data; public final void quicksort(list<t> d) { data = d; quicksort(0, data.size()-1); private final void quicksort(int left, int right) { if (right <= left) return; int i = partition(left, right); quicksort(left, i-1); quicksort(i+1, right); jvo@ualg.pt José Valente de Oliveira Anteriormente /** Call this in a subclass for swaping elements i and j */ protected final void exchange(int i, int j) { Comparable tmp = data[i]; data[i] = data[j]; data[j] = tmp; /** Use this in subclasses to compare elements x.compareto(y) answer 0 if x ==y; -1 if x < y; 1 se x>y */ protected final boolean less(int i, int j) { return (data[i].compareto(data[j]) < 0); jvo@ualg.pt José Valente de Oliveira

8 O quicksort revisitado protected final void exchange(int i, int j) { T tmp = data.get(i); data.set(i, data.get(j)); data.set(j, tmp); protected final boolean less(int i, int j) { T di = data.get(i); T dj = data.get(j); return (di.compareto(dj) < 0); jvo@ualg.pt José Valente de Oliveira Antes class ProbQuickSort extends Quicksort protected int partition(int left, int right) { int last=left; int pp = left + (int) (Math.random() * (right-left)); // pivot position exchange(left, pp); for(int i=left+1; i <= right; i++) if (less(i, left)) exchange(i, ++last); exchange(left, last); return last; jvo@ualg.pt José Valente de Oliveira

9 O quicksort revisitado class GProbQuickort<T extends Comparable<T>> extends GQuicksort<T> { protected int partition(int left, int right) { int last=left; int pp = left + (int) (Math.random() * (right-left)); // pivot position exchange(left, pp); for(int i=left+1; i <= right; i++) if (less(i, left)) exchange(i, ++last); exchange(left, last); return last; jvo@ualg.pt José Valente de Oliveira Será que podemos usar esta classe antiga /** a pre-generics version */ class Fraction implements Comparable { private int num, den; // public int compareto (Object o) { // /** pré-generics **/ interface Comparable { int compareto(object o); jvo@ualg.pt José Valente de Oliveira

10 neste cliente? public class Main { public static void main(string[] args) { List<Fraction> lst = new ArrayList<Fraction>(); lst.add(new Fraction(1, 7)); lst.add(new Fraction(5, 2)); lst.add(new Fraction(1, 2)); GQuicksort<Fraction> qs = new ProbQuickSort<Fraction>(); qs.quicksort(lst); for(fraction f: lst) System.out.println (f); jvo@ualg.pt José Valente de Oliveira Vejamos public abstract class GQuicksort<T extends Comparable<T>> { private List<T> data; // protected final boolean less(int i, int j) { T di = data.get(i); T dj = data.get(j); return (di.compareto(dj) < 0); jvo@ualg.pt José Valente de Oliveira

11 Recorda-se que /** pré-generics **/ interface Comparable { int compareto(object o); /** actualmente **/ interface Comparable<T> { int compareto(t t); jvo@ualg.pt José Valente de Oliveira Relembremos /** a pre-generics version */ class Fraction implements Comparable { private int num, den; // public int compareto (Object o) { // jvo@ualg.pt José Valente de Oliveira

12 e se fizermos estas alterações? public abstract class GQuicksort<T extends Comparable<? super T>> { private List<T> data; // class GProbQuickort<T extends Comparable<? super T>> extends GQuicksort<T> { // jvo@ualg.pt José Valente de Oliveira Rasura (Erasure) jvo@ualg.pt José Valente de Oliveira

13 Rasura (erasure) O compilador rasura toda a informação relativa ao parâmetro formal de tipo na classe compilada A classe fonte ArrayList<T> é na classe compilada apenas ArrayList T é na classe compilada: Object, quando se encontra num contexto <T> (Object é a superclasse implícita de T). Number, quando se encontra num contexto <T extends Number>(Number é a superclasse explícita de T). jvo@ualg.pt José Valente de Oliveira Rasura (erasure) 13

14 Rasura (erasure) Rasura (erasure) A rasura faz com que, em tempo de execução, não se possa usar nada que necessite do conhecimento do parâmetro formal. 1. Não é possível usar o parâmetro tipo T para criar objectos nem para criar tabelas. 14

15 Rasura (erasure) José Valente de Oliveira Solução típica José Valente de Oliveira

16 Cliente José Valente de Oliveira Rasura (erasure) 2. Não é possível criar tabelas cujos elementos sejam tipos parametrizados. 16

17 Rasura (erasure) 3. Não é possível usar instanceof para verificar se um objecto é uma instância de um tipo parametrizado. Rasura (erasure) 4. Os casts envolvendo tipos genéricos ou parâmetros formais de tipo são substituídos por casts para as rasuras respectivas. 17

18 Rasura (erasure) 5. Não é possível aceder a membros estáticos de um tipo parametrizado: public class MyCollection<E> implements Collections<E> { //... public static int MAX_SIZE; MyCollection<Integer>.MAX_SIZE; // ERROR! MyCollection.MAX_SIZE; Polimorfismo revisitado jvo@ualg.pt José Valente de Oliveira

19 Polimorfismo revisitado José Valente de Oliveira Polimorfismo ad-hoc coercitivo José Valente de Oliveira

20 Polimorfismo ad-hoc sobrecarga José Valente de Oliveira Polimorfismo universal paramétrico José Valente de Oliveira

21 Polimorfismo universal de inclusão José Valente de Oliveira Check point Qual é o valor lógico escrito no ecrã? List<String> l1 = new ArrayList<String> (); List<Integer> l2 = new ArrayList<Integer> (); System.out.println(l1.getClass() == l2.getclass()); 21

22 Check point Serão válidas as expressões seguintes? List<Integer> l1 = new ArrayList<Integer> (); List<Number> l2 = new ArrayList<Number> (); l2 = l1; l2.add(1); Sumário Noções chave Definição e utilização de tipos genéricos Hierarquias de subtipos Tipos com limites Especificação UML Métodos genéricos O quicksort revisitado Rasura Polimorfismo revisitado jvo@ualg.pt José Valente de Oliveira