| << Chapter < Page | Chapter >> Page > |
Similar to previous code
The code in Listing 24 is similar to code that you saw earlier. The differences are:
Display the output
Finally, Listing 25 displays the int values stored in the elements of the leaf array objects.
| Listing 25 . Display the output. |
|---|
for(int i=0;i<v6.length;i++){
for(int j=0;j<((int[])v6[i]).length;j++){
System.out.print(((int[] |
The code in Listing 25 is very similar to what you have seen before, and there should be no requirement for an explanation of this code.
The code in Listing 25 produces the following output:
4 6 8 10 12 14 16
6 9 12
I will leave it as an exercise for the student to correlate the output with the code.
When declaring a reference variable capable of referring to an array object, the array type is declared by writing the name of an element type followed bysome number of empty pairs of square brackets [].
The components in an array object may refer to other array objects. The number of bracket pairs used in the declaration of the reference variableindicates the depth of array nesting (in the sense that array elements can refer to other array objects).
An array's length is not part of its type or reference variable declaration.
Multi-dimensional arrays are not required to represent rectangles, cubes, etc. They can be ragged.
The normal rules of type conversion and assignment compatibility apply when creating and populating array objects.
Object is the superclass of all other classes. Therefore, an array of element type Object is capable of storing references to objects instantiated from any other class. The type declaration for such anarray object would be Object[] .
An array of element type Object is also capable of storing references to any other array object.
If the declared element type for the array object is one of the primitive types, the elements of the array can be used to store values of any primitivetype that is assignment compatible with the declared type (without the requirement for a cast).
If the declared element type is the name of a class, (which may or may not be abstract), a null reference or a reference to any object instantiated from the class or any subclass of the class may be stored in thearray element.
If the declared element type is an interface type, a null reference or a reference to any object instantiated from any class that implements theinterface can be stored in the array element.
A reference variable whose declared type is an array type does not contain an array. Rather, it contains either null, or a reference to anarray object. Declaring the reference variable does not create an array, nor does it allocate any space for the array components.
It is possible to declare a reference to an array object and initialize it with a reference to an array object when it is declared.
A reference to an array object can refer to different array objects (of the same element type and different lengths) at different points in the execution of a program.
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|