1

Generics, Type Safety, and Dynamic Data

Structures

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

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?)

4

Today’s Recitation

• Collections• Java generics

– Parameterized classes and methods– Compiler provides type safety

• Syntax and semantics – Examples

• Generics Examples

5

Collections

• Collection– Serves as a repository for other objects

• Array, LinkedList, etc.

• Java Collections Framework– Provides a unified interface for working

with collections

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

…

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

8

Queues

• Java provides a Queue interface– FIFO data structure

• As a linked list• As an array

– Methodsboolean offer(E o) // insert element to end of queueE peek() // retreive front element of queueE element() // same as peek, but with exceptionsE poll() // remove and return front element of queueE remove() // same as poll, but with exceptions

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;

public Node(Object data, Node next) {

this.data = data;this.next = next;

}

public void setNext(Node next) {

this.next = next;}

public void setData(Objectdata) {

this.data = data;}

public Node getNext() {return next;

}

public Object getData() {return data;

}}

10

Java Generics: Key Idea

• Parameterize type definitions– Parameterized classes and methods

• Provide type safety– Compiler performs type checking– Prevent runtime cast errors

11

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

Cast Exceptions at Runtime

12

public class IntBox {Integer data;public IntBox( Integer data ) {this.data = data;

}public Integer getData() {return data;

}}

public class StrBox {String data;public StrBox( String data ) {this.data = data;

}public String 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 FooBox {Foo data;public FooBox( Foo data ) {this.data = data;

}public Foo getData() {return data;

}}

Infinite many classes possible

Naïve Solution

13

Parameterized Classespublic 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

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 tocompile time errors

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

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” );

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

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() );

}}

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 );//Legalnew MathBox<Double>( 32.1 );//Legalnew MathBox<String>( “No good!” );//Illegal

20

Parameterized MethodsConsider 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 voidmain( String[] args ) {Foo foo = new Foo();int k = foo.aMethod( 5 );String s = foo.aMethod( "abc" );

}}

Fix foo and vary parameter to aMethod() ‏

public class Bar<T> {//Bar is parameterized

public T aMethod( T x ) {return x;

}public static voidmain( String[] args ) {Bar<Integer> bar =

new Bar<Integer>();int k = bar.aMethod( 5 );String s = bar.aMethod( "abc" );//Compilation error here

}}

Once Bar<T> object is fixed, we are locked to a specific T.

21

Generics Examples

• Stack• HashMap• List

22

Stack Using GenericsWithout 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();

23

Collections ExampleHashMap<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>

24

List Using GenericsList<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();

25

Quiz

• Given the following class signature, what type of objects can the parameterized type T support?

public class Quiz<T extends Comparable<T>> {…}