Most programmers are familiar with source code that is prepared using one of two major families of character representations: ASCII and its variants (including Latin-1) and EBCDIC. Both character sets contain characters used in English and several other Western European languages.

The Java programming language, on the other hand, is written in a 16-bit encoding of Unicode. The Unicode standard originally supported a 16-bit character set, but has expanded to allow for up to 21-bit characters with a maximum value of 0x10ffff. The characters above the value 0x00ffff are termed the supplementary characters. Any particular 21-bit value is termed a code point. To allow all characters to be represented by 16-bit values, Unicode defines an encoding format called UTF-16, and this is how the Java programming language represents text. In UTF-16 all the values between 0x0000 and 0xffff map directly to Unicode characters. The supplementary characters are encoded by a pair of 16-bit values: The first value in the pair comes from the high-surrogates range, and the second comes from the low-surrogates range. Methods that want to work with individual code point values can either accept a UTF-16 encoded char[] of length two, or a single int that holds the code point directly. An individual char in a UTF-16 sequence is termed a code unit.

The first 256 characters of Unicode are the Latin-1 character set, and most of the first 128 characters of Latin-1 are equivalent to the 7-bit ASCII character set. Current environments read ASCII or Latin-1 files, converting them to Unicode on the fly.^[1]

Few existing text editors support Unicode characters, so you can use the escape sequence uxxxx to encode Unicode characters, where each x is a hexadecimal digit (0–9, and a–f or A–F to represent decimal values 10–15). This sequence can appear anywhere in code—not only in character and string constants but also in identifiers. More than one u may appear at the beginning; thus, the character can be written as u0b87 or uuu0b87.^[2] Also note that if your editor does support Unicode characters (or a subset), you may need to tell your compiler if your source code contains any character that is not part of the default character encoding for your system—such as through a command-line option that names the source character set.

Exercise 7.1: Just for fun, write a “Hello, World” program entirely using Unicode escape sequences.

Comments within source code exist for the convenience of human programmers. They play no part in the generation of code and so are ignored during scanning. There are three kinds of comments:

Comments can include any valid Unicode character, such as yin-yang (u262f), asterism (u2042), interrobang (u203d), won (u20a9), scruple (u2108), or a snowman (u2603).^[3]

Comments do not nest. This following tempting code does not compile:

/* Comment this out for now: not implemented
    /* Do some really neat stuff */
    universe.neatStuff();
*/

The first /* starts a comment; the very next */ ends it, leaving the code that follows to be parsed; and the invalid, stand-alone */ is a syntax error. The best way to remove blocks of code from programs is either to put a // at the beginning of each line or use if(false) like this:

if (false) {
    // invoke this method when it works
    dwim();
}

This technique requires that the code to be removed is complete enough to compile without error. In this case we assume that the dwim method is defined somewhere.

The tokens of a language are its basic words. A parser breaks source code into tokens and then tries to figure out which statements, identifiers, and so forth make up the code. Whitespace (spaces, tabs, newlines, and form feeds) is not significant except to separate tokens or as the contents of character or string literals. You can take any valid code and replace any amount of intertoken whitespace (whitespace outside strings and characters) with a different amount of whitespace (but not none) without changing the meaning of the program.

Whitespace must be used to separate tokens that would otherwise constitute a single token. For example, in the statement

return 0;

you cannot drop the space between return and 0 because that would create

return0;

consisting of the single identifier return0. Use extra whitespace appropriately to make your code human-readable, even though the parser ignores it. Note that the parser treats comments as whitespace.

The tokenizer is a “greedy” tokenizer. It grabs as many characters as it can to build up the next token, not caring if this creates an invalid sequence of tokens. So because ++ is longer than +, the expression

j = i+++++i;    // INVALID

is interpreted as the invalid expression

j = i++ ++ +i;  // INVALID

instead of the valid

j = i++ + ++i;

Identifiers, used for names of declared entities such as variables, constants, and labels, must start with a letter, followed by letters, digits, or both. The terms letter and digit are broad in Unicode: If something is considered a letter or digit in a human language, you can probably use it in identifiers. “Letters” can come from Armenian, Korean, Gurmukhi, Georgian, Devanagari, and almost any other script written in the world today. Thus, not only is kitty a valid identifier, but , , , , and are, too.^[4] Letters also include any currency symbol (such as $, ¥, and £) and connecting punctuation (such as _).

Any difference in characters within an identifier makes that identifier unique. Case is significant: A, a, á, À, Å, and so on are different identifiers. Characters that look the same, or nearly the same, can be confused. For example, the Latin capital letter n “N” and the Greek capital ν “”” look alike but are different characters (u004e and u039d, respectively). The only way to avoid confusion is to write each identifier in one language—and thus in one known set of characters—so that programmers trying to type the identifier will know whether you meant E or E.^[5]

Identifiers can be as long as you like, but use some taste. Identifiers that are too long are hard to use correctly and actually obscure your code.

Language keywords cannot be used as identifiers because they have special meaning within the language. The following table lists the keywords (keywords marked with a ^† are reserved but currently unused):

Although they appear to be keywords, null, true, and false are formally literals, just like the number 12, so they do not appear in the above table. However, you cannot use null, true, or false as identifiers, just as you cannot use 12 as an identifier. These words can be used as parts of identifiers, as in annulled, construe, and falsehood.

The only literal object reference is null. It can be used anywhere a reference is expected. Conventionally, null represents an invalid or uncreated object. It has no class, not even Object, but null can be assigned to any reference variable.

The boolean literals are true and false.

Character literals appear with single quotes: 'Q'. Any valid Unicode character can appear between the quotes. You can use uxxxx for Unicode characters inside character literals just as you can elsewhere. Certain special characters can be represented by an escape sequence:

Octal character constants can have three or fewer digits and cannot exceed 377 (u00ff)—for example, the character literal '12' is the same as ' '. Supplemental characters can not be represented in a character literal.

Integer constants are strings of octal, decimal, or hexadecimal digits. The start of a constant declares the number's base: A 0 (zero) starts an octal number (base 8); a 0x or 0X starts a hexadecimal number (base 16); and any other digit starts a decimal number (base 10). All the following numbers have the same value:

29 035 0x1D 0X1d

Integer constants are long if they end in L or l, such as 29L; L is preferred over l because l (lowercase L) can easily be confused with 1 (the digit one). Otherwise, integer constants are assumed to be of type int. If an int literal is directly assigned to a short, and its value is within the valid range for a short, the integer literal is treated as if it were a short literal. A similar allowance is made for integer literals assigned to byte variables. In all other cases you must explicitly cast when assigning int to short or byte (see “Explicit Type Casts” on page 219).

Floating-point constants are expressed in either decimal or hexadecimal form. The decimal form consists of a string of decimal digits with an optional decimal point, optionally followed by an exponent—the letter e or E, followed by an optionally signed integer. At least one digit must be present. All these literals denote the same floating-point number:

18.  1.8e1  .18E+2  180.0e-1

The hexadecimal form consists of 0x (or 0X), a string of hexadecimal digits with an optional hexadecimal point, followed by a mandatory binary exponent—the letter p or P, followed by an optionally signed integer. The binary exponent represents scaling by two raised to a power. All these literals also denote the same floating-point number (decimal 18.0):

0x12p0  0x1.2p4  0x.12P+8  0x120p-4

Floating-point constants are of type double unless they are specified with a trailing f or F, which makes them float constants, such as 18.0f. A trailing d or D specifies a double constant. There are two zeros: positive (0.0) and negative (-0.0). Positive and negative zero are considered equal when you use == but produce different results when used in some calculations. For example, if dividing by zero, the expression 1d/0d is +∞, whereas 1d/-0d is -∞. There are no literals to represent either infinity or NaN, only the symbolic constants defined in the Float and Double classes—see Chapter 8.

A double constant cannot be assigned directly to a float variable, even if the value of the double is within the valid float range. The only constants you may directly assign to float variables and fields are float constants.

String literals appear with double quotes: "along". Any character can be included in string literals, with the exception of newline and " (double quote). Newlines are not allowed in the middle of strings. If you want to embed a newline character in the string, use the escape sequence . To embed a double quote use the escape sequence ". A string literal references an object of type String. To learn more about strings, see Chapter 13.

Characters in strings can be specified with the octal digit syntax, but all three octal digits should be used to prevent accidents when an octal value is specified next to a valid octal digit in the string. For example, the string "116" is equivalent to " 6", whereas the string "116" is equivalent to "N".

Every type (primitive or reference) has an associated instance of class Class that represents that type. These instances are often referred to as the class object for a given type. You can name the class object for a type directly by following the type name with ".class", as in

String.class
java.lang.String.class
java.util.Iterator.class
boolean.class

The first two of these class literals refer to the same instance of class Class because String and java.lang.String are two different names for the same type. The third class literal is a reference to the Class instance for the Iterator interface mentioned on page 129. The last is the Class instance that represents the primitive type boolean.

Since class Class is generic, the actual type of the class literal for a reference type T is Class<T>, while for primitive types it is Class<W> where W is the wrapper class for that primitive type. But note, for example, that boolean.class and Boolean.class are two different objects of type Class<Boolean>. Generic types are discussed in Chapter 11, and the class Class is discussed in Chapter 16.

Exercise 7.2: Write a class that declares a field for each of the primitive numeric types, and try to assign values using the different literal forms—for example, try to assign 3.5f to an int field. Which literals can be used with which type of field? Try changing the magnitude of the values used to see if that affects things.

Fields and local variables are declared in the same way. A declaration is broken into three parts: modifiers, followed by a type, followed by a list of identifiers. Each identifier can optionally have an initializer associated with it to give it an initial value.

There is no difference between variables declared in one declaration or in multiple declarations of the same type. For example:

float x, y;

is the same as

float x;
float y;

Any initializer is expressed as an assignment (with the = operator) of an expression of the appropriate type. For example:

float x = 3.14f, y = 2.81f;

is the same as the more readable

float x = 3.14f,
      y = 2.81f;

is the same as the preferred

float x = 3.14f;
float y = 2.81f;

Field variables are members of classes, or interfaces, and are declared within the body of that class or interface. Fields can be initialized with an initializer, within an initialization block, or within a constructor, but need not be initialized at all because they have default initial values, as discussed on page 44. Field initialization and the modifiers that can be applied to fields were discussed in Chapter 2.

Local variables can be declared anywhere within a block of statements, not just at the start of the block, and can be of primitive or reference type. As a special case, a local variable declaration is also permitted within the initialization section of a for loop—see “for” on page 236. A local variable must be assigned a value before it is used.^[7] There is no default initialization value for local variables because failure to assign a starting value for one is usually a bug. The compiler will refuse to compile code that doesn't ensure that assignment takes place before a variable is used:

int x;     // uninitialized, can't use
int y = 2;
x = y * y; // now x has a value
int z = x; // okay, safe to use x

Local variables cease to exist when the flow of control reaches the end of the block in which they were declared—though any referenced object is subject to normal garbage collection rules.

Apart from annotations, the only modifier that can be applied to a local variable is final. This is required when the local variable will be accessed by a local or anonymous inner class—see also the discussion of final variables below.

Parameter variables are the parameters declared in methods, constructors, or catch blocks—see “try, catch, and finally” on page 286. A parameter declaration consists of an optional modifier, a type name, and a single identifier.

Parameters cannot have explicit initializers because they are implicitly initialized with the value of the argument passed when the method or constructor is invoked, or with a reference to the exception object caught in the catch block. Parameter variables cease to exist when the block in which they appear completes.

As with local variables, the only modifiers that can be applied to a parameter are annotations, or the final modifier.

The final modifier declares that the value of the variable is set exactly once and will thereafter always have the same value—it is immutable. Any variable—fields, local variables, or parameters—can be declared final. Variables that are final must be initialized before they are used. This is typically done directly in the declaration:

final int id = nextID++;

You can defer the initialization of a final field or local variable. Such a final variable is called a blank final. A blank final field must be initialized within an initialization block or constructor (if it's an instance field) while a blank final local variable, like any local variable, must be initialized before it is used.

Blank final fields are useful when the value of the field is determined by a constructor argument:

class NamedObj {
    final String name;

    NamedObj(String name) {
        this.name = name;
    }
}

or when you must calculate the value in something more sophisticated than an initializer expression:

static final int[] numbers = numberList();
static final int maxNumber; // max value in numbers

static {
    int max = numbers[0];
    for (int num : numbers) {
        if (num > max)
            max = num;
    }
    maxNumber = max;
}

static int[] numberList() {
    // ...
}

The compiler will verify that all static final fields are initialized by the end of any static initializer blocks, and that non-static final fields are initialized by the end of all construction paths for an object. A compile-time error will occur if the compiler cannot determine that this happens.

Blank final local variables are useful when the value to be assigned to the variable is conditional on the value of other variables. As with all local variables, the compiler will ensure that a final local variable is initialized before it is used.

Local variables and parameters are usually declared final only when they will be accessed by a local, or anonymous inner, class—though some people advocate always making parameters final, both as a matter of style, and to avoid accidentally assigning a value to a parameter, when a field or other variable was intended. Issues regarding when you should, and should not, use final on fields were discussed on page 46.

The normal modifiers can be applied to array variables, depending on whether the array is a field or local variable. The important thing to remember is that the modifiers apply to the array variable not to the elements of the array the variable references. An array variable that is declared final means that the array reference cannot be changed after initialization. It does not mean that array elements cannot be changed. There is no way to apply any modifiers (specifically final and volatile) to the elements of an array.

You can have arrays of arrays. The code to declare and print a two-dimensional matrix, for example, might look like this:

float[][] mat = new float[4][4];
setupMatrix(mat);
for (int y = 0; y < mat.length; y++) {
    for (int x = 0; x < mat[y].length; x++)

        System.out.print(mat[y][x] + " ");
    System.out.println();
}

The first (left-most) dimension of an array must be specified when the array is created. Other dimensions can be left unspecified, to be filled in later. Specifying more than the first dimension is a shorthand for a nested set of new statements. Our new creation could have been written more explicitly as:

float[][] mat = new float[4][];
for (int y = 0; y < mat.length; y++)
    mat[y] = new float[4];

One advantage of arrays of arrays is that each nested array can have a different size. You can emulate a 4×4 matrix, but you can also create an array of four int arrays, each of which has a different length sufficient to hold its own data.

When an array is created, each element is set to the default initial value for its type—zero for the numeric types, 'u0000' for char, false for boolean, and null for reference types. When you declare an array of a reference type, you are really declaring an array of variables of that type. Consider the following code:

Attr[] attrs = new Attr[12];

for (int i = 0; i < attrs.length; i++)
    attrs[i] = new Attr(names[i], values[i]);

After the initial new of the array, attrs has a reference to an array of 12 variables that are initialized to null. The Attr objects themselves are created only when the loop is executed.

You can initialize arrays with comma separated values inside braces following their declaration. The following array declaration creates and initializes an array:

String[] dangers = { "Lions", "Tigers", "Bears" };

The following code gives the same result:

String[] dangers = new String[3];

dangers[0] = "Lions";
dangers[1] = "Tigers";
dangers[2] = "Bears";

When you initialize an array within its declaration, you don't have to explicitly create the array using new—it is done implicitly for you by the system. The length of the array to create is determined by the number of initialization values given. You can use new explicitly if you prefer, but in that case you have to omit the array length, because again it is determined from the initializer list.

String[] dangers = new String[]{"Lions", "Tigers", "Bears"};

This form of array creation expression allows you to create and initialize an array anywhere. For example, you can create and initialize an array when you invoke a method:

printStrings(new String[] { "one", "two", "many" });

An unnamed array created with new in this way is called an anonymous array.

The last value in the initializer list is also allowed to have a comma after it. This is a convenience for multiline initializers so you can reorder, add, or remove values, without having to remember to add a comma to the old last line, or remove it from the new last line.

Arrays of arrays can be initialized by nesting array initializers. Here is a declaration that initializes an array to the top few rows of Pascal's triangle, with each row represented by its own array:

int[][] pascalsTriangle = {
            { 1 },
            { 1, 1 },
            { 1, 2, 1 },
            { 1, 3, 3, 1 },
            { 1, 4, 6, 4, 1 },
        };

Indices in an array of arrays work from the outermost inward. For example, in the above array, pascalsTriangle[0] refers to the int array that has one element, pascalsTriangle[1] refers to the int array that has two elements, and so forth.

For convenience, the System class provides an arraycopy method that allows you to assign the values from one array into another, instead of looping through each of the array elements—this is described in more detail in “Utility Methods” on page 665.

Arrays are implicit extensions of Object. Given a class X, classes Y and Z that extend X, and arrays of each, the class hierarchy looks something like this:

This class relationship allows polymorphism for arrays. You can assign an array to a variable of type Object and cast it back. An array of objects of type Y is usable wherever an array of objects of its supertype X is required. This seems natural but can require a run time check that is sometimes unexpected. An array of X can contain either Y or Z references, but an array of Y cannot contain references to X or Z objects. The following code would generate an ArrayStoreException at run time on either of its final two lines, which violate this rule:

Y[] yArray = new Y[3];      // a Y array
X[] xArray = yArray;        // valid: Y is assignable to X
xArray[0] = new Y();
xArray[2] = new X();        // INVALID: can't store X in Y[]
xArray[1] = new Z();        // INVALID: can't store Z in Y[]

If xArray were a reference to a real X[] object, it would be valid to store both an X and a Z object into it. But xArray actually refers to a Y[] object so it is not valid to store either an X reference or a Z reference in it. Such assignments are checked at run time if needed to ensure that no improper reference is stored into an array.

Like any other object, arrays are created and are subject to normal garbage collection mechanisms. They inherit all the methods of Object and additionally implement the Cloneable interface (see page 101) and the Serializable interface (see “Object Serialization” on page 549). Since arrays define no methods of their own, but just inherit those of Object, the equals method is always based on identity, not equivalence. The utility methods of the java.util.Arrays class—see “The Arrays Utility Class” on page 607—allow you to compare arrays for equivalence, and to calculate a hash code based on the contents of the array.

The major limitation on the “object-ness” of arrays is that they cannot be extended to add new methods. The following construct is not valid:

class ScaleVector extends double[] { // INVALID
    // ...
}

In a sense, arrays behave like final classes.

Exercise 7.3: Write a program that calculates Pascal's triangle to a depth of 12, storing each row of the triangle in an array of the appropriate length and putting each of the row arrays into an array of 12 int arrays. Design your solution so that the results are printed by a method that prints the array of arrays using the lengths of each array, not a constant 12. Now change the code to use a constant other than 12 without modifying your printing method.