Download presentation
Presentation is loading. Please wait.
Published bySharleen Chapman Modified over 9 years ago
1
Generic(Parameterized ) types Mehdi Einali Advanced Programming in Java 1
2
2 Agenda Why Generics Generic Methods Generic Classes Type Erasure Generics and Inheritance Generics and Wild Cards Restrictions on Generics
3
3 Why generics
4
4
5
5 Stack interfaces interface StringStack{ void push(String s); String pop(); } interface IntegerStack{ void push(Integer s); Integer pop(); } interface StudentStack{...
6
6 Sort Method static void sort(Integer[] array) { //... } static void sort(Double[] array) { //... } static void sort(String[] array) { //... } static void sort(Student[] array){ //... }
7
7 The Problem What is wrong with these examples? Code redundancy No effective code reuse Solution? Using Object class Pros and Cons? Compile-time type safety
8
8 Most of time Common properties and controls required But software is not just execution of code developers is very important Annotations: @Deprecated, @Override, @Author We need some type check just for compile time(for humans not computers) Compile time vs runtime time
9
9 The Solution Generic types and methods Methods with similar implementation which accepts parameters for impose some restriction on them Generics provides abstraction over Types (Parameterized Types)
10
10 Generic stack Stack stack=new Stack (); Stack.push(new Havij()); Stack stack=new Stack (); Stack.push(new Golabi());
11
11 Why generics? To enable a compiler to as much as error as it can at compile time rather than getting surprised at run time(ClassCastException) Extended code reusability Improve readability and robustness Try to find bugs ASAP!!
12
12 Generic classes
13
13 Type parameter as the Return Type interface Stack { void push(T s); T pop(); } Stack stringStack = new... stringStack.push(“salam”); String s = stringStack.pop();
14
14 public class Stack { private E[] elements ; private final int size; // number of elements in the stack private int top; // location of the top element public void push(E pushValue) { if (top == size - 1) // if stack is full throw new FullStackException(); elements[++top] = pushValue; } public E pop() { if (top == -1) // if stack is empty throw new EmptyStackException(); return elements[top--]; } public Stack() { size = 10; top = -1; elements = new Object[size]; }
15
15 Using Stack Class Stack stack1 = new Stack (); stack1.push("first"); stack1.push("second"); System.out.println(stack1.pop()); Stack stack2 = new Stack (); stack2.push(1); stack2.push(2); System.out.println(stack2.pop());
16
16 Compile-time Type Checking Stack stack1 = new Stack (); stack1.push(new Integer(2)); Compile-time error
17
17 public class Stack { private E[] elements ; private final int size; // number of elements in the stack private int top; // location of the top element public void push(E pushValue) { if (top == size - 1) // if stack is full throw new FullStackException(); elements[++top] = pushValue; } public E pop() { if (top == -1) // if stack is empty throw new EmptyStackException(); return elements[top--]; } public Stack() { size = 10; top = -1; elements = new Student[size]; }
18
18 Generic methods
19
19 Generic Methods Declaring a method which accepts different parameter types For each method invocation, the compiler searches the appropriate method If the compiler does not find a method, it looks for a compatible generic method Type Parameter It says: In this method, E is not a regular type, it is a generic one
20
20 printArray() Generic Method
21
21 Benefits of Generics public static void printArray( E[] inputArray ){…} Restricting possible types Compile-time type checking printArray(stringArray) brings Compiler Error or exception?
22
22 You can specify generic type for methods too.
23
23 Type erasure
24
24 Raw Types Generic classes and methods can be used without type parameter Stack s = new Stack (); String as type parameter s.push(“salam”); s.push(new Integer(12)); Compiler Error Stack objectStack = new Stack(); no type parameter s.push(“salam”); s.push(new Integer(12)); s.push(new Student(“Ali Alavi”));
25
25 No Generics in Runtime Generics is a compile-time aspect In runtime, there is no generic information All generic classes and methods are translated with raw types Byte code has no information about generics Only raw types in byte code This mechanism is named generic type erasure
26
26 Erasure When the compiler translates generic method into Java bytecodes It removes the type parameter section It replaces the type parameters with actual types. This process is known as erasure
27
27 Erasure Example (1) class Stack { void push(T s){...} T pop() {...} } Is translated to class Stack { void push(Object s){...} Object pop() {...} }
28
28 Erasure Example (2) Translated to
29
29 What Happens if…
30
30 Some Notes We can also create generic interfaces interface Stack { void push(T s); T pop(); }
31
31 What Happens if… public static void f(E i){ } public static void f(Number i){ } Compiler Error : Method f(Number) has the same erasure version f(Number) as another method in this type
32
32 Multiple Type Parameters class MultipleType { private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } public void doSomthing(K k, T t){…} } MultipleType multiple = new MultipleType (); multiple.doSomthing(5, "123");
33
33 Inheritance and generics
34
34 Generics and subtypes You can do this Object o = new Integer(5); You can even do this Object[] or = new Integer[5]; So you would expect to be able to do this ArrayList ao = new ArrayList (); This is counter-intuitive at the first glance
35
35 Why? So there is no inheritance relationship between type arguments of a generic class
36
36 This works Inheritance relationship between generic classes themselves still exists
37
37 Still works Entries in a collection maintain inheritance relationship
38
38 Generics and Inheritance A non-generic class can be inherited by a non- generic class As we saw before learning generics A generic class can be inherited from a non-generic class Adding generality to classes A non-generic class can be inherited from a generic class Removing generality A generic class can be inherited by a generic class
39
39 class GenericList extends Object{ public void add(T t){...} public T get(int i) {...} public void remove(int i) {...} } class GenericNumericList extends GenericList { } class NonZeroIntegerList extends GenericList { public void add(Integer t) { if(t==null || t==0) throw new RuntimeException(“Bad value"); super.add(t); }
40
40 Generics and Wild card
41
41 Why Wildcards? Problem Consider the problem of writing a routine that prints out all the elements in a collection What is wrong with this?
42
42 Why Wildcards? Solution Use Wildcard type argument Collection means Collection of unknown type
43
43 Bounded wild character If you want to bound the unknown type to be a subtype of another type, use bounded Wildcard
44
44 Restrictions on generic types
45
45 Not primitive type Cannot Instantiate Generic Types with Primitive Types
46
46 Not insatiate Cannot Create Instances of Type Parameters
47
47 Not static Cannot Declare Static Fields Whose Types are Type Parameters Confusing code:
48
48 No cast no instaneof Cannot Use Casts or instanceof with Parameterized Types The runtime does not keep track of type parameters, so it cannot tell the difference between an ArrayList and an ArrayList.
49
49 Arrays of Parameterized Types You cannot create arrays of parameterized type
50
50 Generics and Java 7 Older versions: ArrayList list = new ArrayList (); With Java 7: ArrayList list = new ArrayList<>(); Type information after new are ignored. List >> list = new ArrayList<>();
51
51 end
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.