Java IO.pdf - Nguyen Dang Binh

Who You Are
Java I/O
This book assumes you have a basic familiarity with Java. You should be thoroughly familiar
with the syntax of the language. You should be comfortable with object-oriented
programming, including terminology like instances, objects, and classes, and you should
know the difference between these terms. You should know what a reference is and what that
means for passing arguments to and returning values from methods. You should have written
simple applications and applets.
For the most part, I try to keep the examples relatively straightforward so that they require a
minimum of understanding of other parts of the class library outside the I/O classes. This may
lead some to deride these as "toy examples." However, I find that such examples are far more
conducive to understanding and learning than full-blown sophisticated programs that fill page
after page with graphical user interface code just to demonstrate a two-line point about I/O.
Occasionally, however, a graphical example is simply too tempting to ignore, as in the
StreamedTextArea class shown in Chapter 2 or the File Viewer application developed
throughout most of the book. I will try to keep the AWT material to a minimum, but a
familiarity with 1.1 AWT basics will be assumed.
When you encounter a topic that requires a deeper understanding for I/O than is customary—
for instance, the exact nature of strings—I'll cover that topic as well, at least briefly. However,
this is not a language tutorial, and the emphasis will always be on the I/O-specific features.
Versions
In many ways, this book was inspired by the wealth of new I/O functionality included in Java
1.1. I/O in Java 1.0 is overall much simpler, though also much less powerful. For instance,
there are no Reader and Writer classes in Java 1.0. However, there's also no reliable way to
read pure Unicode text. Furthermore, Java 1.1 added many new classes to the library for
performing a variety of I/O-related tasks like compression, encryption, digital signatures,
object serialization, encoding conversion, and much more.
Therefore, this book assumes at least Java 1.1. For the most part, Java 1.0 has been relegated
to developing applets that run inside web browsers. Because the applet security manager
severely restricts the I/O an untrusted applet can undertake, most applets do not make heavy
use of I/O, and thus it should not be a major concern.
Java 2's I/O classes are mostly identical to those in Java 1.1, with one noticeable exception.
Java 2 does a much better (though still imperfect) job of abstracting out platform-dependent
filesystem idiosyncrasies than does Java 1.1. Some (though not all) of these improvements are
also available to Java 1.1 programmers working with Swing. I'll discuss both the Java 1.1 and
Java 2 approaches to the filesystem in Chapter 12.
In any case, when I discuss a method, class or interface that's only available in Java 2, its
signature will be suffixed with a comment indicating that. For example:
public interface Replaceable extends Serializable // Java 2
8