Java generics provide compile-time type safety and eliminate casting by allowing type parameters in classes, interfaces, and methods, while wildcards enhance flexibility when working with unknown types; 1. Generics enable reusable, type-safe code like List or generic Box; 2. Wildcards handle unknown types: > for any type, extends T> for subtypes (useful for reading), and super T> for supertypes (useful for writing); 3. The PECS rule guides usage: use extends when the type produces data (producer), super when it consumes data (consumer), as seen in Collections.copy(dest super T>, src extends T>); 4. Avoid raw types, don’t use wildcards in return types unnecessarily, leverage bounded type parameters like >, and remember type erasure limits runtime use — proper use of generics and wildcards improves code safety, clarity, and reusability.

Java generics and wildcards are powerful features that enable type-safe programming, reducing runtime errors and improving code readability. Introduced in Java 5, generics allow you to define classes, interfaces, and methods with type parameters, so the same code can work with different types while catching type mismatches at compile time. Wildcards extend this flexibility by letting you work with unknown or bounded types.

Here’s how to understand and use them effectively.

1. What Are Generics?

Generics let you abstract over types. For example, instead of using raw types like List, you can use List<string></string> to ensure only strings are added.

List<String> names = new ArrayList<>();
names.add("Alice");
// names.add(123); // Compile error – type safety!

Without generics, you’d have to cast objects and risk ClassCastException at runtime.

Key Benefits:

• Compile-time type checking
• Elimination of explicit casting
• Code reuse across different types

You can also define your own generic classes and methods:

public class Box<T> {
    private T value;

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

Now Box<String>, Box<Integer>, etc., are all type-safe.

2. Wildcards: Handling Unknown Types

Sometimes you need to work with generic types when the exact type parameter isn’t known. That’s where wildcards (?) come in.

Unbounded Wildcard (<?>)

Use when you don’t care about the type, typically for reading from collections.

public void printSize(List<?> list) {
    System.out.println("Size: "   list.size());
}

You can’t add elements (except null) because the actual type is unknown.

Upper-Bounded Wildcard (<? extends T>)

Use when you want to accept a type and its subtypes. Common in read-only operations.

public double sum(List<? extends Number> numbers) {
    return numbers.stream().mapToDouble(Number::doubleValue).sum();
}

Now you can pass List<Integer>, List<Double>, etc.

But again, you can’t add anything (except null) — because the compiler doesn’t know the exact type.

Lower-Bounded Wildcard (<? super T>)

Use when you want to accept a type and its supertypes. Useful for write operations.

public void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

This works with List<Integer>, List<Number>, or List<Object>.

But you can’t safely read as Integer — elements might only be Object.

3. The PECS Rule: Producer extends, Consumer super

A helpful mnemonic from the Effective Java book:

PECS: Producer – extends, Consumer – super

• If a parameterized object produces T (you read T from it), use <? extends T>.
• If it consumes T (you write T into it), use <? super T>.

For example, in Collections.copy():

public static <T> void copy(List<? super T> dest, List<? extends T> src)

• src is a producer → ? extends T
• dest is a consumer → ? super T

Apply PECS to design flexible and safe APIs.

4. Common Pitfalls and Tips

• Don’t use wildcards in return types unless necessary — it forces callers to deal with unknown types.

• Raw types are dangerous — avoid List instead of List<String>.

• Generic methods can infer types:

  public <T> void print(T item) { ... }

• Type erasure means generics are enforced at compile time only. No runtime information (e.g., you can’t do new T[]()).

• Bounded type parameters can constrain generics:

  public <T extends Comparable<T>> T max(T a, T b) {
      return a.compareTo(b) > 0 ? a : b;
  }

  ---

  Using generics and wildcards properly leads to cleaner, safer code. Understand when to use extends, super, or specific types — and remember PECS. It’s not just about avoiding casts; it’s about expressing intent and catching bugs early.

  Basically, generics give you compile-time safety, and wildcards give you the flexibility to reuse code across type hierarchies — without sacrificing that safety.

  The above is the detailed content of Understanding Java Generics and Wildcards for Type-Safe Code. For more information, please follow other related articles on the PHP Chinese website!