comp 212: intermediate programming lecture 18 – java generics
DESCRIPTION
Comp 212: Intermediate Programming Lecture 18 – Java Generics. By: Anupam Chanda. Today’s Lecture. Java generics Parameterized classes and methods Compiler provides type safety Syntax and semantics Examples Generics-based implementation of the list framework – next class. Outline. - PowerPoint PPT PresentationTRANSCRIPT
![Page 1: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/1.jpg)
Comp 212: Intermediate Comp 212: Intermediate ProgrammingProgramming
Lecture 18 – Java GenericsLecture 18 – Java Generics
By: Anupam ChandaBy: Anupam Chanda
![Page 2: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/2.jpg)
22
Today’s LectureToday’s Lecture
Java genericsJava generics Parameterized classes and methodsParameterized classes and methods Compiler provides type safetyCompiler provides type safety
Syntax and semantics Syntax and semantics ExamplesExamples
Generics-based implementation of Generics-based implementation of the list framework – next classthe list framework – next class
![Page 3: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/3.jpg)
33
OutlineOutline
Motivation Parameterized classesParameterized classes Parameterized methodsParameterized methods Upper bounded wildcardsUpper bounded wildcards Lower bounded wildcardsLower bounded wildcards Unbounded wildcardsUnbounded wildcards
![Page 4: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/4.jpg)
44
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 RuntimeCast Exceptions at Runtime
![Page 5: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/5.jpg)
55
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 SolutionNaïve Solution
![Page 6: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/6.jpg)
66
Passing Parameters to Methods: An Passing Parameters to Methods: An AnalogyAnalogy
public abstract class Sum { public static int sum_0_1() { return (0+1); } … public static int sum_15_22() { return (15+22); } …}
public class Main { public static void main(String[] nu) { int j = Sum.sum_0_1(); … int k = Sum.sum_15_22(); }}
Bad – infinite many methods
public abstract class NewSum { public static int sum(int m, int n) { return (m+n); }}
public class NewMain { public static void main(String[] nu) { int j = NewSum.sum(0,1); … int k = NewSum.sum(15,22); }}
Pass parameters to methods
Methods accept parameters
![Page 7: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/7.jpg)
77
Java Generics: Key IdeaJava Generics: Key Idea
Parameterize type definitionsParameterize type definitions Parameterized classes and methodsParameterized classes and methods
Provide type safetyProvide type safety Compiler performs type checkingCompiler performs type checking Prevent runtime cast errorsPrevent runtime cast errors
![Page 8: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/8.jpg)
88
Parameterized ClassesParameterized 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
![Page 9: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/9.jpg)
99
How to Use Parameterized How to Use Parameterized ClassesClasses
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
![Page 10: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/10.jpg)
1010
When to Use Parameterized When to Use Parameterized ClassesClasses
Particularly useful for “container” Particularly useful for “container” classesclasses Containers hold but do not process dataContainers hold but do not process data
All collections framework classes in All collections framework classes in Java 5.0 defined using genericsJava 5.0 defined using generics See the Java 5.0 API documentationSee the Java 5.0 API documentation
![Page 11: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/11.jpg)
1111
Parameterized Classes: Syntax Parameterized Classes: Syntax NoteNote
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”);
![Page 12: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/12.jpg)
1212
Parameterized Classes in Parameterized Classes in MethodsMethods
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
![Page 13: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/13.jpg)
1313
So Far…So Far…
Type safety violationsType safety violations Using castsUsing casts
Parameterized classes solve this problemParameterized classes solve this problem Provide type safetyProvide type safety
Enforced by the compilerEnforced by the compiler Particularly useful for container classesParticularly useful for container classes A parameterized class is another A parameterized class is another typetype Next – bounded parameterized classesNext – bounded parameterized classes
![Page 14: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/14.jpg)
1414
Bounded Parameterized Bounded Parameterized TypesTypes
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()); }}
![Page 15: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/15.jpg)
1515
Bounded Parameterized Types Bounded Parameterized Types (Contd.)(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
![Page 16: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/16.jpg)
1616
Bounded Parameterized Types Bounded Parameterized Types (Contd.)(Contd.)
Inside a parameterized class, the type parameter serves as a valid type.So the following is valid.
public class OuterClass<T> { private class InnerClass<E extends T> { … } …}Syntax note: The <A extends B> syntax is valid even if B is an interface.
![Page 17: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/17.jpg)
1717
Bounded Parameterized Types Bounded Parameterized Types (Contd.)(Contd.)
Java allows multiple inheritance in the form of implementing multiple interfaces. So multiple bounds may be necessary to specify a type parameter. The following syntax is used then:
<T extends A & B & C & …>For instance:
interface A {…}interface B {…}class MultiBounds<T extends A & B> {…}
![Page 18: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/18.jpg)
1818
So Far…So Far…
Parameterized classesParameterized classes Bounded parameterized typesBounded parameterized types
To restrict parameter typesTo restrict parameter types Next – parameterized methodsNext – parameterized methods
![Page 19: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/19.jpg)
1919
Parameterized MethodsParameterized 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 void main(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 void main(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.
![Page 20: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/20.jpg)
2020
Use of Parameterized Use of Parameterized MethodsMethods
Adding type safety to methods that Adding type safety to methods that operate on different typesoperate on different types Return type dependent on input typeReturn type dependent on input type
![Page 21: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/21.jpg)
2121
So Far…So Far…
Parameterized classesParameterized classes Bounded parameterized typesBounded parameterized types Parameterized methodsParameterized methods Next – wildcardsNext – wildcards
BoundedBounded UpperUpper LowerLower
UnboundedUnbounded
![Page 22: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/22.jpg)
2222
Upper Bounded Wildcards in Parameterized Upper Bounded Wildcards in Parameterized TypesTypes
We start to run into some new issues when we do some things that seem “normal”. For instance, the following seems reasonable:Box<Number> numBox = new Box<Integer>(31);Compiler comes back with an “Incompatible Type” error message.This is because numBox can hold only a Number object and nothing else, not even an object of type Integer which is a subclass of Number. The type of numBox we desire is “a Box of any type which extends Number”.
Box<? extends Number> numBox = new Box<Integer>(31);
![Page 23: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/23.jpg)
2323
Upper Bounded Wildcards in Parameterized Upper Bounded Wildcards in Parameterized Types (Contd.)Types (Contd.)
public class Box<E> { public void copyFrom(Box<E> b) { this.data = b.getData(); }}//We have seen this earlier//We can rewrite copyFrom() so that it can take a box //that contains data that is a subclass of E and //store it to a Box<E> object
public class Box<E> { public void copyFrom(Box<? extends E> b) { this.data = b.getData();//b.getData() is a
//subclass of this.data }}
<? extends E> is called “upper bounded wildcard” because it defines a type that is bounded by the superclass E.
![Page 24: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/24.jpg)
2424
Lower Bounded Wildcards in Parameterized Lower Bounded Wildcards in Parameterized TypesTypes
Suppose we want to write copyTo() that copies data in the opposite direction of copyFrom().copyTo() copies data from the host object to the given object.
This can be done as:public void copyTo(Box<E> b) { b.data = this.getData();}
Above code is fine as long as b and the host are boxes of exactly same type.But b could be a box of an object that is a superclass of E.This can be expressed as:public void copyTo(Box<? super E> b) { b.data = this.getData(); //b.data() is a superclass of this.data()}
<? super E> is called a “lower bounded wildcard” because it defines a type that is bounded by the subclass E.
![Page 25: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/25.jpg)
2525
Unbounded WildcardsUnbounded Wildcards
Use unbounded wildcards when any type parameter works.<?> is used to specify unbounded wildcards.
The following are legal statements.Box<?> b1 = new Box<Integer>(31);Box<?> b2 = new Box<String>(“Hi”);b1 = b2;
Wildcard capture:The compiler can figure out exactly what type b1 is above from the right hand side of the assignments.
This “capturing” of type information means:1. The type on the left hand doesn’t need to be specified.2. The compiler can do additional type checks because it knows
the type of b1.
![Page 26: Comp 212: Intermediate Programming Lecture 18 – Java Generics](https://reader036.vdocuments.net/reader036/viewer/2022062304/56812bb5550346895d8ff681/html5/thumbnails/26.jpg)
2626
ConclusionsConclusions
Java genericsJava generics Parameterized classes and methodsParameterized classes and methods Type safetyType safety Syntax and semantics through examplesSyntax and semantics through examples
Links to tutorials on the lecture pageLinks to tutorials on the lecture page Generics-based implementation of Generics-based implementation of
the list framework – next classthe list framework – next class