Generics

A. Introduction to Generics in Java:

Generics is a programming feature introduced in Java 5 that allows developers to write reusable code that can work with different data types. With generics, you can create classes, interfaces, and methods that can work with any data type, rather than just a specific one.

Generics are used to make code more type-safe, which means that the compiler can catch more errors at compile-time instead of run-time. This can help reduce bugs in your code and make it easier to maintain and understand.

Example: Here's an example of how to use generics in Java to create a simple generic class:

public class Box<T> {
    private T item;

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

    public T getItem() {
        return item;
    }
}

In this example, the Box class is a generic class that can hold any type of item. The type parameter T is used to specify the type of item that the Box can hold. The setItem and getItem methods use the type parameter T to set and get the item.

B. Generic Classes and Methods in Java:

In addition to generic classes, Java also supports generic methods. Generic methods are methods that can work with any data type, just like generic classes. The syntax for creating a generic method is similar to that of a generic class.

Here's an example of a generic method that can swap the positions of two elements in an array:

public static <T> void swap(T[] array, int i, int j) {
    T temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

In this example, the <T> syntax is used to specify the type parameter for the method. The swap method can work with any type of array, as long as the array elements are of the same type.

C. Wildcards in Java:

Wildcards are a feature of generics in Java that allow you to specify a range of possible data types that a generic class or method can work with. There are two types of wildcards in Java: the ? wildcard and the ? extends and ? super wildcards.

The ? wildcard represents an unknown type. You can use it when you don't care about the specific type of data that a method or class works with.

The ? extends wildcard represents a range of types that are subtypes of a particular type. You can use it when you want to restrict the type of data that a method or class can work with to a specific range of subtypes.

The ? super wildcard represents a range of types that are supertypes of a particular type. You can use it when you want to allow a method or class to work with a wider range of data types, as long as they are all supertypes of a particular type.

Here's an example of how to use wildcards in Java:

public static double sumOfList(List<? extends Number> list) {
    double sum = 0.0;
    for (Number n : list) {
        sum += n.doubleValue();
    }
    return sum;
}

In this example, the sumOfList method takes a List of numbers, but it doesn't care about the specific type of numbers in the list. It uses the ? extends wildcard to specify that the list can contain any type of number, as long as it is a subtype of the Number class. This allows the method to work with a wide range of number types, including Integer, Double, and BigDecimal.