According to The Complete Java 2 Certification Study Guide , instance variables that are initialized when they are declared are initialized just before the class constructor is executed. Therefore, the assignment statement in the constructor changes the value in the instance variable from its initialized value of 10 to a new value of 20. Thus, you might say that the constructor has the last word in this case.

According to The Complete Java 2 Certification Study Guide by Roberts, Heller, and Ernest, "Since array size is not used until runtime, it is legal to specify size with a variable rather than a literal."

This is a very powerful capability because it means that you do not need to know the size of an array when you write and compile a program. Rather, you can defer that decision until runtime.

For example, this capability makes it possible to write code such as shown in Listing 2 . Although in this case, I initialized the value stored in the variable named size when I declared it, that value could come from anywhere (such as the length of a file) before being used to establish the size of the array.

class Q003_09{
  public static void main(
                          String args[]){
    int size = 10;
    int[] array = new int[size];
    size = 20;
    System.out.println(
              size + " " + array.length);
  }//end main()
}//end class definition

It is very important to understand, however, that once the value stored in a variable is used to establish the size of the array, changing the value stored in the variable does not cause the size of the array to change. In fact, you cannot change the size of a Java array once the object that encapsulates that array is instantiated.

Java allows you to use either of the two formats given above when you declare a reference variable that will be used to refer to a single-dimensional array object.

The significant thing is that the empty square brackets, [], can either follow the declaration of the type of elements that will be stored in the array object, or can follow the name of the reference variable.

Of course, the name of the reference variable can differ from one declaration to the next.

When you declare a reference that will later be used to refer to an array object, you must specify the type of the elements that will be stored in the array. That seems to indicate that the answer to the question should true.

It is also true that all of the elements in an array that contains primitives must be of the same primitive type. (Under certain circumstances, primitive values stored in an array will be automatically converted to the type of elements declared for the array if they are not already of that type.)

However, through the use of polymorphism, it is possible to store references to many different true types of objects in a Java array. When you store an object reference in an array, that reference can be stored in an array element that has been declared to be any of the following types:

Thus, a Java array can be a very generic container, and a simple true/false answer doesn't do a very good job of describing the actual situation.

Actually, it could be argued that there are only three kinds of things. The second and third items in the above list are both object references because an array is a special kind of object in Java. I have separated them here to highlight the fact that you should keep ordinary object references and references to Java arrays separated in your mind for a variety of reasons. One reason is that the syntax to create them is significantly different. Later, you will learn other reasons for keeping them separate in your mind, such as what kinds of conversions are allowable on ordinary object references and references to Java arrays.

All that is necessary to create a String literal in Java is to enclose none, one, or more characters inside double quotation marks.

Unlike other programming environments, double quotes and single quotes (also known as apostrophes) are not interchangeable in Java. Single quotes or apostrophes have a completely different use in Java.

The default is a 64-bit double .

These characters are used in the following ways:

The default is 32 bits. To indicate a long (64 bits) literal, append the suffix L to the literal expression. The suffix can also be lower case, but then it looks like a numeral 1 which can be very confusing.

If you preface the literal value with a single zero (0), that indicates that you are specifying the value as an octal value. An octal number is a number that is represented according to the base eight.

Octal representation was widely used in earlier days when the number of bits in each word of computer memory was often a multiple of three, such as 12, 24, 36, etc. However, with the advent of memory word sizes that are not multiples of three, the usefulness of octal representation has diminished.

In case you are interested, octal numbers consist of the following digits: 0, 1, 2, 3, 4, 5. 6. and 7. Note that there are eight unique digits in the octal number system.

If you preface the literal value with either 0x or 0X, that indicates that you are specifying the value as a hexadecimal value. A hexadecimal number is a number that is represented according to the base sixteen.

Hexadecimal numbers are formed from the following characters:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, and F.

Because the X used to preface the literal value and the letter used in the literal vale can be either upper case or lower case, there are four different ways to express the decimal value 28 in hexadecimal notation.

The following list shows six ways to express the decimal value 28 as a literal integer. Four of these use hexadecimal notation, one is octal, and the other is decimal. The second column identifies the notation being used.

-end-