Why can a raw type reference refer to a generic instance?

Question

Please help understand why

Map map1 = new HashMap<String,String>(); // This compiles
Map<Object,Object> map2 = new HashMap<String,String>(); // This does not.

As per my understanding

Map map1

is same as

Map<Object,Object> map1

---- Edit ----

When generics are not provided for reference map1 , compiler accepts the object creation with any generics. This to me seemed like map1 have implicit

<Object,Object>

generics applied.

So the question here is why compilation fails when map2 have explicit

<Object,Object>

generics applied.

For downvoters , the question for which this is marked as duplicate , does not answer my question directly.

Thanks Chetan and Pham , That explains!!!.

Have you tried using `Map map2 = new HashMap();` instead of `Map — Aakash, Jun 10 '15 at 06:49
@RealSkeptic I don't think it's a direct duplicate of the question you linked to. This question asks whether `Map` is the same as `Map — Chetan Kinger, Jun 10 '15 at 06:53
There is no type check done from compiler for 'map1', but for 'map2' and there generic types don't match. — Tom, Jun 10 '15 at 06:53
I am voting to reopen this question as it's not a duplicate of the one it has been marked a duplicate of. The marked duplicate does not talk about raw types. — Chetan Kinger, Jun 10 '15 at 08:11
@ChetanKinger Exactly. I don't think the people who voted to close as a duplicate looked at the question closely. — Erwin Bolwidt, Jun 10 '15 at 13:51

Chetan Kinger · Accepted Answer · 2015-06-12T11:46:24.853

Map<Object,Object> map2 = new HashMap<String,String>();

As per my understanding

Map map1 is same as

Map<Object,Object> map1

No. A Map is not the same as a Map<Object,Object>.

A reference of type HashMap<T,T> is a subtype of a reference of type Map. In other words, a reference of type Map can refer to an object of type HashMap<String,String>.

On the other hand, a reference of type HashMap<T,T> is not a subtype of a reference of type Map<E,E> (Even if T is-a E and HashMap is-a Map). In other words, a reference of type Map<Object,Object> can't refer to an object of type HashMap<String,String> even if String is-a Object and HashMap is-a Map.

If you are wondering why the rules for reference sub types in case of generics works this way, there is one explanation I can give based on my understanding. Generics are syntactic sugar and go through what is known as type-erasure once the code is compiled. That is, a HashMap<String,String> when compiled becomes a HashMap.

If the compiler allowed the statement Map<Object,Object> map = new HashMap<String,String>, it would mislead programmers to believe that the Map can only hold String key and values at runtime. This would be absurd since Generics go through type-erasure at compile time itself.

The statement Map map = new HashMap<String,String> is allowed on the other hand mostly for backward compatibility with legacy code.

Can the downvoter please leave a comment and let me know what is wrong with my answer? I believe that the only explanation for the downvote would be that the downvoter does not have the basic understanding of the Java programming language to understand my answer. — Chetan Kinger, Jun 10 '15 at 07:07
not the downvoter - but you're not likely to get an answer by pre-emptively insulting the downvoter :-) maybe it helps if you add a reference to "JLS 4.10.2. Subtyping among Class and Interface Types" to show that you are right. — Erwin Bolwidt, Jun 10 '15 at 07:37
@ErwinBolwidt Thanks for the upvote. I believe the downvote may have been due to a small typo in my answer which I corrected. Didn't deserve a downvote for a typo. Will quote the JLS. :) — Chetan Kinger, Jun 10 '15 at 07:38

score 0 · Answer 2 · answered Jun 10 '15 at 06:55

That is because when you use new HashMap<String,String>(); the object can contain only String values.

But the variable Map<Object,Object> map2 means that map2 can contain Object keys and values.

And using Map<Object, Object> is not the same as using Map. Its just that in the latter you are not using type safety, the former will show your errors during compilation itself but the latter will throw errors during Runtime.

Why can a raw type reference refer to a generic instance?

2 Answers2