Advanced applications of Java generics include: 1. Use generic methods and wildcards to improve flexibility, such as extends T> for read-only operations, and super T> for writeable operations; 2. Use type erasing mechanism and boundary restrictions to define the upper or lower bounds of generics, and support multi-constraints; 3. Design custom generic classes and recursive generic structures to enhance type consistency; 4. Improve type safety by avoiding primitive types, rational use of wildcards, handling generic arrays, and carefully judging types.

Java generics are an important tool to improve code reusability and type safety. Many people will use basic generics, such as List<string></string> or write a simple generic class. But truly mastering Java generics, especially the advanced part, allows you to write safer, clearer, and more flexible code.

The following points are the core content that you cannot avoid when using advanced generics.

1. Correct use of generic methods and wildcards

Sometimes we don't need the entire class to be generic, we just need a certain method to have generic capabilities. At this time, you can use generic methods .

 public <T> void printList(List<T> list) {
    for (T item : list) {
        System.out.println(item);
    }
}

This method accepts any type of List and does not require casting internal processing.

When you are faced with a situation where you are uncertain about the specific type, such as passing a List<? extends Animal> , you know that it contains an Animal subclass object, but you don't know which subclass it is. In this case, using wildcard characters can increase flexibility.

Common combinations:

• ? extends T : read-only, suitable for consumers (such as traversal)
• ? super T : writable, suitable for producers (such as adding elements)
• Without wildcards: readable or writable, but the types must match exactly

2. Type erasure and boundary limits (Bounded Types)

Java generics are implemented during the compilation period and will be "erased" at runtime, which is called type erasure . This means that you cannot directly obtain the specific type information of a generic through reflection, nor do you do T::class.java like Kotlin.

However, you can control the type range by limiting the upper or lower bounds of generics:

 public class Box<T extends Comparable<T>> {
    // Here T must be the type that implements the Comparable interface}

The advantage of this is that you can call compareTo() method without worrying about the type not being supported.

If you want multiple constraints, you can use & to connect the interface:

 <T extends Serializable & Cloneable>

Note that there can only be one class as the upper bound, and the others must be interfaces.

3. Custom generic classes and recursive generics (Self-referenceal Generics)

In some scenarios, we need to let the class reference its own generic types, such as common linked list nodes:

 public class Node<T> {
    private T value;
    private Node<T> next;

    // constructor, etc.

More complex ones include self-referenced structures, such as:

 public abstract class BaseNode<T extends BaseNode<T>> {
    public abstract T getNext();
}

This is common in designing some DSL or builder patterns, with the purpose of ensuring that the returned type is the current subclass type, not the parent type, thereby avoiding forced rotation.

4. Practical suggestions for using generics to improve type safety

• Avoid Raw Types : Although writing methods like List list = new ArrayList(); are compatible with old code, they lose the type checking brought by generics.
• Try to use wildcards instead of specific types : when you don't need to operate specific types, using List> is more appropriate than List<object></object> .
• Generic arrays are immutable : you cannot create new T[10] because the type is erased. Array.newInstance() can be used instead.
• Use instanceof and generics with caution : due to type erasing, list instanceof List<string></string> is illegal and can only be judged to List.class level.

Basically that's it. Generics may seem a bit abstract, but once you understand the design logic and application scenarios behind it, you will find that it not only reduces casting, but also helps you block many potential errors during the compilation stage.

The above is the detailed content of Advanced Java Generics for Type Safety. For more information, please follow other related articles on the PHP Chinese website!