April 23, 2014
Hot Topics:
RSS RSS feed Download our iPhone app

Java Advanced Placement Study Guide: More on Arrays

  • February 21, 2002
  • By Richard G. Baldwin
  • Send Email »
  • More Articles »

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.

baldwin.richard@iname.com


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.

baldwin.richard@iname.com






Comment and Contribute

 


(Maximum characters: 1200). You have characters left.

 

 


Sitemap | Contact Us

Rocket Fuel