Java Reference
In-Depth Information
As a consequence of how we've defined things, in this repre‐
sentation we have a very simple way to identify whether a bit
pattern corresponds to a negative number: if the high-end bit
of a bit pattern is a
1
, then the number being represented is
negative.
Consider the bit pattern consisting of all set bits:
0b1111_1111
. If we add
1
to this
number, then the result will overflow the 8 bits of storage that a
byte
has, resulting
in
0b1_0000_0000
. If we want to constrain this to fit within the
byte
data type, then
we should ignore the overflow, so this becomes
0b0000_0000
- zero. It is therefore
natural to adopt the representation that “all set bits is
-1
.” This allows for natural
arithmetic behavior, like this:
b
=
(
byte
)
0
b1111_1111
;
// -1
System
.
out
.
println
(
b
);
b
++;
System
.
out
.
println
(
b
);
b
=
(
byte
)
0
b1111_1110
;
// -2
System
.
out
.
println
(
b
);
b
++;
System
.
out
.
println
(
b
);
Finally, let's look at the number that
0b1000_0000
represents. It's the most negative
number that the type can represent, so for
byte
:
b
=
(
byte
)
0
b1000_0000
;
System
.
out
.
println
(
b
);
// -128
This representation is called
two's complement
, and is the most common representa‐
tion for signed integers. To use it effectively, there are only two points that you need
to remember:
• A bit pattern of all 1's is the representation for -1.
• If the high bit is set, the number is negative.
Java's other integer types (
short
,
int
, and
long
) behave in very similar ways but
with more bits in their representation. The
char
datatype is different because it rep‐
resents a Unicode character, but in some ways behaves as an unsigned 16-bit
numeric type. It is not normally regarded as an integer type by Java programmers.
Java and Floating-Point Numbers
Computers represent numbers using binary. We've seen how Java uses the two's
complement representation for integers. But what about fractions or decimals? Java,
like almost all modern programming languages, represents them using
loating-
point arithmetic
. Let's take a look at how this works, first in base-10 (regular deci‐
mal) and then in binary. Java defines the two most important mathematical con‐
stants,
e
and
π
as constants in
java.lang.Math
like this:
