Java Generics Tutorial

Introduction

Hello there! Ever wondered how to increase type safety and reduce bugs in your Java code? Well, Java Generics is the answer. This tutorial will guide you through the ins and outs of Java Generics, a feature that allows programmers to write code that is both safe and easy to read. So, buckle up and let’s dive into the world of Java Generics!

Understanding Java Generics

Java Generics is a powerful feature that was introduced in Java 5. It allows types (classes and interfaces) to be parameters when defining classes, interfaces, and methods. Much like the more familiar formal parameters used in method declarations, type parameters provide a way for you to re-use the same code with different inputs. The difference is that the inputs to formal parameters are values, while the inputs to type parameters are types.

Code Example:

// A simple generic class with a type parameter T
public class Box<T> {
    private T t; // T stands for "Type"

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

In this example, T is a type parameter that will be replaced by a real type when an object of Box class is created.

Java Generics Basics

Java Generics might seem daunting at first, but don’t worry, we’ve got you covered. The syntax for generics involves the use of angle brackets <>. When declaring a generic class, interface, or method, you define one or more type variables enclosed within these brackets. For example, class Box<T> {...} defines a generic class named Box, where T is the type variable.

Code Example:

Box<Integer> integerBox = new Box<Integer>();
integerBox.set(new Integer(10));
Integer someInteger = integerBox.get();
System.out.println(someInteger);

In this example, T is replaced with Integer. This way we ensure type safety at compile time.

Working with Java Generic Classes

Creating a generic class in Java is quite straightforward. You simply declare the class with a type parameter in angle brackets. For example, class Box<T> {...}. The type parameter can then be used as a type for fields, return types, and parameters. When using a generic class, you specify an actual type in place of the type parameter. For example, Box<Integer> integerBox = new Box<>();.

Code Example:

Box<String> stringBox = new Box<>();
stringBox.set("Hello World");
String someString = stringBox.get();
System.out.println(someString);

In this example, T is replaced with String. This way we can use the same Box class for different types.

Java Generic Methods

Just like classes, we can also have generic methods in Java. They have a type parameter, declared before the return type of the method. For example, <T> void genericDisplay (T element) {...}. This method can now be called with any type of data.

Code Example:

public <T> void genericDisplay(T element) {
    System.out.println(element.getClass().getName() + " = " + element);
}

In this example, T is a type parameter that represents some unknown type. The method genericDisplay can now be used to display data of any type.

Bounded Type Parameters

Sometimes, we want to limit the types that can be used as type parameters in a parameterized type. For this, we use bounded type parameters. These are listed after the type parameter, followed by the extends keyword and its upper bound. For example, <T extends Number> – this means T can be any class that extends Number or Number itself.

Code Example:

public class Box<T extends Number> {
    private T t;

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }
}

In this example, T is bounded by Number. This means you can use any class that is a subclass of Number as a type argument.

Wildcards in Java Generics

Wildcards in Java Generics represent an unknown type. The wildcard can be used as a type of a parameter, field, or local variable and sometimes as a return type. We can define an upper-bounded wildcard, using the <? extends> syntax, or a lower-bounded wildcard, using the <? super> syntax.

Code Example:

public void processElements(List<? extends Number> elements){
    for(Number n : elements){
        System.out.println(n);
    }
}

In this example, the method processElements can work with lists of any type that extends Number.

Java Generics and Inheritance

Java Generics and Inheritance work together in a unique way. A common question is whether List<Integer> is a subtype of List<Number>. The surprising answer is “no”. In Java, List<Integer> and List<Number> are two distinct types, neither of which is a subtype of the other.

Code Example:

List<Integer> intList = new ArrayList<>();
List<Number> numList = intList;  // A compile-time error

This code will not compile because List<Integer> is not a subtype of List<Number>.

Type Erasure in Java Generics

Type Erasure is a process by which the compiler translates generic expressions into non-generic ones. This is done to maintain backward compatibility with older versions of Java that do not support generics. The compiler replaces all type parameters with their bounds or with Object if the type parameters are unbounded.

Code Example:

public class Node<T> {

    private T data;
    private Node<T> next;

    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() { return this.data; }
}

After type erasure, the Node class becomes:

public class Node {

    private Object data;
    private Node next;

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public Object getData() { return this.data; }
}

As you can see, all references to T have been replaced with Object.

Java Generics Best Practices

When working with Java Generics, it’s important to keep a few best practices in mind. Always use generics for strong type checks at compile time. Avoid using raw types. Always use bounded wildcards to increase API flexibility.

Java Generics Examples

Let’s look at a couple of complete code examples to understand Java Generics better.

Example 1: A Generic Class and Method

public class Box<T> {
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }

    public <U extends Number> void inspect(U u){
        System.out.println("T: " + t.getClass().getName());
        System.out.println("U: " + u.getClass().getName());
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        integerBox

.set(new Integer(10));
        integerBox.inspect(10.0); // error: this is still String!
    }
}

In this example, T is replaced with Integer. This way we ensure type safety at compile time.

Example 2: Using Bounded Type Parameters and Wildcards

public class NaturalNumber<T extends Integer> {

    private T n;

    public NaturalNumber(T n)  { this.n = n; }

    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }

    public static void main(String[] args) {
        NaturalNumber<Integer> n = new NaturalNumber<>(5);
        System.out.println(n.isEven());
    }
}

In this example, T is bounded by Integer. This means you can use any class that is a subclass of Integer as a type argument.

Conclusion

Java Generics is a powerful feature that allows for type-safe programming, reducing bugs and making our code easier to read. It might seem a bit complex at first, but with practice, it becomes a vital tool in every Java programmer’s toolkit.

Frequently Asked Questions (FAQ)

Related Tutorials

If you enjoyed this tutorial, you might also like these related tutorials:

1. Java Collections Framework
2. Java Multithreading
3. Java Stream API
4. Java Exception Handling
5. Java I/O

That’s all for this tutorial. Happy coding!