From Literals to Expressions in Java
This chapter is from the book
This chapter is from the book
This chapter is from the book
The previous chapter started a tour of Java's non-object-oriented language features. Specifically, it focused on Unicode, comments, identifiers, and types. Although those features are fundamental to all Java source code, they aren't enough to write a complete Java application. Before an application can be presented, a few more features are required. Specifically, you need to know about literals, variables, operators and separators, and expressions. This chapter introduces those new features along with application source code that demonstrates a few of the features covered in this and the previous chapter.
Literals
A value (such as an integer) can be literally specified in source code as a character sequence that conforms to specific syntax based on the value's type. The result is known as a literal. Java classifies literals as Booleans, characters, floating-point numbers, integers, nulls, and strings.
Boolean Literals
A Boolean literal is specified as either true or false. The type of that literal is Boolean.
The following code fragment (which was excerpted from Chapter 1's Craps application) demonstrates a Boolean literal:
boolean firstRoll = true;Character Literals
A character literal is specified as a single printable character (other than the single quote and backslash characters) surrounded by a pair of single quote characters. The type of that literal is character.
The following character literals represent printable characters:
|
'A' |
Capital letter A |
|
'0' |
Digit 0 |
|
'"' |
Double quote " |
|
';' |
Punctuation ; |
|
' ' |
Space |
Suppose you want to specify a single quote, a backslash, or a nonprintable character (such as a horizontal tab) as a character literal. How would you accomplish that task? The answer is to use an escape sequence. An escape sequence represents a character by using special syntax. That syntax begins with a single backslash character. (The type of a character literal composed of an escape sequence is character, as well.)
If you recall, Chapter 2 mentioned one kind of escape sequence: Unicode. Furthermore, the Unicode escape sequence's syntax was shown to consist of \uxxxx (where each x represents a hexadecimal digit). By placing that syntax between a pair of single quote characters, most characters can be represented by using character literals.
The following character literals use Unicode escape sequences to represent printable and nonprintable characters:
|
'\u0041' |
Capital letter A |
|
'\u0030' |
Digit 0 |
|
'\u0022' |
Double quote " |
|
'\u003b' |
Punctuation ; |
|
'\u0020' |
Space |
|
'\u0009' |
Horizontal Tab |
Not all characters can be represented by using character literals composed of Unicode escape sequences. For example, the Java compiler generates errors if you try to specify any of the following:
|
'\u0027' |
(a character literal representing a single quote) |
|
'\u005c' |
(a character literal representing a backslash) |
|
'\u000d' |
(a character literal representing a carriage return) |
|
'\u000a' |
(a character literal representing a newline—also known as line feed) |
Because a Unicode escape sequence cannot be used, you must consider using a special character escape sequence to represent a single quote, backslash, carriage return, or newline.
Java provides the special character escape sequence category for representing the backslash, double quote, and single quote printable characters, as well as the backspace, form feed, newline, carriage return, and horizontal tab characters. Table 3.1 summarizes those escape sequences.
Table 3.1: Special Character Escape Sequences
|
Escape Sequence |
Description |
|
\\ |
Backslash |
|
\" |
Double quote |
|
\' |
Single quote |
|
\b |
Backspace |
|
\f |
Form feed |
|
\n |
Newline |
|
\r |
Carriage return |
|
\t |
Horizontal tab |
To create a character literal that represents a character denoted by a special character escape sequence, place the special character escape sequence between a pair of single quotes. For example, the '\'' character literal represents a single quote, and the '\n' character literal represents a new-line.
In addition to the Unicode and special character escape sequence categories, Java provides octal escape sequences for representing any Unicode character whose value ranges from 0 to 255 (inclusive). An octal escape sequence consists of three digit characters (where the leftmost digit character ranges from 0 to 3 and the remaining digit characters each range from 0 to 7) that follow a single backslash character.
The following character literals use octal escape sequences to represent printable and nonprintable characters:
|
'\101' |
Capital letter A |
|
'\060' |
Digit 0 |
|
'\015' |
Carriage return |
This section's character literal examples have been biased toward the English language. However, international characters can also be represented by character literals.
The following character literals represent two international characters:
|
'\u3063' |
Hiragana letter |
|
'\u20ac' |
Euro |
The example demonstrates how to specify character literals that represent international characters by using an ASCII-based text editor. Figure 3.1 illustrates equivalent character literals that are specified by using a Unicode-based text editor.
){kind=link}
Figure 3.1 Character literals representing a Hiragana letter and the euro are displayed in a Unicode-based text editor.
Floating-Point Literals
A floating-point literal is specified as an integer part, a decimal point (represented by the period character), a fractional part, an exponent (represented by E or e), and a type suffix (represented by D, d, F, or f). At least one digit in either the integer or fractional part, and either a decimal point, an exponent, or a type suffix are required. All other parts are optional. The type of a floating-point literal defaults to double-precision floating-point. (That is also the case if a D or d type suffix is specified.) However, if an F or f type suffix is present, the type is floating-point.
The following floating-point literals represent double-precision floating-point and floating-point values.
|
6.5E+32 (or 6.5E32) |
Double-precision floating-point literal |
|
7D |
Double-precision floating-point literal |
|
.01f |
Floating-point literal |
Integer Literals
An integer literal is specified as a sequence of digits and an optional type suffix (represented by L or l). At least one digit must be specified. The type of an integer literal defaults to integer. However, if an L or l type suffix is specified, the type is long integer.
Tip
To specify a long integer literal, it is best to use the L suffix instead of l. The reason is that the lowercase letter l and digit 1 are similar in appearance—a potential source of confusion.
Integers can be specified in either the decimal, hexadecimal, or octal format. Decimal format is indicated by a leftmost nonzero digit. Hexadecimal format is indicated by the characters 0x or 0X appearing to the left of at least one hexadecimal digit—a digit 0 through 9, an uppercase letter A through F, or a lowercase letter a through f. Finally, octal format is indicated by a zero digit followed by digits that range from 0 through 7.
The following integer literals represent integer values expressed in decimal, hexadecimal, and octal format.
|
659L |
Decimal integer literal of type long integer |
|
0x4a |
Hexadecimal integer literal of type integer |
|
057L |
Octal integer literal of type long integer |
Null Literals
A null literal is specified in source code as null. That literal is often used to reduce the number of references to an object, and its type is always null. You typically assign null literals to object reference variables.
The following code fragment assumes the existence of an object referenced by e. By assigning null to e, you reduce the number of references to an object. When an object is no longer referenced, that object becomes eligible for garbage collection. (Don't worry about objects and garbage collection. Those concepts are discussed in Chapters 5 and 8, respectively.)
e = null;String Literals
A string literal consists of zero or more characters surrounded by double quote " characters. Those characters can consist of all printable characters (except for the double quote and backslash) and nonprintable characters. The double quote, backslash, and nonprintable characters are represented by escape sequences. The type of a string literal is String.
The following string literals represent sequences of characters:
Note
When the compiler encounters a string literal, it generates bytecodes that create an object of type String and store the literal's characters in that object. That situation will be examined in Chapter 12.