Wildcards

List<? extends Number> means a list of some unknown type that is Number or a subtype of Number. You can assign a List<Number>, List<Integer>, or List<Double> to it.

With '? extends Number' the exact type is unknown, so the compiler can't be sure a value you add is allowed, but every element is at least a Number so reading is safe. With '? super Integer' the reverse holds: you can add Integers, but reads only give you Object.

<? super T> means "T or any of its parent types." You can safely add T (or its subtypes) to such a collection, but when you read from it you only get back Object, because you do not know the exact element type.

PECS means Producer Extends, Consumer Super. If a structure gives you (produces) values, use ? extends T. If it receives the values you put in (consumes them), use ? super T.

The compiler doesn't know the real element type behind ?, so it can't be sure any value you add fits - except null, which fits every type. Reading is fine because whatever comes out is at least an Object.

List<?> means 'a list of some unknown but specific type'. List<Object> is a list that explicitly holds any object, and raw List has no type info at all. List<?> is type-safe; raw List is not.

Because the real element type behind the wildcard is unknown, the compiler can't guarantee any value you add fits, so it blocks all add calls. The one exception is null, which is valid for every type.

Because the real list could be a List<Integer>, a List<Double>, or any subtype of Number — the compiler does not know which. It cannot prove your value fits, so it blocks adds. Only null is always safe.

No. The raw List turns off generic checking and lets you do unsafe things with warnings. List<?> keeps the type checks on: you read as Object and can only add null, so the compiler still protects you.

List<?> is a list of some unknown type and is type-safe — you can't add anything but null. Raw List has no type checking and lets you add anything (unsafe, legacy). List<Object> is a list that explicitly holds any Object and lets you add anything safely.

Because the list's real element type could be T or any of its parents, the compiler doesn't know the exact type. The only type guaranteed to fit every possibility is Object, so reads come back as Object.

You get back Object. The list could be a List<Object>, so the only type the compiler can guarantee for every element is Object. You can safely add Integers, but reads come back as Object.

You write a public method taking List<?> and have it call a private generic helper method <T> that takes List<T>. Passing the wildcard list to the helper makes the compiler capture the unknown type as T, so inside the helper you can read and write elements consistently.

Wildcard capture is when the compiler replaces a '?' with a fresh, made-up type variable so it can reason about it as a single concrete type. It happens when a method takes a wildcard-typed argument and binds it to a real type parameter.

A comparator that knows how to compare T's supertype can also compare T's, since every T is-a supertype. Accepting Comparator<? super T> lets you reuse one general comparator (e.g. for Animal) to sort a list of a subtype (e.g. Dog).

PECS means "Producer Extends, Consumer Super." Something you read from uses extends; something you write to uses super. A copy destination is written to (a consumer), so it should be List<? super T> to accept T and its subtypes.

For copying, the source produces so use ? extends T, and the destination consumes so use ? super T. For finding a max, the collection only produces elements to compare, so use ? extends T. Wildcards let the methods accept more caller types.

Use List<?> when the method only cares that it has a list and never needs to name the element type - for example to check its size or print it. Use a type parameter <T> when the element type must appear in more than one place, like returning an element of that same type.

The source list (the one you read from) gets <? extends T> because it produces elements. The destination list (the one you write to) gets <? super T> because it consumes them.

Use a named type parameter <T extends Number> when you need to refer to the exact type by name — for example to return it, relate two parameters, or reuse it. Use a wildcard <? extends Number> when the type is used only once and you just read from it.

It means you tried to write a plain Object into a list whose element type is an unknown captured wildcard (CAP#1). The compiler can't prove the Object is the right type. Fix it by routing through a generic helper method so the unknown type gets a name.

Use List<?> when the method does not care about the element type at all — e.g. it only checks size or clears the list. You can read elements as Object and you cannot add anything except null.

At runtime Java erases generic type information, so List<String> and List<Integer> are both just List. Because of that, the only generic instanceof check Java allows is the unbounded wildcard form: obj instanceof List<?>.

Generics, including the wildcard, are erased at compile time. At runtime there is just List — the ? extends Number part is gone. So you can't instanceof List<? extends Number> it, and you can't create generic arrays of it.