A Closer Look at Literals

Literals were mentioned briefly in Chapter 2. Now that the builtin types have been formally
described, lets take a closer look at them.
Integer Literals
Integers are probably the most commonly used type in the
typical program. Any whole
number value is an integer literal. Examples are 1, 2, 3, and 42.
These are all decimal values,
meaning they are describing a base 10 number. Two other
bases that can be used in integer
literals are octal (base eight) and hexadecimal (base 16). Octal
values are denoted in Java by a
leading zero. Normal decimal numbers cannot have a leading
zero. Thus, the seemingly
valid value 09 will produce an error from the compiler, since 9
is outside of octals 0 to 7
range. A more common base for numbers used by
programmers is hexadecimal, which
matches cleanly with modulo 8 word sizes, such as 8, 16, 32,
and 64 bits. You signify a
hexadecimal constant with a leading zero-x, (0x or 0X). The
range of a hexadecimal digit is
0 to 15, so A through F (or a through f ) are substituted for 10
through 15.
Integer literals create an int value, which in Java is a 32-bit
integer value. Since Java is
strongly typed, you might be wondering how it is possible to
assign an integer literal to one
of Javas other integer types, such as byte or long, without
causing a type mismatch error.
Fortunately, such situations are easily handled. When a literal
value is assigned to a byte or
short variable, no error is generated if the literal value is within
the range of the target type.
An integer literal can always be assigned to a long variable.
However, to specify a long
literal, you will need to explicitly tell the compiler that the
literal value is of type long. You
do this by appending an upper- or lowercase L to the literal. For
example, 0x7ffffffffffffffL

or 9223372036854775807L is the largest long. An integer can

also be assigned to a char as
long as it is within range.
Beginning with JDK 7, you can also specify integer literals using
binary. To do so, prefix
the value with 0b or 0B. For example, this specifies the decimal
value 10 using a binary
literal:
int x = 0b1010;
Among other uses, the addition of binary literals makes it easier
to enter values used as
bitmasks. In such a case, the decimal (or hexadecimal)
representation of the value does not
visually convey its meaning relative to its use. The binary literal
does.
Also beginning with JDK 7, you can embed one or more
underscores in an integer
literal. Doing so makes it easier to read large integer literals.
When the literal is compiled,
the underscores are discarded. For example, given
int x = 123_456_789;
the value given to x will be 123,456,789. The underscores will
be ignored. Underscores can
only be used to separate digits. They cannot come at the
beginning or the end of a literal. It
is, however, permissible for more than one underscore to be
used between two digits. For
example, this is valid:
int x = 123___456___789;
The use of underscores in an integer literal is especially useful
when encoding such
things as telephone numbers, customer ID numbers, part
numbers, and so on. They are
also useful for providing visual groupings when specifying
binary literals. For example,
binary values are often visually grouped in four-digits units, as
shown here:
int x = 0b1101_0101_0001_1010;
Floating-Point Literals
Floating-point numbers represent decimal values with a
fractional component. They can be

expressed in either standard or scientific notation. Standard

notation consists of a whole
number component followed by a decimal point followed by a
fractional component. For
example, 2.0, 3.14159, and 0.6667 represent valid standardnotation floating-point numbers.
Scientific notation uses a standard-notation, floating-point
number plus a suffix that specifies
a power of 10 by which the number is to be multiplied. The
exponent is indicated by an E
or e followed by a decimal number, which can be positive or
negative. Examples include
6.022E23, 314159E05, and 2e+100.
Floating-point literals in Java default to double precision. To
specify a float literal, you
must append an F or f to the constant. You can also explicitly
specify a double literal by
appending a D or d. Doing so is, of course, redundant. The
default double type consumes
64 bits of storage, while the smaller float type requires only 32
bits.
Hexadecimal floating-point literals are also supported, but they
are rarely used. They
must be in a form similar to scientific notation, but a P or p,
rather than an E or e, is used.
For example, 0x12.2P2 is a valid floating-point literal. The value
following the P, called the
binary exponent, indicates the power-of-two by which the
number is multiplied. Therefore,
0x12.2P2 represents 72.5.
Beginning with JDK 7, you can embed one or more underscores
in a floating-point
literal. This feature works the same as it does for integer
literals, which were just described.
Its purpose is to make it easier to read large floating-point
literals. When the literal is
compiled, the underscores are discarded. For example, given
double num = 9_423_497_862.0;
the value given to num will be 9,423,497,862.0. The
underscores will be ignored. As is the

case with integer literals, underscores can only be used to

separate digits. They cannot
come at the beginning or the end of a literal. It is, however,
permissible for more than one
underscore to be used between two digits. It is also permissible
to use underscores in the
fractional portion of the number. For example,
double num = 9_423_497.1_0_9;
is legal. In this case, the fractional part is .109.
Boolean Literals
Boolean literals are simple. There are only two logical values
that a boolean value can have,
true and false. The values of true and false do not convert
into any numerical representation.
The true literal in Java does not equal 1, nor does the false
literal equal 0. In Java, the
Boolean literals can only be assigned to variables declared as
boolean or used in expressions
with Boolean operators.
Character Literals
Characters in Java are indices into the Unicode character set.
They are 16-bit values that
can be converted into integers and manipulated with the
integer operators, such as the
addition and subtraction operators. A literal character is
represented inside a pair of single
quotes. All of the visible ASCII characters can be directly
entered inside the quotes, such as
'a', 'z', and '@'. For characters that are impossible to enter
directly, there are several escape
sequences that allow you to enter the character you need, such
as ' \' ' for the single-quote
character itself and ' \n' for the newline character. There is also
a mechanism for directly
entering the value of a character in octal or hexadecimal. For
octal notation, use the
backslash followed by the three-digit number. For example, ' \
141' is the letter 'a'. For
hexadecimal, you enter a backslash-u ( \u), then exactly four
hexadecimal digits. For example,
' \u0061' is the ISO-Latin-1 'a' because the top byte is zero.
' \ua432 ' is a Japanese Katakana

character. Table 3-1 shows the character escape sequences.

String Literals
String literals in Java are specified like they are in most other
languagesby enclosing a
sequence of characters between a pair of double quotes.
Examples of string literals are
"Hello World"
"two\nlines"
" \"This is in quotes\""
The escape sequences and octal/hexadecimal notations that
were defined for character
literals work the same way inside of string literals. One
important thing to note about Java
strings is that they must begin and end on the same line. There
is no line-continuation
escape sequence as there is in some other languages.
NOTE As you may know, in some other languages, including
C/C++, strings are implemented as arrays of
characters. However, this is not the case in Java. Strings are
actually object types. As you will see later
in this book, because Java implements strings as objects, Java
includes extensive string-handling
capabilities that are both powerful and easy to use.