Java Generics: In-Depth Explanation and Usage

In Java, generics are a type parameterization mechanism that allows the compiler to detect type mismatch errors at compile time, thereby enhancing type safety and code readability. Through generics, Java programs can define a generic type, enabling the same class or method to work with data of different types.
Here, <T> represents a generic type parameter, which can be replaced by any letter to denote a generic type; for example, List<T> denotes a generic list type that can accommodate data of various types.
In Java, generics primarily serve the following purposes:

1. Type Safety: Through generics, type mismatch errors can be detected at compile time, avoiding runtime type conversion exceptions.
2. Code Reusability: Through generics, generic types and methods can be defined, allowing the same class or method to work with data of different types, thus improving code reusability and maintainability.
3. Readability: Through generics, program code can become more concise and readable, avoiding excessive type conversions and repetitive code.
   When using generics, keep the following points in mind:
4. Generics can only be used with reference types, not primitive types.
5. Generic parameters cannot be primitive types; they must be classes, interfaces, or other generic types.
6. Generic parameters are erased during compilation; that is, specific type information for generic types is unavailable at runtime.
7. A generic type can have multiple type parameters; for example, Map<K, V> denotes a key-value pair type, where K and V represent two generic type parameters.
8. Generics can restrict the scope of types using wildcards; for example, List<? extends Number> denotes a list type where the element type must be the Number class or one of its subclasses.
   In summary, generics are an important type parameterization mechanism in Java that enhances type safety, code reusability, and readability. It is necessary to master their basic syntax and usage precautions to effectively use generics in actual development to improve program quality and efficiency.

Basic Syntax of Generics

Generics in Java can be applied to classes, interfaces, methods, etc., with the basic syntax as follows:

1. When defining a generic class or interface, add angle brackets after the class or interface name, containing one or more type parameters, as shown below:

public class MyClass<T> {
    // Class members and methods can use the type parameter T
}
public interface MyInterface<T> {
    // Interface methods can use the type parameter T
}

2. When defining a generic method, add angle brackets before the method name, containing one or more type parameters, as shown below:

public <T> void myMethod(T arg) {
    // Method parameters and local variables can use the type parameter T
}

3. When using generics, specific type parameters can be specified when instantiating a class or calling a method, or they can be omitted. In this case, the compiler infers the specific type of the type parameter based on context, as shown below:

MyClass<String> myObj = new MyClass<String>(); // Specify type parameter as String
MyClass<Integer> myObj2 = new MyClass<>(); // Type inference; type parameter automatically inferred as Integer
myMethod("hello"); // Specify type parameter as String
myMethod(123); // Type inference; type parameter automatically inferred as Integer

4. Type parameters can be constrained, meaning the type parameter must satisfy certain conditions, as shown below:

public class MyClass<T extends Number> {
    // Type parameter T must be of Number type or a subclass thereof
}
public <T extends Comparable<T>> void myMethod(T arg) {
    // Type parameter T must implement the Comparable interface
}

By using generics, code can become more general and flexible, avoiding the repetition of writing similar code, thereby improving code reusability and maintainability.

Examples

public class Pair<T, U> {
    private T first;
    private U second;
    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }
    public T getFirst() {
        return first;
    }
    public U getSecond() {
        return second;
    }
    public void setFirst(T first) {
        this.first = first;
    }
    public void setSecond(U second) {
        this.second = second;
    }
}

This example defines a generic class Pair with two type parameters T and U. This class has one constructor and four methods: getFirst() and getSecond() are used to retrieve the values of the first and second attributes, while setFirst() and setSecond() are used to set the values of the first and second attributes.
Below is an example code demonstrating how to use the Pair class:

Pair<String, Integer> pair = new Pair<>("Hello", 123);
String first = pair.getFirst();
Integer second = pair.getSecond();
System.out.println("First: " + first);
System.out.println("Second: " + second);

In this example, a Pair object is created where the type of the first attribute is String with value "Hello", and the type of the second attribute is Integer with value 123. The values of the attributes are then retrieved using the getFirst() and getSecond() methods and printed using the System.out.println() method.
The output result of this example is:

First: Hello
Second: 123