Array of Object in Java vs C++

Question

My Background is C++ and in c++ we can easily create array of object using simple syntax. className obj[n]; and also constructor will call n time.

But When I tried to create array of object in java className[] obj=new className[n]; no constructor call. After searching I found the answer of this question on stackoverflow that it just create n Reference that can point to n objects and I need to create objects again for each reference like. obj[0]=new className();

Now I just want to ask why java do this? is there any reason even C++ allows but java not allows to create array of objects in same way? I searched for this but still didn't get exact answer.

Answer 1

In C++ you have flexibility to choose a memory in which you create the object. You can create objects in automatic area (on the stack), in the static area, or in the dynamic area. In the last case you get an object pointer, and become responsible for freeing it after you are done.

In contrast, all Java has is the dynamic area option, because all objects are reference objects. In C++ that would be equivalent to using objects only through pointers, and always creating them with new. When you do this in C++, you also have to fill your array of pointers with new-ed objects:

myclass *array[10];
for (int i = 0 ; i != 10 ; i++) {
    array[i] = new myclass();
}
...
for (int i = 0 ; i != 10 ; i++) {
    delete array[i];
}

Allowing creation of object arrays in C++ was a choice dictated by need to let programmers allocate arrays of objects in the automatic area. It came with a tradeoff, because objects from which you make arrays must have a default constructors. This is not ideal, because the requirement of default constructor sounds arbitrary.

Java, on the other hand, was free from the automatic memory requirement, so they went for a simple solution that requires you to initialize objects individually.

Answer 2

Not so often need you to create objects of the same type as array with default constructor. Sometimes you want to call the custom constructor. Sometimes you want to instantiate the subclasses and store them in the array.

Note that Java array className[] obj is more equivalent to C++ array className* obj[n], not just className obj[n], because it's an array of references to the objects, not the array of objects themselves. As of Java-8 you cannot create an array of objects themselves (they are discussed as part of project Valhalla, but will not appear even in Java-9). When the objects themselves are stored in the array in C++, you must initialize the array. You cannot keep "nulls" or something like this there, because null is not an object, it's the reference (or pointer). When you create className* obj[n] array in C++ (which is more similar to Java className[] obj array), it's uninitialized as well.

Finally note that in Java-8 you can quite easily create all the objects instantiating them with default constructor like this:

className[] array = Stream.generate(className::new).limit(n).toArray(className[]::new);

Answer 3

What is allowed or not do is up to the language designers.

If you want to initialize all elements of an Array with a reference to the same object in Java you can use :

className[] obj = new clasName[2];
Arrays.fill(obj, new className());

or to create different objects and pass different arguments to each constructor

className[] obj = new className[] {new className(), new className()};

Answer 4

In Java, whenever you declare a variable, be it a member of an object or a local variable, it's either of primitive type (byte, char, ...) or of reference-type (pointer to object of some type).
Thus, there are no arrays of objects, only arrays of references.

In C++ you have the freedom and responsibility to choose how many indirections you do, how to allocate, free, construct and destroy objects, adding much complexity:

• dereference-operator (*pointer)
• dereference-and-use-member (pointer->member)
• address-of-operator (&object)
• a way to derive a pointer-to-type from other types (type* var).
• placement-new (`new(pointer) type(arg1, arg2);
• explicit delete-operator (delete pointer)
• much more.