I'm new to java, I was reading Head first Java when I came across object in arrays. The code is from the book itself, I get the flow of the code but I don't really understand the second line. What does new Dog[7] do, in the book it says
"Declare and Create a Dog array to hold 7 Dog references"
If we have already created dog references why do we need to create a dog reference for individual array items again.
Dog[] pets;
pets = new Dog[7];
pets[0] = new Dog();
There is a difference between declaration and initialization.
Dog[] pets declares that the variable pets is an array of Dogs
pets = new Dog[7] initializes the variable pets, it assigns it a value. The value is an array of size 7 full of null references.
It is the same for primitives :
int i; //declaration
i = 5; //initialization
As well as you can write
int i = 5;
you can write
Dog[] pets = new Dog[7];
In this case, you do the declaration and initialization on the same line.
Before the second line, you just say that the variable pets exists, and it's an array of Dog, but the array doesn't exist in memory, because it hasn't been created.
In order to be able to use the array and read / store values inside, you need to actually create this array in memory, which is what the 2nd line does: it creates an array of Dog, of size 7.
The first line declares a variable of a "Dog array" type. The second line actually initializes it with an array that has seven slots, each of which are null. The third line creates an actual Dog instance, and assigns it to the first slot of the array.
Dog[] pets;
This will declare an array of dog. But when you do pets = new Dog[7]; it will initialize array with length of 7.
pets[0] = new Dog();
this statement will store an object of dog at 0th position.
This line pets = new Dog[7]; creates a Array Object which will contain Dog objects.
So initially all 7 indeces in pets array are null. Therefore pets[0] = new Dog(); required to create Dog Objects
Every object in java must be initialized with the keyword new, which allocates memory on the heap.
Arrays in java are also objects, thus they must be initialized with new.
By default, every object in the array will have a null value. So you must initialize every individual item with the new keyword again.
Situation at each step:
Dog[] pets; // <-- reference to an array of Dog, still uninitialized
pets = new Dog[7]; // <-- now pets points to an array of 7 Dog's. Array value is [null, null, null, null, null, null, null]
pets[0] = new Dog(); // <-- array now is [Dog@some_memory_address, null, null, null, null, null, null]
See the oracle tutorial for arrays
With that you are declaring and creating a java array able to contain 7 items of dog type. From a machine stand point you are creating a pointer to the memory space to contain your objects.
Dog[] pets; : decalres the array of Dog
pets = new Dog[7]; : Creates an array (with contiguous memory allocation on heap) of Dog to hold 7 Dog references (initially null).
