what is the difference between ? and T in class and method signatures?

Question

why does

public interface ArrayOfONEITEMInterface <T extends ONEITEMInterface>{
    public List<T> getONEITEM();
}

compile, but not

public interface ArrayOfONEITEMInterface <? extends ONEITEMInterface>{
    public List<?> getONEITEM();
}

what is the difference between ? and T in class and method signatures?

Answer 1

? is a wildcard and means any subclass of ONEITEMInterface including itself.

T is a specific implementation of ONEITEMInterface in this case.

Since ? is a wildcard, there is no relation between your ? in the class declaration and the ? in your method declaration hence it won't compile. Just List<?> getONEITEM(); will compile though.

---

The first scenario means the entire class can handle exactly one type of Bar per instance.

interface Foo<T extends Bar> {
     List<T> get();
}

The second scenario allows each instance to operate on any subtype of Bar

interface Foo {
     List<? extends Bar> get()
}

Answer 2

T is a placeholder for a type that will be provided by an implementing or instantiating class.

? is a placeholder saying "I don't know or care what the generic type is" generally used when the work you'll do on the container object doesn't need to know the type.

The reason you can't use '?' in the class/interface definition is because there's the value is saying defining the name of the placeholder (and the type will be provided elsewhere). Putting a '?' doesn't make sense.

Furthermore, the placeholder doesn't need to be T, it can any standard Java variable. By convention, it is one capital character, but need not be.