Generics, Type Safety, and Dynamic Data Structures

Transcription

1 Generics, Type Safety, and Dynamic Data Structures 1

2 Reminders No classes, labs, recitations next week (gobble gobble) Consulting hours Monday only Project 8 (the final one!) is out start early Milestone due 11/28 Final project due 12/5 Armand's Discussion section Cancelled next week 2

3 Project 7 Design Use object oriented design! Load method should handle much of the labyrinth processing to make rest of methods easier char[][] and String[] insufficient still need to process structure of labyrinth later on in every other method (ouch!) Organize information in classes Labyrinth classes (pros/cons?) Cell classes (pros/cons?) Wall classes (pros/cons?) 3

4 Today s Recitation Collections Java generics Parameterized classes and methods Compiler provides type safety Syntax and semantics Examples Generics Examples 4

5 Collections Collection Serves as a repository for other objects Array, LinkedList, etc. Java Collections Framework Provides a unified interface for working with collections 5

6 Java Collections Framework Interfaces List Most basic collection Set No Duplicates SortedSet No Duplicates Sorted order Map Key, value pairs SortedMap Key, value pairs Sorted Order Implementations ArrayList An expandable array Vector An expandable array Stack FILO TreeMap A Map Sorted 6

7 Collection Design: Keep collections general so that they can hold any type of object Java 5.0 provides generics Allows type of collection to be established upon instantiation 7

8 Queues Java provides a Queue interface FIFO data structure As a linked list As an array Methods boolean offer(e o) E peek() E element() E poll() E remove() // insert element to end of queue // retreive front element of queue // same as peek, but with exceptions // remove and return front element of queue // same as poll, but with exceptions 8

9 Building Your Own List Node class Item Next pointer Type unsafe Class Object supports any class type Should use parameterized type! public class Node { private Object data; private Node next; next) { { data) { public Node(Object data, Node this.data = data; this.next = next; public void setnext(node next) this.next = next; public void setdata(object this.data = data; public Node getnext() { return next; public Object getdata() { return data; 9

10 Java Generics: Key Idea Parameterize type definitions Parameterized classes and methods Provide type safety Compiler performs type checking Prevent runtime cast errors 10

11 Cast Exceptions at Runtime public class OldBox { Object data; public OldBox( Object data ) { this.data = data; public Object getdata() { return data; OldBox intbox = new OldBox( 42 ); int x = (Integer) intbox.getdata(); OldBox strbox = new OldBox( Hi ); String s = (String) strbox.getdata(); int y = (Integer) strbox.getdata(); intbox = strbox; ClassCastException! Compiles but fails at runtime 11

12 Naïve Solution public class IntBox { Integer data; public IntBox( Integer data ) { this.data = data; public Integer getdata() { return data; IntBox intbox = new IntBox( 42 ); int x = intbox.getdata(); StrBox strbox = new StrBox( Hi ); String s = strbox.getdata(); int y = (Integer) strbox.getdata(); intbox = strbox; Errors caught by compiler public class StrBox { String data; public StrBox( String data ) { this.data = data; public String getdata() { return data; public class FooBox { Foo data; public FooBox( Foo data ) { this.data = data; public Foo getdata() { return data; Infinite many classes possible 12

13 Parameterized Classes public class OldBox { Object data; public OldBox( Object data ) { this.data = data; public Object getdata() { return data; We want the box to hold a specific class abstractly represented Object does not work as we have seen earlier Solution parameterize the class definition public class Box<E> { E data; public Box( E data ) { this.data = data; public E getdata() { return data; E refers to a particular type The constructor takes an object of type E, not any object To use this class, E must be replaced with a specific class 13

14 How to Use Parameterized Classes public class Box<E> { E data; public Box( E data ) { this.data = data; public E getdata() { return data; Box<Integer> intbox = new Box<Integer>( 42 ); int x = intbox.getdata();//no cast needed Box<String> strbox = new Box<String>( Hi ); String s = strbox.getdata();//no cast needed Following lines will not compile anymore: String s = (String) intbox.getdata(); int y = (Integer) strbox.getdata(); intbox = strbox; Runtime errors now converted to compile time errors 14

15 When to Use Parameterized Classes Particularly useful for container classes Containers hold but do not process data All collections framework classes in Java 5.0 defined using generics See the Java 5.0 API documentation 15

16 Parameterized Classes: Syntax A class can have multiple parameters, e.g: public class Stuff<A,B,C> { Subclassing parameterized classes allowed, e.g: /* Extending a particular type */ class IntBox extends Box<Integer> { Or /* Extending a parameterized type */ class SpecialBox<E> extends Box<E> { SpecialBox<String> is a subclass of Box<String>. /* Following assignment is legal */ Box<String> sb = new SpecialBox<String>( Hi ); 16

17 Parameterized Classes in Methods A parameterized class is a type just like any other class. It can be used in method input types and return types, e.g: Box<String> amethod( int i, Box<Integer> b ) { If a class is parameterized, that type parameter can be used for any type declaration in that class, e.g: public class Box<E> { E data; public Box( E data ) { this.data = data; public E getdata() { return data; public void copyfrom( Box<E> b ) { this.data = b.getdata(); //We have added an infinite number of types of Boxes //by writing a single class definition 17

18 Bounded Parameterized Types Sometimes we want restricted parameterization of classes. We want a box, called MathBox that holds only Number objects. We can t use Box<E> because E could be anything. We want E to be a subclass of Number. public class MathBox<E extends Number> extends Box<Number> { public MathBox( E data ) { super( data ); public double sqrt() { return Math.sqrt( getdata().doublevalue() ); 18

19 Bounded Parameterized Types (. Contd ) public class MathBox<E extends Number> extends Box<Number> { public MathBox( E data ) { super( data ); public double sqrt() { return Math.sqrt( getdata().doublevalue() ); The <E extends Number> syntax means that the type parameter of MathBox must be a subclass of the Number class. We say that the type parameter is bounded. new MathBox<Integer>( 5 );//Legal new MathBox<Double>( 32.1 );//Legal new MathBox<String>( No good! );//Illegal 19

20 Parameterized Methods Consider the following class: public class Foo { //Foo is not parameterized public <T> T amethod( T x ) { //will not compile without <T> //to indicate that this is a //parameterized method. return x; public static void main( String[] args ) { Foo foo = new Foo(); int k = foo.amethod( 5 ); String s = foo.amethod( "abc" ); public class Bar<T> { //Bar is parameterized public T amethod( T x ) { return x; public static void main( String[] args ) { Bar<Integer> bar = new Bar<Integer>(); int k = bar.amethod( 5 ); String s = bar.amethod( "abc" ); //Compilation error here Fix foo and vary parameter to () amethod Once Bar<T> object is fixed, we are locked to a specific T. 20

21 Generics Examples Stack HashMap List 21

22 Stack Using Generics Without Generics class Stack { void push( Object o ) {... Object pop() { String s = "Hello"; Stack st = new Stack();... st.push( s );... s = (String) st.pop(); With Generics class Stack<A> { void push( A a ) {... A pop() { String s = "Hello"; Stack<String> st = new Stack<String>(); st.push( s );... s = st.pop(); 22

23 Collections Example HashMap<Intger, String> sumnerfavfive = new HashMap<Intger, String>(); sumnerfavfive.put(1, Magic Labyrinths ); sumnerfavfive.put(2, Happy Dogs ); sumnerfavfive.put(3, Blue Beanies ); sumnerfavfive.put(4, Huzzah! ); sumnerfavfive.put(5, CS180 Students ); String SumnerFavorite = sumnerfavfive.get(1); Note: Hashmap_1.4 hm => Hashmap_1.5<Object, Object> 23

24 List Using Generics List<String> ys = new LinkedList<String>(); ys.add( "zero" ); List<List<String>> yss; yss = new LinkedList<List<String>>(); yss.add( ys ); String y = yss.iterator().next().iterator().next(); // Compile-time error much better! Integer z = ys.iterator().next(); 24

25 Quiz Given the following class signature, what type of objects can the parameterized type T support? public class Quiz<T extends Comparable<T>> { 25