Java Generics

📦 Java Generics

Generics in Java allow you to write classes, interfaces, and methods that can operate on any type of objects while providing compile-time type safety.

Introduced in Java 5
Helps avoid ClassCastException
Widely used in Collections Framework

1. Why Use Generics?

Type Safety: Detect type errors at compile time
Code Reusability: One class/method works with multiple types
Eliminate Type Casting: Reduces runtime casting

2. Generic Class Example

// Generic class
class Box<T> { // T is a type parameter
private T content;

public void setContent(T content) {
this.content = content;
}

public T getContent() {
return content;
}
}

public class GenericClassExample {
public static void main(String[] args) {
Box<Integer> intBox = new Box<>();
intBox.setContent(123);
System.out.println("Integer Box: " + intBox.getContent());

Box<String> strBox = new Box<>();
strBox.setContent("Hello Generics");
System.out.println("String Box: " + strBox.getContent());
}
}

// Generic class

class Box<T> { // T is a type parameter

private T content;

public void setContent(T content) {

this.content = content;

}

public T getContent() {

return content;

}

public class GenericClassExample {

public static void main(String[] args) {

Box<Integer> intBox = new Box<>();

intBox.setContent(123);

System.out.println("Integer Box: " + intBox.getContent());

Box<String> strBox = new Box<>();

strBox.setContent("Hello Generics");

System.out.println("String Box: " + strBox.getContent());

}

<T> is a type parameter.
Can replace T with any reference type (Integer, String, custom classes).

3. Generic Method Example

public class GenericMethodExample {
// Generic method
public static <T> void printArray(T[] array) {
for (T element : array) {
System.out.print(element + " ");
}
System.out.println();
}public static void main(String[] args) {
Integer[] intArray = {1, 2, 3};
String[] strArray = {"A", "B", "C"};

printArray(intArray); // Works with Integer
printArray(strArray); // Works with String
}
}

public class GenericMethodExample {

// Generic method

public static <T> void printArray(T[] array) {

for (T element : array) {

System.out.print(element + " ");

}

System.out.println();

}public static void main(String[] args) {

Integer[] intArray = {1, 2, 3};

String[] strArray = {"A", "B", "C"};

printArray(intArray); // Works with Integer

printArray(strArray); // Works with String

}

<T> before return type declares a generic method.
Can be used with arrays, collections, or any objects.

4. Generic Interface Example

interface Container<T> {
void add(T item);
T get();
}class ItemContainer<T> implements Container<T> {
private T item;

public void add(T item) {
this.item = item;
}

public T get() {
return item;
}
}

public class GenericInterfaceExample {
public static void main(String[] args) {
Container<String> container = new ItemContainer<>();
container.add("Generics are powerful!");
System.out.println(container.get());
}
}

interface Container<T> {

void add(T item);

T get();

}class ItemContainer<T> implements Container<T> {

private T item;

public void add(T item) {

this.item = item;

}

public T get() {

return item;

}

public class GenericInterfaceExample {

public static void main(String[] args) {

Container<String> container = new ItemContainer<>();

container.add("Generics are powerful!");

System.out.println(container.get());

}

Interfaces can also be generic.

5. Bounded Generics

Restrict generic types to subclasses of a specific class.
Syntax: <T extends Number>

class Calculator<T extends Number> {
public double square(T number) {
return number.doubleValue() * number.doubleValue();
}
}public class BoundedGenericExample {
public static void main(String[] args) {
Calculator<Integer> intCalc = new Calculator<>();
System.out.println("Square: " + intCalc.square(5));

Calculator<Double> doubleCalc = new Calculator<>();
System.out.println("Square: " + doubleCalc.square(3.5));
}
}

class Calculator<T extends Number> {

public double square(T number) {

return number.doubleValue() * number.doubleValue();

}

}public class BoundedGenericExample {

public static void main(String[] args) {

Calculator<Integer> intCalc = new Calculator<>();

System.out.println("Square: " + intCalc.square(5));

Calculator<Double> doubleCalc = new Calculator<>();

System.out.println("Square: " + doubleCalc.square(3.5));

}

Ensures only Number types (Integer, Double, Float) can be used.

🔹 6. Wildcards (`?`) in Generics

Represents an unknown type
Useful in method parameters

import java.util.List;

public class WildcardExample {
public static void printList(List<?> list) {
for (Object obj : list) {
System.out.print(obj + " ");
}
System.out.println();
}

public static void main(String[] args) {
List<Integer> intList = List.of(1, 2, 3);
List<String> strList = List.of("A", "B", "C");

printList(intList);
printList(strList);
}
}

import java.util.List;

public class WildcardExample {

public static void printList(List<?> list) {

for (Object obj : list) {

System.out.print(obj + " ");

}

System.out.println();

}

public static void main(String[] args) {

List<Integer> intList = List.of(1, 2, 3);

List<String> strList = List.of("A", "B", "C");

printList(intList);

printList(strList);

}

? extends Number → Upper bounded wildcard
? super Integer → Lower bounded wildcard

🧠 Summary Table

Feature	Description
Generic Class	Class with type parameter `<T>`
Generic Method	Method with type parameter `<T>`
Bounded Type	Restrict type using `extends`
Wildcards	Represent unknown type `?`, `? extends`, `? super`
Collections	Works well with `ArrayList<T>`, `HashMap<K,V>`, etc.

Best Practices

Use Generics for type safety and code reusability.
Avoid using raw types (e.g., ArrayList without <T>).
Use bounded types to restrict operations to compatible types.

Java Generics

📦 Java Generics

1. Why Use Generics?

2. Generic Class Example

3. Generic Method Example

4. Generic Interface Example

5. Bounded Generics

🔹 6. Wildcards (?) in Generics

🧠 Summary Table

Best Practices

You may also like...

Java Constructors

Java Exceptions

Java super Keyword

🔹 6. Wildcards (`?`) in Generics