Why can't wildcards be used at the top level during instantiation, but they can be used at every other level during instantiation?

Question

For example, if I have the following class:

class MyObject<T> {}

Why is this possible:

class Main {
    public static void main(String[] args) {        
        MyObject<MyObject<?>> moMo = new MyObject<MyObject<?>>();
    }
}

but not this:

class Main {
    public static void main(String[] args) {
        MyObject<?> mo = new MyObject<?>();
    }
}

I don't understand why one of these would be possible and not the other. I'm starting to believe that these many little discrepancies weren't intentionally designed, but are instead just quirks in the language.

---

I understand there have been similar questions asked on here (this, this, and this); however, none have answered why one is allowed and not the other.

Answer 1

Consider

    List<?> list1 = new ArrayList<>();
    List<?> list2 = new ArrayList<List<?>>();
    List<?> list3 = new ArrayList<?>(); // WRONG

    list2.add(new ArrayList<Integer>()); // WRONG

In the third wrong case an actual List is created with a generic parameter class not bound to the declared parameter class on the left (also ?). A wild card type may not be instantiated directly.

You might do new ArrayList<Integer>() (or new ArrayList()) telling what type is allowed. These are stored in Class.getType parameters(). Hence new ArrayList<?>() cannot be stored in the objects actual class for that ArrayList instance. Runtime class erasure does not hold 100% for generic classes.

In the second case this immediate instantiation does not happen.

That such usage of wild card types are cumbersome/impractical is shown by the add, where the actual list2 might be a List<List<String>> instead.

For those that have experience stronger type systems in other languages: better refrain from trying to use too clever type expressions.