The Essence of OOP using Java, Array Objects, Part 2
The first lesson in the series was entitled The Essence of OOP Using Java, Objects, and Encapsulation. The previous lesson was entitled The Essence of OOP using Java, Array Objects, Part 1.
You may find it useful to open another copy of this lesson in a separate browser window. That will make it easier for you to scroll back and forth among the different listings while you are reading about them.
A sample program shows you three ways to emulate traditional two-dimensional rectangular arrays, and also shows you how to create and use ragged arrays.
A different syntax is required to create array objects than the syntax normally used to create ordinary objects. Array objects are accessed via references. Any of the methods of the Object class can be invoked on a reference to an array object.
The indices of a Java array object
Array objects encapsulate a group of variables, which don't have individual names. They are accessed using positive integer index values. The integer indices of a Java array object always extend from 0 to (n-1) where n is the length of the array encapsulated in the object.
All array objects in Java encapsulate one-dimensional arrays. However, the component type of an array may itself be an array type. This makes it possible to create array objects whose individual components refer to other array objects. This is the mechanism for creating multi-dimensional or ragged arrays in Java.
Such a structure of array objects can be thought of as a tree of array objects, with the data being stored in the array objects that make up the leaves of the tree.
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 by some number of empty pairs of square brackets . This
is illustrated in Listing 1, which declares a reference variable named
capable of storing a reference to a two-dimensional array of type
int v1; Listing 1
(Note that Listing 1 doesn't really declare a two-dimensional array in the traditional sense of other programming languages. Rather, it declares a reference variable capable of storing a reference to a one-dimensional array object, which in turn is capable of storing references to one-dimensional array objects of type int.)Multiple pairs of square brackets are allowed
The components in an array object may refer to other array objects. The number of bracket pairs used in the declaration of the reference variable indicates the depth of array nesting (in the sense that array elements can refer to other array objects). This is one of the ways that Java implements the concept of traditional multi-dimensional arrays (I will show you some other ways later in this lesson).
The code in Listing 1 shows two levels of nesting for the reference variable of type int.
Length not part of variable declarationAllowable types
(Note that an array's length is not part of its type or reference variable declaration.)
(Note also that multi-dimensional arrays, when implemented in this fashion, are not required to represent rectangles, cubes, etc. For example, the number of elements in each row of a Java two-dimensional array can be different. Some authors refer to this as a ragged array.)
The specified element type of an array may be any primitive or reference type. Note, however, that all elements of the array must be of the same type (consistent with the type-conversion rules discussed below).
Listing 2 shows the declaration of a reference variable capable of referring
to a three-dimensional array object of element type Button (Button
is one of the classes in the standard class library).
Button v2; Listing 2
Rules of type conversion and assignment compatibility apply
The normal rules of type conversion and assignment compatibility apply when creating and populating array objects. For example, if the specified type is the name of a non-abstract class, a null reference or a reference to any object instantiated from that class or any subclass of that class may be stored in the array element.
The generic class Object
For example, Listing 3 shows the declaration of a reference variable capable of referring to a one-dimensional array object of element type Object.
Since Object is the superclass of all other classes, this array
object is capable of storing references to objects instantiated from any
other class. (As we saw in the previous lesson, it is also capable
of storing a reference to any other array object as well.)
Object v3; Listing 3
Primitive type conversions
Similarly, 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 primitive type that is assignment compatible with the declared type (without the requirement for a cast).
For example, the code in Listing 4 shows the creation of a one-dimensional
array object capable of storing values of type int. The array
object has a length of 3 elements, and the object's reference is stored
in a reference variable named v1.
int v1; v1 = new int; byte x1 = 127; short x2 = 16384; int x3 = 32000; v1 = x1; v1 = x2; v1 = x3; Listing 4