Closer Look at Literals
Literals were mentioned
briefly in Chapter 2. Now that the built-in types have been formally described,
let’s take a closer look at them.
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 octal’s 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.
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 Java’s
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
9223372036854775807L is the largest long.
An integer can also be assigned to a char
as long as it is within range.
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;
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.
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
int x = 123___456___789;
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
int x = 0b1101_0101_0001_1010;
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 standard-notation 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,
314159E–05, and 2e+100.
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.
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
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
double num = 9_423_497_862.0;
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 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
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.
literals in Java are specified like they are in most other languages—by
enclosing a sequence of characters between a pair of double quotes. Examples of
string literals are
3-1 Character Escape Sequences
" \"This is in
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
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.