Java Enterprise Java Java Advanced Placement Study Guide: More on Arrays

Java Advanced Placement Study Guide: More on Arrays

Questions


File JavaAP012.htm


Welcome


This is one in a miniseries of tutorial lessons designed to help you learn
the essential features of Java object-oriented programming as identified
by The College Board.

Purpose

The purpose of this miniseries is to help you study for the Advanced
Placement Examinations designed by the College Board.

Once you understand everything in this miniseries, plus the material
in the lessons that I published earlier on Java
Data Structures
, you should understand the Java programming features
that the College Board considers essential for the first two semesters
of object-oriented programming education at the university level.

Approach

These lessons provide questions, answers, and explanations designed
to help you to understand the subset
of Java features covered by the Java Advanced Placement Examinations (as
of October, 2001).

Please see the first lesson in the miniseries entitled Java
Advanced Placement Study Guide: Introduction to the Lessons, Primitive
Types
, for additional background information.  The previous lesson
was entitled Java Advanced Placement Study Guide: 
Escape Character Sequences and Arrays
.

Supplementary material

In addition to the material in these lessons, I recommend that you also
study the other lessons in my extensive collection of online Java tutorials,
which are designed from a more conventional textbook approach.  You
will find those lessons published at
Gamelan.com
However, as of the date of this writing, Gamelan doesn’t maintain a consolidated
index of my Java tutorial lessons, and sometimes they are difficult to
locate there.  You will find a consolidated index at
Baldwin’s
Java Programming Tutorials
.

What is Included?

Click here for a preview of the Java
programming features covered by this lesson.



1.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  I’m OK
  • D.  None of the above
public class Ap064{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    double[] A = new double[2];
    A[0] = 1.0;
    A[1] = 2.0;
    Object B = A;
    
    System.out.println("I'm OK");
  }//end doArrays()
}// end class

Answer and Explanation

2.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1.0 2.0
  • D.  None of the above.
public class Ap065{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    double[] A = new double[2];
    A[0] = 1.0;
    A[1] = 2.0;
    Object B = A;
    
    System.out.println(
                    B[0] + " " + B[1]);
  }//end doArrays()
}// end class

Answer and Explanation

3.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1.0 2.0
  • D.  None of the above.
public class Ap066{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    double[] A = new double[2];
    A[0] = 1.0;
    A[1] = 2.0;
    Object B = A;
    
    double C = (double)B;
    System.out.println(
                    C[0] + " " + C[1]);
  }//end doArrays()
}// end class

Answer and Explanation

4.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1.0 2.0
  • D.  None of the above.
public class Ap067{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    double[] A = new double[2];
    A[0] = 1.0;
    A[1] = 2.0;
    Object B = A;
    
    double[] C = (double[])B;
    System.out.println(
                    C[0] + " " + C[1]);
  }//end doArrays()
}// end class

Answer and Explanation

5.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1.0 2.0
  • D.  None of the above.
public class Ap068{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    double[] A = new double[2];
    A[0] = 1.0;
    A[1] = 2.0;
    Object B = A;
    
    String[] C = (String[])B;
    System.out.println(
                    C[0] + " " + C[1]);
  }//end doArrays()
}// end class

Answer and Explanation

6.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap069{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    Subclass[] A = new Subclass[2];
    A[0] = new Subclass(1);
    A[1] = new Subclass(2);
    
    System.out.println(
                    A[0] + " " + A[1]);
  }//end doArrays()
}// end class

class Superclass{
  private int data;
  public Superclass(int data){
    this.data = data;
  }//end constructor
  
  public int getData(){
    return data;
  }//end getData()
    
  public String toString(){
    return "" + data;
  }//end toString()
}//end class SuperClass

class Subclass extends Superclass{
  public Subclass(int data){
    super(data);
  }//end constructor
}//end class Subclass

Answer and Explanation

7.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap070{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    Subclass[] A = new Subclass[2];
    A[0] = new Subclass(1);
    A[1] = new Subclass(2);
    
    Superclass[] B = A;
    System.out.println(
                    B[0] + " " + B[1]);
  }//end doArrays()
}// end class

class Superclass{
  private int data;
  public Superclass(int data){
    this.data = data;
  }//end constructor
  
  public int getData(){
    return data;
  }//end getData()
    
  public String toString(){
    return "" + data;
  }//end toString()
}//end class SuperClass

class Subclass extends Superclass{
  public Subclass(int data){
    super(data);
  }//end constructor
}//end class Subclass

Answer and Explanation

8.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap071{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    Superclass[] A = new Superclass[2];
    A[0] = new Superclass(1);
    A[1] = new Superclass(2);
    
    Subclass[] B = (Subclass[])A;
    System.out.println(
                    B[0] + " " + B[1]);
  }//end doArrays()
}// end class

class Superclass{
  private int data;
  public Superclass(int data){
    this.data = data;
  }//end constructor
  
  public int getData(){
    return data;
  }//end getData()
    
  public String toString(){
    return "" + data;
  }//end toString()
}//end class SuperClass

class Subclass extends Superclass{
  public Subclass(int data){
    super(data);
  }//end constructor
}//end class Subclass

Answer and Explanation

9.  What output is produced by the following program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap072{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    Subclass[] A = new Subclass[2];
    A[0] = new Subclass(1);
    A[1] = new Subclass(2);
    
    Superclass[] B = A;
    Subclass[] C = (Subclass[])B;
    System.out.println(
                    C[0] + " " + C[1]);
  }//end doArrays()
}// end class

class Superclass{
  private int data;
  public Superclass(int data){
    this.data = data;
  }//end constructor
  
  public int getData(){
    return data;
  }//end getData()
    
  public String toString(){
    return "" + data;
  }//end toString()
}//end class SuperClass

class Subclass extends Superclass{
  public Subclass(int data){
    super(data);
  }//end constructor
}//end class Subclass

Answer and Explanation

10.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1.0 2.0
  • D.  D.  None of the above
public class Ap073{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    double[] A = new double[2];
    A[0] = 1.0;
    A[1] = 2.0;
    Object B = A;
    
    System.out.println(
              ((double[])B)[0] + " " + 
              ((double[])B)[1]);
  }//end doArrays()
}// end class

Answer and Explanation

11.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap074{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    int[] A = new int[2];
    A[0] = 1;
    A[1] = 2;
    
    double[] B = (double[])A;

    
    System.out.println(
                    B[0] + " " + B[1]);
  }//end doArrays()
}// end class

Answer and Explanation

12.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap075{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    int[] B = returnArray();
    for(int i = 0; i < B.length;i++){
      System.out.print(B[i] + " ");
    }//end for loop
    System.out.println();
  }//end doArrays()
    
  public int[] returnArray(){
    int[] A = new int[2];
    A[0] = 1;
    A[1] = 2;
    return A;
  }//end returnArray()
}// end class

Answer and Explanation

13.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  0 0 0
  •     0 1 2

  • D.  None of the above
public class Ap076{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    int[] A[];
    A = new int[2][3]; 
    
    for(int i=0; i<A.length;i++){
      for(int j=0;j<A[0].length;j++){
        A[i][j] = i*j;
      }//end inner loop
    }//end outer loop

    for(int i=0; i<A.length;i++){
      for(int j=0;j<A[0].length;j++){
        System.out.print(
                        A[i][j] + " ");
      }//end inner loop
      System.out.println();
    }//end outer loop

  }//end doArrays()
}// end class

Answer and Explanation

14.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  1 2
  • D.  None of the above
public class Ap077{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    Subclass[] A = new Subclass[2];
    A[0] = new Subclass(1);
    A[1] = new Subclass(2);
    
    Object X = A;
    Superclass B = A;
    Subclass[] C = (Subclass[])B;
    Subclass[] Y = (Subclass[])X;
    System.out.println(
                    C[0] + " " + Y[1]);
  }//end doArrays()
}// end class

class Superclass{
  private int data;
  public Superclass(int data){
    this.data = data;
  }//end constructor
  
  public int getData(){
    return data;
  }//end getData()
    
  public String toString(){
    return "" + data;
  }//end toString()
}//end class SuperClass

class Subclass extends Superclass{
  public Subclass(int data){
    super(data);
  }//end constructor
}//end class Subclass

Answer and Explanation

15.  What output is produced by the following
program?

  • A.  Compiler Error
  • B.  Runtime Error
  • C.  0 0.0 false 0
  • D.  None of the above
public class Ap078{
  public static void main(
                        String args[]){
    new Worker().doArrays();
  }//end main()
}//end class definition

class Worker{
  public void doArrays(){
    int[] A = new int[1];
    double[] B = new double[1];
    boolean[] C = new boolean[1];
    int[] D = new int[0];
    
    System.out.println(A[0] + " " +
                       B[0] + " " +
                       C[0] + " " +
                       D.length);
  
  }//end doArrays()
}// end class

Answer and Explanation



Copyright 2002, Richard G. Baldwin.  Reproduction in whole or
in part in any form or medium without express written permission from Richard
Baldwin is prohibited.

About the author

Richard Baldwin
is a college professor (at Austin Community College in Austin, TX) and
private consultant whose primary focus is a combination of Java and XML.
In addition to the many platform-independent benefits of Java applications,
he believes that a combination of Java and XML will become the primary
driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects involving
Java, XML, or a combination of the two.  He frequently provides onsite
Java and/or XML training at the high-tech companies located in and around
Austin, Texas.  He is the author of Baldwin’s Java Programming Tutorials,
which has gained a worldwide following among experienced and aspiring Java
programmers. He has also published articles on Java Programming in Java
Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and
has many years of experience in the application of computer technology
to real-world problems.

[email protected]


What is Included?


According to the subset
document,

“Arrays: 1-dimensional arrays and 2-dimensional rectangular
arrays are part of the AP CS subset. Both arrays of primitive types (e.g.
int[]
and arrays of objects (e.g. Student[]) are tested. Initialization
of named arrays (int[] a = { 1, 2, 3 };) is part of the AP CS
subset.  … students are expected to know that a[0].length
is the number of columns in a rectangular two-dimensional array a.”


Answers and Explanations

Answer 15


C.  0 0.0 false 0

Back to Question 15

Explanation 15


You can initialize array elements

You can create a new array object and initialize
its elements using statements similar to the following:

int[] A = {22, 43, 69};

X[] B = {new X(32), new X(21)};

What if you don’t initialize array elements?

If you create a new array object without
initializing its elements, the value of each element in the array is automatically
initialized to a default value.

Illustrating array element default initialization

This program illustrates default initialization
of int, double, and boolean arrays.

The default values are as follows:

  • zero for all numeric values
  • false for all boolean values
  • all zero bits for char values (char is
    not on AP CS exam)
  • null for object references

An array with no elements …

This program also illustrates that it is possible
to have an array object in Java that has no elements.  In this case,
the value of the length property for the array object is 0.

Give me an example

For example, when the user doesn’t enter any arguments
on the command line for a Java application, the incoming parameter String
array to the main() method has a length value of 0.

Another example

It is also possible that methods that return a
reference to an array object may sometimes return a reference to an array
whose length is 0.  The method must satisfy the return type
requirement by returning a reference to an array object.  Sometimes,
there is no data to be used to populate the array, so the method will simply
return a reference to an array object with a length property value
of 0.

Answer 14


A.  Compiler Error

Back to Question 14

Explanation 14


Assigning array reference to type Object

As you learned in an earlier lesson, you can assign
an array object’s reference to an ordinary reference variable of the type
Object
It is not necessary to indicate that the reference variable is a reference
to an array by appending square brackets to the type name or the variable
name.

Only works with type Object

However, you cannot assign an array object’s reference
to an ordinary reference variable of any other type.  For any type
other than Object, the reference variable must be declared to hold
a reference to an array object by appending empty square brackets onto
the type name or the variable name.

The first statement in the following fragment
compiles successfully.


 

    Object X = A;
    Superclass B = A;

However, the second statement in the above fragment
produces a compiler error under JDK 1.3, which is partially reproduced
below.

Both Superclass and Object are superclasses
of the array type referred to by the reference variable named A
However, because of the above rule, in order to cause this program to compile
successfully, you would need to modify it as shown below by adding the
requisite empty square brackets to the Superclass type name.


 

    Object X = A;
    Superclass[] B = A;

Ap077.java:22: incompatible types

found   : Subclass[]

required: Superclass

    Superclass B = A;

Answer 13


C.  0 0 0

    0 1 2

Back to Question 13

Explanation 13


Syntactical ugliness

As I indicated in an earlier lesson, when declaring
a reference variable that will refer to an array object, you can place
the empty square brackets next to the name of the type or next to the name
of the reference variable.  In other words, either of the following
formats will work.


 

    int[][] A;
    int B[][]; 

What I didn’t tell you at that time is that you
can place some of the empty square brackets in one location and the remainder
in the other location.

Really ugly syntax

This is indicated by the following fragment, which
declares a reference variable for a two-dimensional array of type int
Then it creates the two-dimensional array object and assigns the array
object’s reference to the reference variable.


 

    int[] A[];
    A = new int[2][3]; 

While it doesn’t matter which location you use
for the square brackets in the declaration, it does matter how many pairs
of square brackets you place in the two locations combined.  The number 
of dimensions on the array (if you want to think of a Java array as
having dimensions)
will equal the total number of pairs of square brackets. 
Thus, in this case, the array is a two-dimensional array because there
is one pair of square brackets next to the type and another pair next to
the variable name.

This program goes on to use nested for
loops to populate the array and then to display the contents of the elements.

I personally don’t use this syntax, and I hope
that you don’t either.  However, even if you don’t use it, you need
to be able to recognize it when used by others.

Answer 12


C.  1 2

Back to Question 12

Explanation 12


The length property

This program illustrates the use of the array
property named length, whose value always matches the number of
elements in the array.

As a Java programmer, you will frequently invoke
methods that will return a reference to an array object of a specified
type, but of an unknown length.  (See, for example, the method
named getEventSetDescriptors() that is declared in the interface named
BeanInfo.)
  This program simulates that situation.

Returning a reference to an array

The method named returnArray() returns
a reference to an array of type int having two elements.  Although
I fixed the size of the array in this example, I could just as easily have
used a random number to set a different size for the array each time the
method is called.  Therefore, the doArrays() method making
the call to the method named returnArray() has no way of knowing
the size of the array referred to by the reference that it receives as
a return value.

All array objects have a length property

This could be a problem, but Java provides the
solution to the problem in the length property belonging to all
array objects.

The for loop in the method named doArrays()
uses the length property of the array to determine how many elements
it needs to display.  This is a very common scenario in Java.

Answer 11


A.  Compiler Error

Back to Question 11

Explanation 11


You cannot cast primitive array references

You cannot cast an array reference from
one primitive type to another primitive type, even if the individual elements
in the array are of a type that can normally be converted to the new type.

This program attempts to cast a reference to an
array of type int[] and assign it to a reference variable of type
double[].  Normally, a value of type int will be automatically
converted to type double whenever there is a need for such a conversion. 
However, this attempted cast produces the following compiler error under
JDK 1.3.

Ap074.java:19: inconvertible types

found   : int[]

required: double[]

    double[] B = (double[])A;

Why is this cast not allowed?

I can’t give you a firm reason why such a cast
is not allowed, but I believe that I have a good idea why.  I speculate
that this is due to the fact that the actual primitive values are physically
stored in the array object, and primitive values of different types require
different amounts of storage.  For example, the type int requires
32 bits of storage while the type double requires 64 bits of storage.

Would require reconstructing the array object

Therefore, to convert an array object containing
int values to an array object containing double values would
require reconstructing the array object and allocating twice as much storage
space for each element in the array.

Restriction doesn’t apply to arrays of references

As you have seen from previous questions, such
a casting restriction does not apply to arrays containing references to
objects.  This may be because the amount of storage required to store
a reference to an object is the same, regardless of the type of the object. 
Therefore, the allowable casts that you have seen in the previous questions
did not require any change to the size of the array.  All that changed
was some supplemental information regarding the type of objects to which
the elements in the array refer.

Answer 10


C.  1.0 2.0

Back to Question 10

Explanation 10


Assigning array reference to variable of type
Object

A reference to an array can be assigned to a non-array
reference of the class named Object, as in the following statement
extracted from the program, where A is a reference to an array object
of type double.


 

    Object B = A;

Note that there are no square brackets
anywhere in the above statement.  Thus, the reference to the array
object is not being assigned to an array reference of the type Object[]
Rather, it is being assigned to an ordinary reference variable of the type
Object.

Downcasting to an array type

Once the array reference has been assigned to
the ordinary reference variable of the type Object, that reference
variable can be downcast and used to access the individual elements in
the array as illustrated in the following fragment.  Note the square
brackets in the syntax of the cast operator: (double[]).


 

    
    System.out.println(
               ((double[])B)[0] + " " + 
               ((double[])B)[1]);

Parentheses are critical

Note also that due to precedence issues, the placement
of both sets of parentheses is critical in the above code fragment. 
You must downcast the reference variable before applying the index to that
variable.


 

Answer 9


C.  1 2

Back to Question 9

Explanation 9


General array casting rule

The general rule for casting array references
(for arrays whose declared type is the name of a class or an interface)
is:

A reference to an array object can be
cast to another array type if the elements of the referenced array are
of a type that can be cast to the type of the elements of the specified
array type.

Old rules apply here also

Thus, the general rules covering conversion and
casting up and down the inheritance hierarchy and among classes that implement
the same interfaces also apply to the casting of references to array objects.

A reference to an object can be cast down the
inheritance hierarchy to the actual class of the object.  Therefore,
an array reference can also be cast down the inheritance hierarchy to the
declared class for the array object.

This program declares a reference to, creates,
and populates an array of the class type Subclass.  This reference
is assigned to an array reference of a type that is a superclass of the
actual class type of the array.  Then the superclass reference is
downcast to the actual class type of the array and assigned to a different
reference variable.  This third reference variable is used to successfully
access and display the contents of the elements in the array.


 

Answer 8


B.  Runtime Error

Back to Question 8

Explanation 8


Another ClassCastException

While it is allowable to assign an array reference
to an array reference variable declared for a class that is further up
the inheritance hierarchy (as illustrated earlier), it is not allowable
to cast an array reference down the inheritance hierarchy to a subclass
of the original declared class for the array.

This program declares a reference for, creates,
and populates a two-element array for a class named Superclass
Then it downcasts that reference to a subclass of the class named Superclass
The compiler is unable to determine that this is a problem.  However,
the runtime system throws the following exception, which terminates the
program at runtime.

java.lang.ClassCastException: [LSuperclass;

 at Worker.doArrays(Ap071.java:19)

 at Ap071.main(Ap071.java:9)

Answer 7


C.  1 2

Back to Question 7

Explanation 7


Assignment to superclass array reference variable

This program illustrates that, if you have a reference to an array object
containing references to other objects, you can assign the array object’s
reference to an array reference variable whose type is a superclass of
the declared class of the array object.  (As we will see later,
this doesn’t work for array objects containing primitive values.)

What can you do then?

Having made the assignment to the superclass reference variable, whether
or not you can do anything useful with the elements in the array (without
downcasting)
depends on many factors.

No downcast required in this case

In this case, the ability to display the contents of the objects referred
to in the array was inherited from the class named Superclass
Therefore, it is possible to access and display a String representation
of the objects without downcasting the array object reference from Superclass
to the actual type of the objects.

Probably need to downcast in most cases

However, that will often not be the case.  In most cases, when
using a reference of a superclass type, you will probably need to downcast
in order to make effective use of the elements in the array object.

Answer 6


C.  1 2

Back to Question 6

Explanation 6


Straightforward array application

This is a straightforward application of Java
array technology for the storage and retrieval of references to objects.

The program declares a reference to, creates,
and populates a two-element array of a class named Subclass
The class named Subclass extends the class named Superclass,
which in turn, extends the class named Object by default.

The super keyword

The class named Subclass doesn’t do anything
particularly useful other than to illustrate extending a class.

However, it also provides a preview of the use
of the super keyword for the purpose of causing a constructor in
a subclass to invoke a parameterized constructor in its superclass.

Setting the stage for future questions

The main purpose for showing you this program
is to set the stage for several programs that will be using this class
structure in subsequent questions.

Answer 5


B.  Runtime Error

Back to Question 5

Explanation 5


ClassCastException

There are some situations involving casting where the compiler cannot
identify an erroneous condition that is later identified by the runtime
system.  This is one of those cases.

This program begins with an array of type double[].  The
reference to that array is converted to type Object.  Then
it is cast to type String[].  All of these operations are allowed
by the compiler.

However, at runtime, the runtime system expects to find references to
objects of type String in the elements of the array.  What
it finds instead is values of type double stored in the elements
of the array.

As a result, a ClassCastException is thrown.  Since
it isn’t caught and handled by the program, the program terminates with
the following error message showing on the screen.

java.lang.ClassCastException: [D

 at Worker.doArrays(Ap068.java:17)

 at Ap068.main(Ap068.java:6)

 

Answer 4


C.  1.0 2.0

Back to Question 4

Explanation 4


Finally, we got it right

Finally, we managed to get it all together. 
The program compiles and executes correctly.  This program illustrates
the assignment of an array object’s reference to a reference variable of
type Object, and the casting of that reference of type Object
back to the correct array type in order to gain access to the elements
in the array.

But don’t go away, there is a lot more that you
need to know about arrays in Java.  We will look at some of those
things in the questions that follow.

Answer 3


A.  Compiler Error

Back to Question 3

Explanation 3


Must use the correct cast syntax

While it is possible to store an array object’s
reference in a reference variable of type Object, and later cast
it back to an array type to gain access to the elements in the array, you
must use the correct syntax in performing the cast.  This is not the
correct syntax for performing that cast.  It is missing the empty
square brackets required to indicate a reference to an array object.

A portion of the compiler error produced by JDK
1.3 is shown below:

Ap066.java:17: inconvertible types

found   : java.lang.Object

required: double

    double C = (double)B;

Answer 2


A.  Compiler Error

Back to Question 2

Explanation 2


Must cast back to an array type

This program illustrates another very important point.  Although
you can assign an array object’s reference to a reference variable of type
Object,
you cannot gain access to the elements in the array while treating it as
type Object.  Rather, you must cast it back to an array type
before you can gain access to the elements in the array object.

A portion of the compiler error produced by JDK 1.3 is shown below:

Ap065.java:18: array required, but java.lang.Object found

B[0] + " " + B[1]);

 

Answer 1


C.  I’m OK

Back to Question 1

Explanation 1


Assigning array reference to type Object

This program illustrates a very important point.  You can assign
an array object’s reference to an ordinary reference variable of type Object
Note that I didn’t say Object[].  The empty square brackets
are not required when the type is Object.

Standard containers or collections

Later on, when we study the various containers in the Java class libraries
(see the Java Collections Framework), we will see that they store
references to all objects, including array objects, as type Object
Thus, if it were not possible to store a reference to an array object in
a reference variable of type Object, it would not be possible to
use the standard containers to store references to array objects.

Because it is possible to assign an array object’s reference to a variable
of type Object, it is also possible to store array object references
in containers of type Object.

About the author

Richard Baldwin
is a college professor (at Austin Community College in Austin, TX) and
private consultant whose primary focus is a combination of Java and XML.
In addition to the many platform-independent benefits of Java applications,
he believes that a combination of Java and XML will become the primary
driving force in the delivery of structured information on the Web.

Richard has participated in numerous consulting projects involving
Java, XML, or a combination of the two.  He frequently provides onsite
Java and/or XML training at the high-tech companies located in and around
Austin, Texas.  He is the author of Baldwin’s Java Programming Tutorials,
which has gained a worldwide following among experienced and aspiring Java
programmers. He has also published articles on Java Programming in Java
Pro magazine.

Richard holds an MSEE degree from Southern Methodist University and
has many years of experience in the application of computer technology
to real-world problems.

[email protected]

Latest Posts

Related Stories