Why does my attempt to add an Integer to a Java array, declared as an Object[] but instantiated as a String[], not generate a compilation error?
Object[] ob = new String[1];
ob[0] = new Integer(1); // this shouldn’t compile but it does!
When I run this, I get a runtime exception instead of a (much preferred) compile-time error! Is this correct behavior? Shouldn't I get a compile-time error?
It's a choice that Java designers have made: String[] extends Object[], but you can't add anything other than a String to an array whose concrete type is String[] without getting a runtime exception.
What they could have made invalid is the following:
Object[] ob = new String[1];
because it effectively allows any kind of object to be added to the array without getting any compiler error (as you noticed), which is perfectly normal since an Integer is an Object, and the compile-time type of the array is Object[].
They didn't make this choice for arrays, but they did it for generic collections:
List<Object> ob = new ArrayList<String>();
generates a compiler error, because List<String> doesn't extend List<Object>. Collections should generally be preferred over arrays, as they're safer, and provide a lot more functionality.
Integer into a String array (doesn't have to do with array type covariance).
The main point that you may want to take into account is the runtime type of the referenced array (String[]) vs. the compile-time type of the array variable (Object[]). The compiler only enforces that what you put into the array is compatible with the static type of the array variable refering to it. This example makes that stand out:
String[] strs = new String[1];
Object[] objs = strs;
strs[0] = new Integer(1); /* error, says the compiler! */
objs[0] = new Integer(1); /* fine by me, says the compiler! */
Now, what you should legitimately be upset about is actually your first line: Object[] ob = new String[1]; which implies that String[] is assignment-compatible with Object[]—in other words, its subtype. This is in opposition with the well-known fact of CS that container types are contravariant in the type of their elements. Why is it then not so with Java? I read once an account where James Gosling was asked that and he replied that they were aware of the facts, but wanted a simple way for a Java method to be able to accept any kind of array (through the Object[] type). This stems from the requirement on Java to be a "blue collar language" and not get into type-theoretical exactitudes which bring their own mental baggage. Witness generics' <? super String> and Scala's covariant/contravariant position rules.
obis anObject[].Integeris a subclass ofObject. So that should compile perfectly fine. Perhaps you want to declareobasString[]instead?String[]) vs. the compile-time type of the array variable (Object[]). The compiler only enforces that what you put into the array is compatible with the static type of the array variable refering to it.