Java IO.pdf - Nguyen Dang Binh

Java I/O
data types in Java, a byte is signed. The maximum byte value is 127. 128, 129, and so on
through 255 are not legal values for bytes.
There are no short or byte literals in Java. When you write the literal 42 or 24000, the
compiler always reads it as an int, never as a byte or a short, even when used in the righthand
side of an assignment statement to a byte or short, like this:
byte b = 42;
short s = 24000;
However, in these lines a special assignment conversion is performed by the compiler,
effectively casting the int literals to the narrower types. Because the int literals are constants
known at compile time, this is permitted. However, assignments from int variables to shorts
and bytes are not, at least not without an explicit cast. For example, consider these lines:
int i = 42;
short s = i;
byte b = i;
Compiling these lines produces the following errors:
Error: Incompatible type for declaration.
Explicit cast needed to convert int to short.
ByteTest.java line 6
Error: Incompatible type for declaration.
Explicit cast needed to convert int to byte.
ByteTest.java line 7
Note that this occurs even though the compiler is theoretically capable of determining that the
assignment does not lose information. To correct this, you must use explicit casts, like this:
int i = 42;
short s = (short) i;
byte b = (byte) i;
Even simple arithmetic with small, byte-valued constants as follows produces "Explicit cast
needed to convert int to byte" errors:
byte b = 1 + 2;
In fact, even the addition of two byte variables produces an integer result and thus cannot be
assigned to a byte variable without a cast; the following code produces that same error:
byte b1 = 22;
byte b2 = 23;
byte b3 = b1 + b2;
For these reasons, working directly with byte variables is inconvenient at best. Many of the
methods in the stream classes are documented as reading or writing bytes. However, what
they really return or accept as arguments are ints in the range of an unsigned byte (0-255).
This does not match any Java primitive data type. These ints are then converted into bytes
internally.
18