Scribd
Upload
91 views

Generic Programming

This document discusses generic programming in Java. It introduces generics as a way to write reusable code for objects of different types. Generics allow type-safe operations and eliminate casting. The key points are: 1. Generic classes use type parameters like ArrayList<String> to ensure type safety at compile time rather than runtime. 2. Generic methods also use type parameters to make methods reusable for different data types. 3. Type parameters can have bounds to restrict them to subclasses or interfaces. 4. Wildcard types like Pair<? extends Employee> allow working with unknown types while maintaining type safety. They are used for input and output types.

Uploaded by

STUTI Dikshit
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
91 views

Generic Programming

This document discusses generic programming in Java. It introduces generics as a way to write reusable code for objects of different types. Generics allow type-safe operations and eliminate casting. The key points are: 1. Generic classes use type parameters like ArrayList<String> to ensure type safety at compile time rather than runtime. 2. Generic methods also use type parameters to make methods reusable for different data types. 3. Type parameters can have bounds to restrict them to subclasses or interfaces. 4. Wildcard types like Pair<? extends Employee> allow working with unknown types while maintaining type safety. They are used for input and output types.

Uploaded by

STUTI Dikshit
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 15

GENERIC

PROGRAMMING
INTRODUCTION
 Generic programming means writing code that can be
reused for object of many different types
 Added to the JDK from version 5.0
 It tooks 5 years to be formalized (from 1999)
 First added to support strongly typed collections (as in C++)

 No generic code is obscure and not typesafe


// Before generic classes
ArrayList files = new ArrayList();
// You do not know which kind of object are store inside the list
String filename = (String) files.get(0);

 Before generics there was no typesafe checking


 Errors will be find only at runtime

 Violation of FAIL FAST principle

2
INTRODUCTION
 Generics solution: type parameters
 The compiler can perform typesafe checks
// After generic classes
ArrayList<String> files = new ArrayList<>();
// You do not need the cast operation anymore
String filename = files.get(0);

 Generics make the code safer and easier to read


 But how will you use generic programming?
 Basic level: just use generic classes
 Intermediate level: when you encounter your
first
enigmatic error using generic classes
 Advanced level: implement your own generic
3
classes
GENERIC CLASSES
A class with one or more type variable
 Type variable are introduced after class name,
enclosed by angle brackets < >
Type variables are used throughout the class
class definition
Pair<T, U>
{ private T
first; private U
second;
// ...
}
 It is common to use upper case letters for type variables
 A type variables is instantiated by substituting types
 Generic classes act as a factory for ordinary classes
Pair<Integer, String> pair = new Pair<>();
Integer first = pair.getFirst();
String second = pair.getSecond();

4
Type Parameters
• The type parameters naming conventions are important to learn
generics thoroughly. The common type parameters are as follows:
• T - Type
• E - Element
• K - Key
• N - Number
• V - Value
GENERIC METHODS
 Also single methods can be defined as generics
 Type variable definition stands behind
method’s return type
public static <T> T getMiddle(T... a) { /* ... */ }
String middle = getMiddle("Riccardo", "Cardin", "Professor");

 Can be placed inside both generic an ordinary classes


 You can omit the type variable instantiation
 But sometimes the compiler gets it wrong...
double middle = ArrayAlg.getMiddle(3.14, 1729, 0);

 Which type is inferred by the compiler? Number!!!


 In C++, type parameters are after method name
 This can lead to ambiguites

6
TYPE VARIABLES
BOUNDS
 Rescrictionof a type variable to a class that is a
subtype of an another type
class ArrayAlg {
public static <T extends Comparable> T min(T[] a) {
if (a == null || a.length == 0) return null;
T smallest = a[0];
for (int i = 1; i < a.length; i++)
// We know for sure that compareTo is
available
if (smallest.compareTo(a[i]) > 0)
smallest = a[i];
return smallest;
}

} Use extends keyword both for classes and
interfaces
 It is possibile
T extends to &use
Comparable multiple bounds
Serializable
 At most one bound can be a class
7
RESTRICTIONS AND
LIMITATIONS
 Type Parameters Cannot Be Instantiated with
Primitive Types
 Runtime Type Inquiry Only Works with Raw Types
 You Cannot Create Arrays of Parameterized Types
 Varargs Warnings...
 You Cannot Instantiate Type Variables
 Type Variables Are Not Valid in Static Contexts of Generic
Classes
 You Cannot Throw or Catch Instances of a Generic Class
 Beware of Clashes after Erasure

13
GENERICS AND
INHERITANCE
 Generics and inheritance works togheter in an
unintuitive way
 In general, there is no relationship between
Pair<S>
and Pair<T>, no matter how S and T are related
 Necessary for type safety

 Generics are said invariant


// Type safety restriction
Pair<Manager> managerBuddies =
new Pair<>(ceo, cfo);
// Illegal, but suppose it
// wasn't
Pair<Employee> employeeBuddies
=
managerBuddies;
employeeBuddies.setFirst(
lowlyEmployee);
14
GENERICS AND
INHERITANCE
 Unfortunately there is a way to bypass this type
safety controls
Pair<Manager> managerBuddies = new Pair<>(ceo, cfo);
Pair rawBuddies = managerBuddies; // OK
// Only a compile-time warning. A ClassCastException
// is thrown at runtime
rawBuddies.setFirst(new File(". . ."));

 But, this is the same behaviour we obtain using older


version of Java (≤ 1.5)
 NEVER use raw type of generics if you can
 Generic classes can extend or implement other
generic types
 For example, ArrayList<T> implements List<T>
 So, an ArrayList<Manager> is subtype of
List<Manager>
15
WILDCARD
TYPES
 Thetype system derived is too rigid: wildcard
types help to safetly relax some constraint
// Any generic Pair whose type parameter is a subclass of Employee
Pair<? extends Employee>

 Why using wildcard types can we force type safety?


 The compiler cannot guess the real type the object passed
Pair<Manager> managerBuddies = new Pair<>(ceo, cfo);
Pair<? extends Employee> wildcardBuddies = managerBuddies; // OK
wildcardBuddies.setFirst(lowlyEmployee); // compile-time error

 Use wildcard type as return types in methods


In return types the compiler needs only to know which is the
supertype, to allow assignments
 Type ? extends T is said covariant wrt type T

16
WILDCARD
TYPES

17
WILDCARD
TYPES
 How can we use wildcard type for parameters?
 In Java are available supertype bounds
// Any generic Pair whose type parameter is restricted to all
// supertypes of Manager
Pair<? super Manager>

 A wildcard with a super type bound gives you a behavior that


is opposite to that of the wildcards
 You can supply parameters to methods, but you
can’t use the return values
// Any generic Pair whose type parameter is restricted to all
// supertypes of Manager
Pair<? super Manager>
 As a return values the only possible assignee type is Object
 Type ? super T is said contravariant wrt type T

18
WILDCARD
TYPES

19
WILDCARD TYPES
 You can even use wildcards with no bounds
 As a return value, can only be assigned to an Object
 As a parameter, no type matches, not even Object
 A method with a parameter with an unbounded wildcard type can never be called
 Actually, you can call it passing a null reference...

 Remember, an unbounded wildcard is not a type


 So you can not use it when a type is requested

// It is different from the raw type Pair


Pair<?>

// This code is not valid, use type variables instead


? t = p.getFirst(); // ERROR
p.setFirst(p.getSecond());
p.setSecond(t);

20

You might also like