Generics and Type Safety - Purdue Universityweb.ics.purdue.edu/~cs180/Spring2009Web/lecture... · 2...

Generics and Type Safety

CS 180Sunil PrabhakarDepartment of Computer Science Purdue University

2

Generics Generics are a new feature introduced in Java 5. The main goal of this new feature is to improve program

reliability through increased type safety. Type safety reduces the possibility of incorrect types for

data through compile-time testing and enforcement of correct types.

Although Java is type safe, earlier versions were unable to enforce type safety for generic collections, such as those defined in the Java collections framework (JCF), e.g. List and Map.

Prior to Java 5, these collections were unable to define a homogeneous collection -- they stored any object of any class.

3

Example: List

If we create a list object for storing Student objects, we have no way of ensuring that non-Student objects are not added to this list.

Similarly, we cannot create an ArrayList object in which we can only store objects of a certain class.

This is desirable for improving the reliability of programs and avoiding logical errors.

4

Generic Classes Generic classes (or Generics) provide a solution for this. Before we see how this is achieved, let us get familiar

with the notion of generic classes. Consider the functionality of a bag. Suppose we want to

have a bag class that allows us to store one object of some class. E.g. we would like to have one bag object to store a Book; a

second one to store a Laptop, … One solution is to implement a BookBag and a

LaptopBag class, and any other specific type of bag classes. Each of these would have exactly the same functionality but with

a data member of different types.

5

General class

class Bag{

private Object content;

public Bag(){

store(null) ;

}

public Object retrieve(){

return content;

}

public void store(Object item){

content = item;

}

}

Bag bookBag = new Bag();

Bag laptopBag = new Bag();

Bag l = new Laptop();

Book b = new Book();

bookBag.store(b);

laptopBag.store(b);

5

General class

class Bag{


public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}

Bag bookBag = new Bag();

Bag laptopBag = new Bag();

Bag l = new Laptop();


bookBag.store(b);

laptopBag.store(b);

This does not allow us to enforce the requirement that the bookBag object can only store Book objects, and laptopBag only store Laptop objects.

6

Multiple classes

class BookBag{

private Book content;

public BookBag(){

store(null) ;

}

public Book retrieve(){

return content;

}

public void store(Book item){

content = item;

}

}

class LaptopBag{

private Laptop content;

public LaptopBag(){

store(null);

}

public Laptop retrieve(){

return content;

}

public void store(Laptop item){

content = item;

}

}

Another solution is to implement a BookBag and a LaptopBag class, and any other specific type of bag classes.

Each of these would have exactly the same functionality but with a data member of different types.

7

Generic Bag class

Both alternatives are unsatisfactory. Instead, we can create a generic class

(Java 5 onwards only) that solves both problems.

The generic class takes a Type parameter as part of its definition.

8

Generic classclass Bag<T>{

private T content;

public Bag(){

store(null) ;

}

public T retrieve(){

return content;

}

public void store(T item){

content = item;

}

}

Bag <Book> bookBag = new

Bag <Book> ();

Bag <Laptop> laptopBag = new

Bag <Laptop> ();


Laptop l = new Laptop();

bookBag.store(b);

bookBag.store(l);

l = (Laptop)laptopBag.retrieve();

b = (Book)laptopBag.retrieve();

8


private T content;

public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}


Bag <Book> ();


Bag <Laptop> ();



bookBag.store(b);

bookBag.store(l);



Bag is called a generic (pluggable, parametrized) class.T is called a type parameter

8


private T content;

public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}


Bag <Book> ();


Bag <Laptop> ();



bookBag.store(b);

bookBag.store(l);



Bag is called a generic (pluggable, parametrized) class.T is called a type parameter Will not

compile!

9

Generic classes and objects

Depending upon the type specified for the type parameter when creating an object of the Bag class, the compiler will perform the appropriate type checking. The content of bookBag can only be an object of class

Book (or descendants) The content of laptopBag can only be an object of

class Laptop (or descendants) This is exactly what we wanted

We define only a single class, and We are able to limit the data types for different

instances.

10

Generic classes

It is important to realize that there is only one class called Bag.

bookBag and laptopBag are both of class Bag. Note the class is called Bag, the constructor is Bag(). There are no Bag<T>, or Bag<Book>, …

classes. However, even though they are from the same

class, we cannot use them interchangeably: bookBag = laptopBag;

11

Generic classesBag <Book> bookBag = new Bag <Book> ();

Bag <Laptop> laptopBag = new Bag <Laptop> ();

if(bookBag instanceof Bag)

System.out.println("bookBag is a Bag object");

if(bookBag instanceof Bag<T>)

System.out.println("bookBag is a Bag<T> object");

if(bookBag instanceof Bag<Book>)

System.out.println("bookBag is a Bag<Book> object");

if(bookBag instanceof Bag<Laptop>)

System.out.println("bookBag is a Bag<Laptop> object");

11

Generic classesBag <Book> bookBag = new Bag <Book> ();

Bag <Laptop> laptopBag = new Bag <Laptop> ();

if(bookBag instanceof Bag)

System.out.println("bookBag is a Bag object");

if(bookBag instanceof Bag<T>)

System.out.println("bookBag is a Bag<T> object");

if(bookBag instanceof Bag<Book>)

System.out.println("bookBag is a Bag<Book> object");

if(bookBag instanceof Bag<Laptop>)

System.out.println("bookBag is a Bag<Laptop> object");

Will not compile!

12

Primitive data

A type parameter can only take a class data type. If we want to store primitive data in our Bag, then

we have to convert it to its corresponding wrapper class.

With Java 5 this is trivial due to autoboxing and auto unboxing.

12

Primitive data

A type parameter can only take a class data type. If we want to store primitive data in our Bag, then

we have to convert it to its corresponding wrapper class.

With Java 5 this is trivial due to autoboxing and auto unboxing.

Bag<Integer> intBag = new Bag<Integer>();

int i = 5, j;intBag.store(new Integer(i));intBag.store(i);j = intBag.retrieve();j = intBag.retrieve().intValue();

13

Multiple Type Parameters

We can have multiple type parameters in a generic class.

13

Multiple Type Parameters

We can have multiple type parameters in a generic class.

class DualBag<T1, T2>{

private T1 content1;

private T2 content2;

public DualBag(){

storeFirst(null);

storeSecond(null);

}

public DualBag(T1 item1, T2 item2){

storeFirst(item1);

storeSecond(item2);

}

public T1 retrieveFirst(){

return content1;

}

public T2 retrieveSecond(){

return content2;

}

public void storeFirst(T1 item){

content1 = item;

}

public void storeSecond(T2 item){

content2 = item;

}

}

14

Example

14

ExampleDualBag<Book, Laptop> bigBag = new DualBag<Book, Laptop> ();



bigBag.storeFirst(b);

bigBag.storeSecond(l);

Book b1 = bigBag.retrieveFirst();

Laptop l1 = bigBag.retrieveSecond();

14








b1 = bigBag.retrieveSecond();

14









Will not compile!

14









l1 = bigBag.retrieveFirst();

Will not compile!

15

Example

DualBag<Book, Book> pair =

new DualBag<Book, Book> ();

Book b1 = new Book();


parr.storeFirst(b1);

pair.storeSecond(b2);

15

Example







Both parameters can be of the same type.

15

Example








If we want to enforce this then we use only one parameter.

15

Example








class DualBag<T>{

private T content1;

private T content2;

public DualBag(){

storeFirst(null);

storeSecond(null);

}

public DualBag(T item1, T item2){

storeFirst(item1);

storeSecond(item2);

}

public T retrieveFirst(){

return content1;

}

public T retrieveSecond(){

return content2;

}

public void storeFirst(T item){

content1 = item;

}

public void storeSecond(T item){

content2 = item;

}

}

If we want to enforce this then we use only one parameter.

16

Type Safetyclass BagA{


public BagA(){

store(null) ;

}


return content;

}


content = item;

}

}

class BagB<T>{

private T content;

public BagB(){

store(null) ;

}


return content;

}


content = item;

}

}

These two are not the same. Only the generic class offers (compile time) type

safety. The other may lead to runtime errors due to type

mismatches.

17

Type Safety contd.

BagA bookBag = new BagA();

BagA laptopBag = new BagA();



bookBag.store(l);

laptopBag.store(l);

l = (Laptop) bookBag.retrieve();

b = (Book) laptopBag.retrieve();

17

Type Safety contd.





bookBag.store(l);

laptopBag.store(l);



Runtime error!

17

Type Safety contd.





bookBag.store(l);

laptopBag.store(l);



BagB<Book> bookBag = new BagB<Book>();

BagB<Laptop> laptopBag = new BagB<Laptop>();



bookBag.store(l);

laptopBag.store(b);



Runtime error!

17

Type Safety contd.





bookBag.store(l);

laptopBag.store(l);



BagB<Book> bookBag = new BagB<Book>();

BagB<Laptop> laptopBag = new BagB<Laptop>();



bookBag.store(l);

laptopBag.store(b);



Runtime error! Will not compile!

18

Type Safety

Which is better Have the compiler enforce type safety or Allow unsafe expressions and then have a runtime

error? It is far better to catch such errors (which are

likely to be logical errors) at compile time. Thus type safety is desirable.

In addition to better reliability, note that with type safety there is no need for type casting or runtime type checking. This can improve the runtime of programs too.

19

Bounded Types

The current generic version of Bag allows us to create instances to store any type of objects as content.

What if we want to limit the types of objects that can be stored in our Bag?

We can do this by bounding the type parameter.

Consider a Bag class that only allows us to store numeric objects.

20

Bounded Type

class NumBag<T extends Number>{

private T content;

public NumBag(){

store(null) ;

}

public NumBag(T item){

store(item) ;

}


return content;

}


content = item;

}

}

20

Bounded Type


private T content;

public NumBag(){

store(null) ;

}


store(item) ;

}


return content;

}


content = item;

}

}

NumBag <Double> doubleBag = new

NumBag <Double> ();

NumBag <Laptop> laptopBag = new

NumBag <Laptop> ();

NumBag <Number> numBag;

doubleBag.store(new Double(3.0));

numBag.store(new Number(12));

numBag.store(new Integer(12));

numBag = new NumBag<Double>();

20

Bounded Type


private T content;

public NumBag(){

store(null) ;

}


store(item) ;

}


return content;

}


content = item;

}

}


NumBag <Double> ();


NumBag <Laptop> ();






Will not compile!Laptop doesn’t

extend Number

20

Bounded Type


private T content;

public NumBag(){

store(null) ;

}


store(item) ;

}


return content;

}


content = item;

}

}


NumBag <Double> ();


NumBag <Laptop> ();







extend NumberNumber is an abstract class!

20

Bounded Type


private T content;

public NumBag(){

store(null) ;

}


store(item) ;

}


return content;

}


content = item;

}

}


NumBag <Double> ();


NumBag <Laptop> ();







extend NumberNumber is an abstract class!No super-sub relationship!

21

Wildcard types

Suppose we would like to be able to check for equality of the number values stored in different instances of the NumBag class:

NumBag<Double> bag1= new NumBag<Double>(new Double(3.0));NumBag<Integer> bag2 = new NumBag<Integer>(new Integer(3));if(bag1.isSameValue(bag2)) System.out.println(“The values are the same.”);

How should the isSameValue method be written? Note that it may be called on an object such as

bag1 that stores doubles and receive an object such as bag2 that stores integers as a parameter.

22

Wildcard types

22

Wildcard types


private T content;

. . .

public boolean isSameValue(NumBag<T> item){

return this.retrieve().doubleValue() ==

item.retrieve().doubleValue();

}

}

22

NumBag<Double> bag1= new NumBag<Double>(new Double(3.0));NumBag< Integer> bag2 = new NumBag< Integer>(new Integer(3));

if(bag1.isSameValue(bag2)) System.out.println(“The values are the same.”);

Wildcard types


private T content;

. . .

public boolean isSameValue(NumBag<T> item){



}

}

Will not compile!

23

Wildcard types


private T content;

. . .

public boolean isSameValue(NumBag<?> item){



}

}

23

Wildcard types


private T content;

. . .




}

}



23

Wildcard types


private T content;

. . .




}

}

Okay as long as bag2’s content supports the doubleValue() method



24

Limitations of generics

We are not allowed to Create an instance of the type parameter class

within the generic class, or Use type parameters with static data members

or static methods. The reason is that the actual type

corresponding to the type parameter is known only when an object is instantiated.

25

Example


private T content;

private static T classContent;

public NumBag(){

content = new T();

store(content) ;

}

public static T getClassContent(){

return classContent;

}

25

Example


private T content;

private static T classContent;

public NumBag(){

content = new T();

store(content) ;

}

public static T getClassContent(){

return classContent;

}

Will not compile!

26

Java Collections Framework

The JCF provides a large set of very commonly used classes such as ArrayList, Vector, Queue, …

In earlier releases of Java the JCF classes were unable to enforce types strongly.

All JCF classes have been retrofitted in Java 5 to work correctly with generics.

These classes are defined in java.util

27

(Old) JCF Example

import java.util.*;

List bookList = new ArrayList();

booklist.add(new Book(“Wilder”);

booklist.add(new Book(“Nabokov”);

booklist.add(new Book(“William”);

bookList.add(“Shakespeare”);

27

(Old) JCF Example

import java.util.*;






Can add any type of objectto this ArrayList.

27

(Old) JCF Example

import java.util.*;






Iterator itr = bookList.iterator();

while(itr.hasNext()){

Book book = (Book) itr.Next();

System.out.println(book.getAuthor());

}


27

(Old) JCF Example

import java.util.*;






Iterator itr = bookList.iterator();


Book book = (Book) itr.Next();


}


Note the need for typecasting.

28

Generics JCF Example

import java.util.*;

ArrayList<Book> bookList = new ArrayList<Book>();





28


import java.util.*;






Compile error.

28


import java.util.*;






Iterator<Book> itr = bookList.iterator();


Book book = itr.Next();


}

Compile error.

28


import java.util.*;










}

Compile error.

Iterator needs type too.

28


import java.util.*;










}

Compile error.

Iterator needs type too.

No need for typecasting.

29

New for statement

Java 5 has also introduced a new variant of the for loop statement: for-each loop

Eliminates the need for iterator objects for iterating through a collection.

for(Book book : bookList) { System.out.println(book.getAuthor());}

General format: for (<type> <var> : <collection>) <stmt>

Collection must be a JCF class and type must match the type of the collection.

30

for-each Example with ArrayList

ArrayList<Bag<Book>> bookBagList = new ArrayList<Bag<Book>>();

bookBagList.add(new Bag<Book>(new Book(“Qian”)) );

bookBagList.add(new Bag<Book>(new Book(“Achebe”)) );

bookBagList.add(new Bag<Book>(new Book(“Lisa”)) );

for(Bag<Book> bag : bookBagList) {

System.out.println(bag.retrieve().getAuthor());

}

31

for-each Example with arraysint number[] = {1, 3, 4, 5, 6 9};

int sum = 0;

for(int element : number) {

sum += element;

}

int sum = 0;

for (int i = 0; i< number.length; i++){

sum += number[i];

}

31

for-each Example with arraysint number[] = {1, 3, 4, 5, 6 9};

int sum = 0;

for(int element : number) {

sum += element;

}

int sum = 0;

for (int i = 0; i< number.length; i++){

sum += number[i];

}

NOTE: not allowed to change the value of loop variable

of a for-each loop.

32

Non-generic ArrayList example

ArrayList bookList = new ArrayList();

bookList.add(new Book(“Qian”));

bookList.add(new Book(“Achebe”));

bookList.add(new Book(“Lisa”));

for(Object b : bookBagList) {

System.out.println( ( (Book)b ).getAuthor() );

}

33

Generics, Inheritance & Interfaces

It is possible to define a generic subclass of a non-generic class.

It is also possible to define a subclass of a generic class IMPORTANT: in this case the subclass must also be

generic. It is possible for a generic class to implement a

non-generic interface. It is also possible for a class to implement a

generic interface IMPORTANT: in this case the class must also be

generic.

34

Subclass of a generic classclass Bag<T>{

private T content;

public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}

34


private T content;

public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}

class BagSub<T> extends Bag<T>{

private int id;

private static int idCounter = 100;

public BagSub(){

this(null) ;

}

public BagSub(T item){

super();

id = idCounter++;

store(item) ;

}

public int showID(){

return id;

}

}

34


private T content;

public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}

class BagSub<T> extends Bag<T>{

private int id;

private static int idCounter = 100;

public BagSub(){

this(null) ;

}

public BagSub(T item){

super();

id = idCounter++;

store(item) ;

}

public int showID(){

return id;

}

}Can be automatically inserted.

35

Example useBagSub<String> subStr;

BagSub<Integer> subInt;

subStr = new BagSub<String> (“Hello”);

subInt = new BagSub<Integer>( );

System.out.println(subStr.showID() + “: “ + subStr.retrieve());

System.out.println(subInt.showID() + “: “ + subInt.retrieve());

35

Example useBagSub<String> subStr;

BagSub<Integer> subInt;

subStr = new BagSub<String> (“Hello”);

subInt = new BagSub<Integer>( );

System.out.println(subStr.showID() + “: “ + subStr.retrieve());

System.out.println(subInt.showID() + “: “ + subInt.retrieve());

100: Hello101: null

36

Subclass of a generic class

class Bag<T>{

private T content;

public Bag(){

store(null) ;

}


return content;

}


content = item;

}

}

class BagSubTwo<T,O> extends Bag<T>{

private O owner;

public BagSubTwo(){

this(null, null) ;

}

public BagSubTwo(T item, O owner){

super();

store(item);

setOwner(owner);

}

public O getOwner (){

return owner;

}

public void setOwner (O owner){

this. owner = owner;

}

}

37

Implementing a generic interface

interface MyContainer<T>{


}


}

}

class MyTrunk<T> implements MyContainer <T> {

private T content;

public MyTrunk(){

store(null);

}

public T retrieve (){

return content;

}

public void store (T item){

content = item;

}

}

37




}


}

}


private T content;

public MyTrunk(){

store(null);

}


return content;

}


content = item;

}

}

class MyTrunk<T extends Number> implements MyContainer <T> {

}

37




}


}

}


private T content;

public MyTrunk(){

store(null);

}


return content;

}


content = item;

}

}

class MyTrunk<T extends Number> implements MyContainer <T> {

}

class MyStringTrunk implements MyContainer <String> {

}

38


interface MyContainer<T extends Number>{


}


}

}

38




}


}

}

class MyTrunk<T extends Number > implements MyContainer<T> {

public T content;

public MyTrunk(){

store(null);

}


return content;

}


content = item;

}

}

38




}


}

}

class MyTrunk<T extends Number > implements MyContainer<T> {

public T content;

public MyTrunk(){

store(null);

}


return content;

}


content = item;

}

}

Must match the interface

39

Non-generic implementation

It is possible to implement a generic interface in a non-generic class.

This is achieved by providing a specific class for the type parameter in the class definition.

40




}


}

}

class MyTrunk implements MyContainer <String> {

private String content;

public MyTrunk(){

store(null);

}

public String retrieve (){

return content;

}

public void store (String item){

content = item;

}

}

41

Raw Types & Backward Compatibility

All the JCF class have been redefined to be generic classes.

What about earlier programs not written for Java 5 using older JCF classes?

In order to ensure backward compatibility, Java 5 allows a generic class to be created without specifying a type parameter!

Essentially, the compiler assumes that the type is Object -- thus any class can be stored.

If we don’t specify the type, we get a raw type. Raw types do not have the benefit of type safety

and should be avoided.

42

Arrays and generics

Arrays should not be used with generics unless you wish to use raw types.

Instead use the ArrayList or LinkedList class to create a generic array.

In general, do not use raw types with generics.

Their use is only for ensuring backward compatibility in legacy code written before Java 5.

43

Raw Types

Bag bag = new Bag();

bag.store(new Integer(5));

bag.store(“test”);

bag.store(new Book(“Ludlum”));

Bag rawBag = new Bag();

Bag<String> strBag = new Bag<String>;

Bag<Integer> intBag = new Bag<Integer>;

intBag.store(new Integer(5));

rawBag = intBag;

strBag = rawBag;

String str = strBag.retrieve();

43

Raw Types

Bag bag = new Bag();

bag.store(new Integer(5));

bag.store(“test”);

bag.store(new Book(“Ludlum”));

Bag rawBag = new Bag();

Bag<String> strBag = new Bag<String>;

Bag<Integer> intBag = new Bag<Integer>;

intBag.store(new Integer(5));

rawBag = intBag;

strBag = rawBag;

String str = strBag.retrieve();

Dangerous, but allowed!

Limitations of Generics Cannot create a generic class for

Exceptions Anonymous inner classes

classes defined within another class, but with no name.

E.g. as Action Handlers for GUIs Enum types

http://java.sun.com/j2se/1.5.0/docs/guide/language/enums.html

Casting to a generic type generates a warning (“unchecked cast”) cast is to the raw type (with no type

parameter) 44



No Inheritance for Generics

List<Object> is not a super-type of List<Number>

However, List<Number> is a super-type of ArrayList<Number> !!!!This only works if the type parameter is the same.

Note that arrays behave differently: Object[] is a super-type to Number[]

45

Lots of subtleties with Generics

See http://www.AngelikaLanger.com/GenericsFAQ/JavaGenericsFAQ.html for an excellent treatment of generics in Java.

46

http://www.AngelikaLanger.com/GenericsFAQ/JavaGenericsFAQ.html




Generics and Type Safety - Purdue Universityweb.ics.purdue.edu/~cs180/Spring2009Web/lecture... · 2...

Documents

Transcript of Generics and Type Safety - Purdue Universityweb.ics.purdue.edu/~cs180/Spring2009Web/lecture... · 2...