Java Reference

In-Depth Information

Integer binary literals start with
0b
and may, of course, only feature the digits 1 or 0.

As binary literals can be very long, underscores are often used as part of a binary

literal. The underscore character is ignored whenever it is encountered in any

numerical literal—it's allowed purely to help with readability of literals.

Java also supports octal (base-8) integer literals. These literals begin with a leading
0

and cannot include the digits 8 or 9. They are not often used and should be avoided

unless needed. Legal hexadecimal, binary, and octal literals include:

0xff
// Decimal 255, expressed in hexadecimal

0377
// The same number, expressed in octal (base 8)

0
b0010_1111
// Decimal 47, expressed in binary

0xCAFEBABE
// A magic number used to identify Java class files

Integer literals are 32-bit
int
values unless they end with the character
L
or
l
, in

which case they are 64-bit
long
values:

1234
// An int value

1234L
// A long value

0xff
L
// Another long value

Integer arithmetic in Java never produces an overflow or an underflow when you

exceed the range of a given integer type. Instead, numbers just wrap around. For

example:

byte
b1
=
127
,
b2
=
1
;
// Largest byte is 127

byte
sum
=
(
byte
)(
b1
+
b2
);
// Sum wraps to -128, the smallest byte

Neither the Java compiler nor the Java interpreter warns you in any way when this

occurs. When doing integer arithmetic, you simply must ensure that the type you

are using has a sufficient range for the purposes you intend. Integer division by zero

and modulo by zero are illegal and cause an
ArithmeticException
to be thrown.

Each integer type has a corresponding wrapper class:
Byte
,
Short
,
Integer
, and

Long
. Each of these classes defines
MIN_VALUE
and
MAX_VALUE
constants that

describe the range of the type. The classes also define useful static methods, such as

Byte.parseByte()
and
Integer.parseInt()
, for converting strings to

integer values.

Floating-Point Types

Real numbers in Java are represented by the
float
and
double
data types. As shown

in
Table 2-1
,
float
is a 32-bit, single-precision floating-point value, and
double
is a

64-bit, double-precision floating-point value. Both types adhere to the IEEE

754-1985 standard, which specifies both the format of the numbers and the behav‐

ior of arithmetic for the numbers.

Floating-point values can be included literally in a Java program as an optional

string of digits, followed by a decimal point and another string of digits. Here are

some examples: