Outline. 1 Generic Classes. 2 Generics and Subtyping. Generics. Guy Wiener. Generic Classes. Generics and Subtyping

Transcription

1 Outline 1 2

2 Outline 1 2

3 (Parametric) classes are classes that have Parameters A generic class with a concrete type parameter is an instance of the generic class The type parameter can be the type of variables, parameters or return values.

4 in Java 1 Declaring a generic interface or class: interface List<T> { public void add(t t) { class ArrayList<T> implements List<T> { private T[] _data;... 1 The Israeli connection: The person who introduced generics to Java was Dr. Gilad Bracha, a former BGU student

5 in Java (cont d) Creating instances of generics: List<String> names = new ArrayList<String>(); and Concrete types The parametrized type, e.g List Concrete A generic type with a concrete parameter, e.g List<String> Concrete types, in Java, are just for type safety. Only generic types are compiled to.class files.

6 Methods Methods can have a type parameters as well The type parameter of a method must be the type of one of the arguments or the type of the return value The concrete type parameter is deducted by the static type of the actual argument

7 Methods in Java A generic method: public <R, T> R foo(t t) {... An instance of foo: String f = foo(5); R String T Integer

8 Galore A concrete type parameter can be an instance of a generic class as well List<Set<Integer>> Map<String, Set<String>> List<List<Stack<Integer>>> Don t be shy to use generics Don t over-do it as well

9 Outline 1 2

10 Reminder: Sub-s and Assignments Sub-Typing defines the class relation B is a sub-type of A, marked B A. According to the substitution principle, if B A, then an instance of B can substitute an instance of A. Therefore, it is legal to assign an instance of B b to a reference of A a: a b.

11 Does the rules for sub-types and assignment works for generics? If B A, then G B G A? Counter example List<String> ls = new LinkedList<String>(); List<Object> lo = ls; Since String Object, so far so good. lo.add(new Object()); String s = ls.get(0); // Error! The rule B A G B G A defies the principle of substitution!

12 A More Concise Example Some generic code class B extends A {... class G<E> { public E e; G<B> gb = new G<B>(); G<A> ga = gb; ga.e = new A(); B b = gb.e; // Error! Supposedly, because B A, then G B B A, and therefore the assignment: G<A> ga = gb is legal. Actually, it erases the type of G.e. B A does not imply G B G A

13 Reading and Writing Permissions The sub-type relation defines which types can read from or write to which other types. If X Y then X is readable by Y : y x If X Y then X is writable to Y : x y To ensure generic type safety we need to be able to specify unknown types as sub-types of reading (left-hand) side, or super-types of the writing (right-hand) side.

14 Java defines? to be the Unknown. 2 For a generic type G<E>, the type instance G<?> is the super-type of all other type instances. The fine print Variables of the unknown type cannot be assigned to, and are considered as Object when reading from. public void foo(g<?> g) { Object o = g.e; // Allowed g.e = new Object(); // Not allowed 2 Also called Wildcard.

15 Printing a Collection How to print an entire collection? Bad example void print(collection<object> c) { for(object e: c) { System.out.println(e); Won t work, because Collection<Object> is not the super-type of all collections!

16 Printing a Collection (cont d) How to print an entire collection? Good example void print(collection<?> c) { for(object e: c) { System.out.println(e); Will work, because Collection<?> is the super-type of all collections.

17 A wildcard alone does not allow to do a lot. In order to have a more specific read or write access, Java allows to specify bounds on the wildcard. The ancestor of the unknown type, marked G<? extends X>. Allows to read an instance of the unknown type. The descendant of the unknown type, marked G<? super Y>. Allows to write to an instance of the unknown type.

18 Concise Example More generic code G<A> ga = new G<A>(); G<B> gb = new G<B>(); G<? extends A> gea = gb; // Can read from A a = gea.e; G<? super B> gsb = ga; // Can write to gsb.e = new B(); Because B A and? A, then? B, the assignment G<? extends A> gea = gb is legal. Similarly, A B and? B, then? A, and the assignment G<? extends B> gsb = ga is legal.

19 Rules of For any B such that B A (including B = A), then: G<? extends A> can get as value G<B> G<? super B> can get as value G<A> Java does not support comparing two unknown types.

20 Example Shapes Given this class hierarchy of shapes: Shape* draw()* Circle+ draw()+ Box+ draw()+ Figure: Shapes

21 Example Shapes (cont d) Here is how to draw a collection of shapes: Drawing shapes public void drawall( Collection<? extends Shape> shapes) { for (Shape s: shapes) { s.draw(); Since Collection<Shape> will not work, Collection<? extends Shape> solves the problem.

22 Example - Flushing Consider this generic code: Sink interface interface sink<t> { flush(t t); Flushing method public <T> T flushall( Collection<T> col, Sink<T> sink) { T last; for (T t: col) { last = t; sink.flush(t); return last;

23 Example Flushing (cont d) Will this code work? Using flushing Collection<String> strings; Sink<Object> sink_obj; String str = flushall(strings, sink_obj); // Error! The last assignment is illegal, because Sink<Object> is not a super-type of Sink<String>, so the generic parameter T cannot be resolved.

24 Example Flushing (cont d) Second attempt: Flushing <T> T flushall( Collection<? extends T> col, Sink<T> sink) { String str = flushall(strings, sink_obj); // Error! T is now solvable as Object, but that is not the correct return type Should be String.

25 Example Flushing (cont d) Using a lower bound instead of an upper bound: Flushing <T> T flushall( Collection<T> col, Sink<? super T> sink) { String str = flushall(stings, sink_obj); Now T is resolved to String, as desired.