In Java, I can compile
Object[] obj = {new Object[1], new Object[2]};
But I cannot compile
Object obj = {new Object(), new Object()};
In the first example I declare a one-dimensional array of Objects and assign it a two-dimensional array. In the second I declare an Object and assign it a one dimensional array.
If a Java array extends Object, why doesn't the second code fragment compile? Why does the first?
Assigning an array to an Object isn't a problem, but you have to create the array like this
Object obj = new Object[] { new Object(), new Object[2] };
Otherwise the compiler won't know that it's an Object array and not some other kind of array.
Object obj = {new Object(), ...} returns an array, as in "a multiple pointer-array", while new ... returns a pointer to whatever comes after new. So Object obj = new Object[]{...} returns a pointer to the array, while Object obj = {...} returns an array.
Object[] a; Object[] b; a = new Object[] { new Object(), new Object() }; b = a; b[0] = null; System.out.println("a[0] is null? " + (a[0] == null)); If the variables actually contained the array, the b = a; line would have to be an array copy operation, wouldn't it? And thus assigning to b[0] would have no effect on a[0]. But of course it does, because Java defines that a and b hold references. :-)Object[] o = {...} is stored in the Stack or the Heap of the application. I think that's where I'm trying to get. I know that in the end o will only be a reference and not the actual array. I hope you know what I mean.Because Array is not just a subclass of Object. Arrays also have language-level semantics and syntax.
Separately, your second example begs the question: Where would the object store those two things you're trying to initialize it with? You've just declared an object, but it has no named fields, and lacks the numerically-indexed slots arrays have.
Your first example compiles because you've declared an array of Object (which is to say, object references), and the elements you're giving it to initialize that array are object references (references to the single-element arrays you're creating via new Object[1]).
This may help as well: Java doesn't really have two-dimensional arrays, although there is some convenience syntax that makes it look like it does. It has (single dimensional) arrays of (single dimensional) arrays (of...you get the idea).
The problem is that when you create an array using an initializer, the compiler needs to ensure all elements from the initializer are of the same provided type by checking the type of the element against the provided type.
That said, you always need to provide the type information when initializing an array. Otherwise, the compiler doesn't know how to verify if the array initialization is valid, thus giving an illegal initializer error.
There's no problem assigning an array to an object. For example, you can do the following:
int[] arr = {1,2};
Object obj = arr;
The following code won't compile:
Object obj = {1,2};
Because you didn't explicitly provide the type of the element that the compiler needs to verify the values in the initializer against. And this is required for array initialization in Java.
The following code will compile:
Object[] obj = {1,2};
Because the type of the element was provided(i.e.,Object) and the compiler will check the type of 1, 2 against the type Object(which succeeds since Integer is subtype of Object).
You cannot compile
Object obj = {new Object(), new Object()};
because obj is not an array therefore declare like this
Object[] obj = {new Object(), new Object()};
or
Object obj = new Object[] { new Object(), new Object() };
Edited after the below conversation
Object variables can hold references to arrays, because arrays derive from Object. You don't have to declare the variable Object[] (although it's likely to be more useful if you do). It's just that when creating and initializing the array, the compiler needs to know what type of array it is, hence the syntax Robber presents.