Basics of Java Generics

By: Rajesh P.S.

Generics provide a powerful mechanism for writing type-safe code that can work with various data types without sacrificing flexibility. They eliminate the need for type casting, which can lead to runtime errors, and enhance code readability and maintainability.

Why Use Generics?

Generics in Java enhance code reusability, improve type safety, and enable the creation of generic algorithms. They achieve this by allowing you to define classes, methods, and interfaces that work with various data types without compromising type safety. This eliminates the need for duplicate code and ensures compile-time errors for type mismatches, leading to more robust and flexible Java applications.

Key Concepts:

Type Parameters: Generic classes, methods, and interfaces use placeholders called type parameters, represented by letters like T, U, V, etc. These parameters act as templates that can be filled with specific types when the generic code is used.

Generic Type Declaration

You declare a generic class, method, or interface by specifying the type parameters within angle brackets ( <> ) after the class name, method name, or interface name. For example:

public class Box<T> { private T data; public void setData(T data) { this.data = data; } public T getData() { return data; } }

Generic Type Invocation

When using a generic class, method, or interface, you provide the actual type argument(s) within angle brackets after the name. These arguments replace the type parameters in the generic definition. For example:

Box<Integer> intBox = new Box<>(); intBox.setData(10); int value = intBox.getData(); Box<String> stringBox = new Box<>(); stringBox.setData("Hello"); String message = stringBox.getData();

Generic Collection Framework

The Java Collections Framework extensively utilizes generics. For instance, ArrayList <T> represents an array list that can hold elements of type T. This ensures type safety and eliminates the need for raw types (collections without type parameters).

Generic Methods

Methods can also be generic. They can have their own type parameters independent of the class's type parameters. For example:

public <T> T genericMethod(T[] array) { return array[array.length / 2]; }

Bounded Type Parameters

You can restrict the types that can be used as type arguments by specifying upper bounds. For example:

public class Box<T extends Number> { // Now T must be a subtype of Number }

Wildcards

Wildcards allow more flexibility in using generic types. There are two types of wildcards: ? extends T and ? super T. For example:

public double sum(List<? extends Number> list) { double total = 0; for (Number number : list) { total += number.doubleValue(); } return total; }

Generic Interfaces

Interfaces can also be generic. For example:

public interface List<T> { void add(T item); T get(int index); }

Type Erasure

Java generics use type erasure, meaning the type parameters are removed during compilation and replaced with their upper bounds or Object if no bounds are specified. This is done to maintain backward compatibility with older Java versions. For example:

List<String> strings = new ArrayList<>(); List<Integer> integers = new ArrayList<>(); boolean same = strings.getClass() == integers.getClass(); // true

Generic Classes and Inheritance

Generic classes can extend other generic classes or implement generic interfaces. For example:

public class MyClass<T> implements MyInterface<T> { // Implementation }

Benefits of Generics

Type Safety: Generics enforce type safety at compile time, preventing errors like adding a String to an Integer list.
Code Reusability: Generic code can be reused with different data types, reducing code duplication and maintenance effort.
Readability: Generics make code more readable by explicitly stating the types involved.

Conclusion

Generics in Java enhance type safety and code reusability by enabling the creation of generic algorithms and data structures. They allow developers to write more flexible and robust code while maintaining compile-time type checking.

Next > Static keyword in Java

Related Topics

More Related Topics.....