Amity School of Engineering & Technology (CSE)
Java Generics
Generics Amity School of Engineering & Technology (CSE)
• Java Generics allows us to create a single class,
interface, and method that can be used with different
types of data (objects).
• Generics does not work with primitive types (int, float,
char, etc).
Amity School of Engineering & Technology (CSE)
What is a Generic Class?
• A generic class is a class that can operate on objects of
various types while providing compile-time type safety.
Amity School of Engineering & Technology (CSE)
Defining a Generic Class
class ClassName<T> {
// Class body
}
Amity School of Engineering & Technology (CSE)
Single type parameter
class Solution<T>
{
T data;
public static T getData(){
return data;
}
}
Amity School of Engineering & Technology (CSE)
Generic Class Example
class Box<T> {
private T content;
public void setContent(T content) { this.content =
content;
}
public T getContent()
{ return content;
}
}
Amity School of Engineering & Technology (CSE)
Multiple type parameters
public class Pair<K, V> {
private K key;
private V value;
public Pair(K key, V value) {
this.key = key;
this.value = value;
}
public K getKey() { return key; }
public V getValue() { return value; }
}
Amity School of Engineering & Technology (CSE)
Creating Instances of a Generic Class
GenericClass<Integer> intObj = new GenericClass<>();
GenericClass<String> strObj = new GenericClass<>();
Amity School of Engineering & Technology (CSE)
Generic Method Example
class DemoClass {
// create a generics method
public <T> void genericsMethod(T data) {
System.out.println("Generics Method:");
System.out.println("Data Passed: " + data);
}
}
Contd… Amity School of Engineering & Technology (CSE)
class Main {
public static void main(String[] args) {
// initialize the class with Integer data
DemoClass demo = new DemoClass();
// generics method working with String
demo.<String>genericsMethod("Java Programming");
// generics method working with integer
demo.<Integer>genericsMethod(25);
}
}
Example Amity School of Engineering & Technology (CSE)
class GenericMethodExample {
public static <T> void printArray(T[] array) {
for (T item : array) {
System.out.print(item + " ");
}
System.out.println();
}
}
Contd… Amity School of Engineering & Technology (CSE)
public class Main {
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] strArray = {"A", "B", "C"};
GenericMethodExample.printArray(intArray);
GenericMethodExample.printArray(strArray);
}
}
Amity School of Engineering & Technology (CSE)
Advantages of Java Generics
• Code Reusability: we can write code that will work with different
types of data
• Type-Safety: One can hold only a single type of objects in
generics.
• Type Casting Is Not Required: There is no need to typecast.
• Compile -Time Checking: It checks all the errors of datatype
related to generics at the time of compile-time so the issue will
not occur at the time of runtime.
Amity School of Engineering & Technology (CSE)
Bounded Type Parameters: Example
class Calculator<T1 extends Number>{
T1 num1;
T1 num2;
T1 sum(T1 num1,T1 num2){
return (T1) (Double.valueOf(num1.doubleValue()+num2.doubleValue()));
}
}
public class Main {
public static void main(String[] args) {
Calculator <Integer> obj=new Calculator<>();
System.out.println(obj.sum(10,20));
}
}
Amity School of Engineering & Technology (CSE)
Wildcards (?) in Generics
• Wildcards (?) are useful when we want to allow unknown
types.
• Types of Wildcards
– Unbounded Wildcard (<?>)Allows any type.
• Can only read elements but cannot add new elements (except null).
• Useful when the type does not matter.
– Upper Bounded Wildcard (<? extends T>)
• Restricts types to T or subclasses of T.
– Lower Bounded Wildcard (<? super T>)
• Restricts types to T or superclasses of T.
Amity School of Engineering & Technology (CSE)
Unbounded Wildcard (<?>) Example
import java.util.List;
class WildcardExample {
public static void printList(List<?> list) {
for (Object obj : list) {
System.out.print(obj + " ");
}
System.out.println();
}
}
Contd… Amity School of Engineering & Technology (CSE)
import java.util.List;
class WildcardExample {
public static void printList(List<?> list) {
for (Object obj : list) {
System.out.print(obj + " ");
}
System.out.println();
}
}
Amity School of Engineering & Technology (CSE)
Why can't we add elements?
• Since we don't know the exact type (<?> could be
Integer, String, or anything else), adding an element is
unsafe.
Amity School of Engineering & Technology (CSE)
Upper Bounded Wildcard (<? extends T>)
• restricts type to T or its subclasses.
• Used when we need to read elements but not modify
them.
• <? extends Number>
– This means the type can be Number or any subclass of
Number (Integer, Double, Float, etc.).
Example Amity School of Engineering & Technology (CSE)
public static void printNumbers(List<? extends Number>
list) {
for (Number num : list) {
System.out.println(num);
}
}
Contd… Amity School of Engineering & Technology (CSE)
List<Integer> intList = Arrays.asList(10, 20, 30);
List<Double> doubleList = Arrays.asList(1.1, 2.2, 3.3);
printNumbers(intList);
printNumbers(doubleList);
Amity School of Engineering & Technology (CSE)
Why can't we add elements?
• The list might be List<Integer> or List<Double>, but
Java doesn't know for sure. So adding a specific type
(Integer or Double) is unsafe.
Amity School of Engineering & Technology (CSE)
Lower Bounded Wildcard (<? super T>)
• Restricts type to T or its superclasses.
• Used when we need to write (add elements) but don't
need to read specific types.
• <? super Integer>
– This means the type can be Integer or any superclass of
Integer (Number, Object, etc.).
Example Amity School of Engineering & Technology (CSE)
public static void addNumbers(List<? super Integer> list)
{
list.add(100); // Allowed
list.add(200);
}
Contd… Amity School of Engineering & Technology (CSE)
List<Integer> intList = new ArrayList<>();
List<Number> numList = new ArrayList<>();
addNumbers(intList);
addNumbers(numList);
Amity School of Engineering & Technology (CSE)
• Integer num = list.get(0); // Compilation Error!
• Object obj = list.get(0); // Allowed
– Since list might hold Integer, Number, or Object, it is only
safe to retrieve elements as Object.
Amity School of Engineering & Technology (CSE)
When to Use Each Wildcard?
• Use <?> when you just need to iterate over a list but
don’t modify it.
• Use <? extends T> when you need to read elements as
T but don’t modify.
• Use <? super T> when you need to add elements of
type T.
Amity School of Engineering & Technology (CSE)
Generic Interfaces
interface GenericInterface<T> {
void display(T data);
}
class GenericClassImpl<T> implements GenericInterface<T> {
public void display(T data) {
System.out.println("Data: " + data);
}
}
Contd… Amity School of Engineering & Technology (CSE)
public class Main {
public static void main(String[] args) {
GenericClassImpl<Integer> intObj = new GenericClassImpl<>();
intObj.display(100);
GenericClassImpl<String> strObj = new GenericClassImpl<>();
strObj.display("Hello Generics");
}
}
Restrictions Amity School of Engineering & Technology (CSE)
• Cannot Instantiate Generic Types with Primitive Types:
• Cannot Create Instances of Type Parameters:
Contd… Amity School of Engineering & Technology (CSE)
• Cannot Declare Static Fields Whose Types are Type
Parameters:
• Cannot Create Arrays of Parameterized Types:
Exercise Amity School of Engineering & Technology (CSE)
Define a generic class Box<T>, where T is a placeholder
for a data type. The class should have: A private field to
store the item of type T. A constructor to initialize the
item. Getter and setter methods. A method display() to
print the item. In the main method: Create a
Box<Integer> and store a number. Create a Box<String>
and store a string. Display their values.
Amity School of Engineering & Technology (CSE)
• Write a generic method to swap two elements in an
array. Create a generic method swap() that: Takes an
array and two indices. Swaps the elements at those
indices. In the main method: Test the method with an
Integer array. Test the method with a String array.
