Java Generics - New Dev Point

What are Java Generics?

Java Generics provide a way to create classes, interfaces, and methods with type parameters, allowing code to be more flexible, reusable, and type-safe. With generics, you can specify the type of objects that a class or method can operate on, avoiding the need for casting and helping to detect type-related errors at compile time.

Before Java generics were introduced in Java 5, code often involved casting, which was both unsafe and error-prone. Generics allow you to specify a type when instantiating a class or invoking a method, ensuring that only objects of that type can be used, and reducing the need for explicit casts.

Key Benefits of Java Generics

Type Safety: Generics enforce type checking at compile time, preventing ClassCastException during runtime.
Code Reusability: You can write a single class or method that can handle multiple data types without duplicating code.
Eliminates Casting: You don’t have to cast objects when retrieving them from a collection, making the code cleaner and easier to read.
Abstraction: Allows for creating more abstract, flexible algorithms and data structures.

Basic Syntax of Generics

Generic Classes:

// A simple generic class
public class Box&lt;T&gt; {
    private T value;

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

    public T get() {
        return value;
    }
}

// Using the generic class
public class Main {
    public static void main(String[] args) {
        Box&lt;String&gt; stringBox = new Box&lt;&gt;();
        stringBox.set("Hello");
        System.out.println(stringBox.get());

        Box&lt;Integer&gt; integerBox = new Box&lt;&gt;();
        integerBox.set(123);
        System.out.println(integerBox.get());
    }
}

// A simple generic class

public class Box<T> {

private T value;

public void set(T value) {

this.value = value;

}

public T get() {

return value;

}

// Using the generic class

public class Main {

public static void main(String[] args) {

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

stringBox.set("Hello");

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

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

integerBox.set(123);

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

}

T is the type parameter, and when creating a new instance of Box, you specify the actual type (String, Integer, etc.).
This ensures that only a String can be placed in the stringBox and only an Integer in the integerBox.

Generic Methods:

public class Utils {
    // A generic method
    public static &lt;T&gt; void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = { 1, 2, 3 };
        String[] stringArray = { "Hello", "World" };

        printArray(intArray);
        printArray(stringArray);
    }
}

public class Utils {

// A generic method

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

for (T element : array) {

System.out.println(element);

}

public static void main(String[] args) {

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

String[] stringArray = { "Hello", "World" };

printArray(intArray);

printArray(stringArray);

}

The <T> before the return type tells the compiler that T is a type parameter, which can be used within the method.

Bounded Type Parameters:
You can restrict the types that can be passed as generic parameters using bounded types.

public class NumberBox&lt;T extends Number&gt; {
    private T number;

    public NumberBox(T number) {
        this.number = number;
    }

    public T getNumber() {
        return number;
    }
}

public class Main {
    public static void main(String[] args) {
        NumberBox&lt;Integer&gt; intBox = new NumberBox&lt;&gt;(100);
        System.out.println(intBox.getNumber());

        NumberBox&lt;Double&gt; doubleBox = new NumberBox&lt;&gt;(99.99);
        System.out.println(doubleBox.getNumber());

        // This would cause a compile-time error:
        // NumberBox&lt;String&gt; stringBox = new NumberBox&lt;&gt;("Hello"); // Error!
    }
}

public class NumberBox<T extends Number> {

private T number;

public NumberBox(T number) {

this.number = number;

}

public T getNumber() {

return number;

}

public class Main {

public static void main(String[] args) {

NumberBox<Integer> intBox = new NumberBox<>(100);

System.out.println(intBox.getNumber());

NumberBox<Double> doubleBox = new NumberBox<>(99.99);

System.out.println(doubleBox.getNumber());

// This would cause a compile-time error:

// NumberBox<String> stringBox = new NumberBox<>("Hello"); // Error!

}

T extends Number: This means that the type parameter T can only be a subclass of Number (e.g., Integer, Double, Float, etc.).

Wildcards:
- ? is a wildcard that represents an unknown type. It’s useful when you want to allow any type but don’t need to know the specific type.
- Example:
  
  public void printList(List<?> list) { for (Object element : list) { System.out.println(element); } }
  
  1
  2
  3
  4
  5
  
  public void printList(List<?> list) {
    for (Object element : list) {
        System.out.println(element);
    }
  }

Using Generics in Real-Life Projects

Generics are extremely useful in real-world applications, particularly for handling collections and data structures, as they provide compile-time type safety. Here are some common real-life use cases:

1. Working with Collections

In Java, most of the Collections Framework (like List, Set, Map, etc.) is built using generics. When you declare a collection with a specific type, generics enforce type safety and eliminate the need for manual casting.

Example:

List<String> names = new ArrayList<>(); names.add("John"); names.add("Jane"); for (String name : names) { System.out.println(name); }

1
2
3
4
5
6
7

List<String> names = new ArrayList<>();
names.add("John");
names.add("Jane");

for (String name : names) {
System.out.println(name);
}
Without generics, you would have to cast every element when retrieving it from the collection:

List names = new ArrayList(); // Before generics names.add("John"); String name = (String) names.get(0); // Casting required

1
2
3

List names = new ArrayList(); // Before generics
names.add("John");
String name = (String) names.get(0); // Casting required

2. Data Access Objects (DAO)

When interacting with databases in a project, you can use generics to create a DAO that works with different types of entities.

Example:

public interface GenericDao&lt;T&gt; {
  void save(T entity);
  T findById(int id);
}

public class UserDao implements GenericDao&lt;User&gt; {
  @Override
  public void save(User user) {
      // Code to save user
  }

  @Override
  public User findById(int id) {
      // Code to find user by id
      return new User();
  }
}

public class ProductDao implements GenericDao&lt;Product&gt; {
  @Override
  public void save(Product product) {
      // Code to save product
  }

  @Override
  public Product findById(int id) {
      // Code to find product by id
      return new Product();
  }
}

public interface GenericDao<T> {

void save(T entity);

T findById(int id);

}

public class UserDao implements GenericDao<User> {

@Override

public void save(User user) {

// Code to save user

}

@Override

public User findById(int id) {

// Code to find user by id

return new User();

}

public class ProductDao implements GenericDao<Product> {

@Override

public void save(Product product) {

// Code to save product

}

@Override

public Product findById(int id) {

// Code to find product by id

return new Product();

}

In this example, the GenericDao<T> interface can work with any type of entity (like User, Product), and each concrete class implements methods for that specific entity type. This eliminates the need to write multiple DAOs that are otherwise redundant.

3. Custom Utility Classes

Generics can be used to write utility classes that operate on different data types. For example, creating a generic utility class for sorting:

public class SortUtils {
    public static &lt;T extends Comparable&lt;T&gt;&gt; void sort(T[] array) {
        Arrays.sort(array);
    }
}

public class SortUtils {

public static <T extends Comparable<T>> void sort(T[] array) {

Arrays.sort(array);

}

Now, the sort method can be used to sort any type of array that implements Comparable (like Integer, String, etc.).

4. API Design

When designing RESTful APIs or microservices, you may use generics to return responses for different types of objects:

Generic Response Wrapper:

public class ApiResponse&lt;T&gt; {
  private T data;
  private String message;
  private int status;

  public ApiResponse(T data, String message, int status) {
      this.data = data;
      this.message = message;
      this.status = status;
  }

  // Getters and Setters
}

// Example usage
public ApiResponse&lt;User&gt; getUserById(int id) {
  User user = userService.findById(id);
  return new ApiResponse&lt;&gt;(user, "User found", 200);
}

public class ApiResponse<T> {

private T data;

private String message;

private int status;

public ApiResponse(T data, String message, int status) {

this.data = data;

this.message = message;

this.status = status;

}

// Getters and Setters

}

// Example usage

public ApiResponse<User> getUserById(int id) {

User user = userService.findById(id);

return new ApiResponse<>(user, "User found", 200);

}

This ApiResponse<T> wrapper can handle any type of response (e.g., User, Product, Order), allowing for a unified structure while preserving type safety.

Conclusion

Java Generics are powerful and widely used in real-life projects to write flexible, type-safe, and reusable code. Generics enable you to:

Create flexible APIs that handle various data types.
Enforce compile-time type checking, preventing runtime type errors.
Simplify code when working with collections or other data structures.

In modern Java applications, especially in areas like data handling, collection management, and service design, generics play an essential role in improving the robustness and maintainability of code.