The Motivation Behind Generics in Java Programming

Tl;dr Summary of this Article:

• Code Complexity and Bugs: As software projects grow, complexity increases, making it easier for bugs to creep in. Bugs, akin to misplaced puzzle pieces, can lead to runtime issues, especially in production.
• Runtime Bugs: Runtime bugs, often caused by human errors, occur during program execution and can lead to crashes or unexpected behavior. They are not checked by the compiler.
• Compile-Time Bugs: Compile-time bugs are detected and reported by the compiler during code compilation, preventing the project from being completed until they are fixed.
• Generics' Role: Generics in Java, introduced in version 1.5, play a crucial role in improving type safety and mitigating runtime bugs.
• Type Safety Enhancement: Generics allow developers to specify the type of elements a collection can hold at compile time, preventing potential runtime type errors like ClassCastException.
• Type Casting: Generics eliminate the need for explicit type casting when retrieving elements from collections, improving code readability and reducing the risk of errors.

Code Complexity and Bugs

Imagine that you are writing some Java code, at first, your project is like a small puzzle. You know exactly what each piece looks like, and you can easily put them together.

But as your project grows, it's no longer just a simple puzzle. It becomes a massive, complex one with hundreds or even thousands of pieces (lines of code). This can get confusing, and it's easy to make mistakes, like putting the wrong pieces together.



Some of these pieces can be tricky, they might fit in well at a place, but it may be the wrong match. Now, think about these pieces as bugs in your code, they don't show up until your program is running. That's when things can go wrong, and it's not fun to deal with problems when your software is already out there in the production environment.

It is a fact that software bugs are part and parcel of development. Smaller projects make spotting and fixing them easier, but as projects grow and evolve with changing teams and new features, project complexity increases, and bugs inevitably creep in, it is our job to minimize them as much as possible before the project moves to higher environments - Staging/UAT/Production.

The Creepy Runtime Bugs

The runtime bugs (exceptions) occur during the execution of a program and are typically indicative of errors in the program's logic. Unlike Checked Exceptions, which must be explicitly declared or caught, Runtime Exceptions are unchecked, meaning they do not need to be declared in a method's signature or caught explicitly.

Runtime Exceptions are the result of human errors introduced by developers during the coding process. These errors may include improper input validation, null pointer dereferences, improper casting, or arithmetic operations that can lead to unexpected behavior. Since the compiler does not check for RTEs at compile time, they can often go unnoticed until runtime, potentially causing program crashes or undesirable behavior in production.

The Compile time Bugs!

The compile time bugs are shown as an error message during code compilation. All IDEs like Eclipse, IntelliJ, or VS Code will show the line in red where there is a compilation error and the project will not complete until you fix them.

Now Let's Talk About Generics

Compile time bugs are easy to detect and fix, this is where Generics comes in!

Now that we have looked at how Runtime Exceptions can creep into production, the way to mitigate them is by converting them into CompileTime Exceptions so they can be avoided, below are some key motivations behind the introduction of Generics in Java 1.5.

Type Safety:

import java.util.ArrayList;
import java.util.List;

public class TypeSafetyExample {

    public static void main(String[] args) {

        List assortedList = new ArrayList();
        assortedList.add("Hello");
        assortedList.add(123);

        for (Object item : assortedList) {
            String element = (String) item;
            System.out.println(element);
        }
    }
}

Exception in thread "main" java.lang.ClassCastException:
class java.lang.Integer cannot be cast to class java.lang.String
(java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
at TypeSafetyExample.main(TypeSafetyExample.java:13)

As you can see in the above code there was no Compilation error, but failed during runtime.

This is one of the primary motivations for introducing Generics was to introduce type safety in Java programs.

Before Generics, collections like ArrayList and HashMap could hold objects of any type, leading to potential runtime type errors (ClassCastException). Generics allow developers to specify the type of elements a collection can hold at compile time, preventing such errors.

List<String> list = new ArrayList<>();
        list.add("Hello");
        list.add(123);





Eliminating Type Casting:

This can be seen as a byproduct of type casting, prior to Generics, developers often had to use explicit type casting when retrieving elements from collections. Generics eliminate the need for such casts, making code more readable and less error-prone.



As you can see the compiler says that "casting can be removed" when we make use of collections with Generics.

Summary

Generics in Java address code complexity and improve type safety by detecting and preventing runtime bugs at compile time, leading to more reliable and maintainable software projects.

Some more advantages of Genetics

Generics are not just about collections, they help you write reusable code and algorithms, thus helping write lean & robust code. We shall cover these topics in our next article.