基于java web技术的音乐网站外文翻译.doc

designer.

This is evidenced by the number of different approaches. The challenge seems to be in

covering all eventualities. Not only are there different sources and sinks of I/O that you want

to communicate with (files, the console, network connections, etc.), but you need to talk to

them in a wide variety of ways (sequential, random-SQLServer2000, buffered, binary,

character, by lines, by words, etc.).

The Java library designers attacked this problem by creating lots of classes. In fact, there

are so many classes for Java’s I/O system that it can be intimidating at first (ironically, the

Java I/O design actually prevents an explosion of classes). There was also a significant change

in the I/O library after Java 1.0, when the original byte-oriented library was supplemented

perspective, you will rapidly become confused with some of the classes and when you should

and shouldn’t use them.

This chapter will give you an introduction to the variety of I/O classes in the standard

Java library and how to use them.

The File class

Before getting into the classes that actually read and write data to streams, we’ll look at a

utility provided with the library to assist you in handling file directory issues.

The File class has a deceiving name; you might think it refers to a file, but it doesn’t. It

can represent either the name of a particular file or the names of a set of files in a directory. If

it’s a set of files, you can ask for that set using the list( ) method, which returns an array of

Suppose you’d like to see a directory listing. The File object can be listed in two ways. If

you call list( ) with no arguments, you’ll get the full list that the File object contains. However,

if you want a restricted list—for example, if you want all of the files with an extension

of .java—then you use a “directory filter,” which is a class that tells how to select the File

objects for display.

The DirFilter class “implements” the interface FilenameFilter. It’s useful to see how

simple the FilenameFilter interface is:

to provide its service. Because list( ) takes a FilenameFilter object as its argument, it means

that you can pass an object of any class that implements FilenameFilter to choose (even at run

time) how the list( ) method will behave. The purpose of a callback is to provide flexibility in

the behavior of code.

DirFilter shows that just because an interface contains only a set of methods, you’re not

restricted to writing only those methods. (You must at least provide definitions for all the

methods in an interface, however.) In this case, the DirFilter constructor is also created.

The accept( ) method must accept a File object representing the directory that a particular

file is found in, and a String containing the name of that file. You might choose to use or

ignore either of these arguments, but you will probably at least use the file name. Remember

Input and output

sink as an object capable of producing or receiving pieces of data. The stream hides the details

of what happens to the data inside the actual I/O device.

The Java library classes for I/O are divided by input and output, as you can see by

looking at the class hierarchy in the JDK documentation. By inheritance, everything derived

from the InputStream or Reader classes have basic methods called read( ) for reading a single

byte or array of bytes. Likewise, everything derived from OutputStream or Writer classes

have basic methods called write( ) for writing a single byte or array of bytes. However, you

won’t generally use these methods; they exist so that other classes can use them—these other

classes provide a more useful interface. Thus, you’ll rarely create your stream object by using

a single class, but instead will layer multiple objects together to provide your desired

It’s helpful to categorize the classes by their functionality. In Java 1.0, the library

designers started by deciding that all classes that had anything to do with input would be

Types of OutputStream

(no String, however; presumably, you can create one using the array of bytes), a file, or a

“pipe.”

In addition, the FilterOutputStream provides a base class for "decorator" classes that

attach attributes or useful interfaces to output streams.

Adding attributes and useful interfaces

The use of layered objects to dynamically and transparently add responsibilities to

individual objects is referred to as the Decorator pattern. (Patterns

in Patterns (with Java) at www.BruceEckel.com.) The decorator pattern specifies that all

objects that wrap around your initial object have the same interface. This makes the basic use

of the decorators transparent—you send the same message to an object whether it has been

interface, which occurs in several of the “filter” classes).

however. Decorators give you much more flexibility while you’re writing a program (since

you can easily mix and match attributes), but they add complexity to your code. The reason

that the Java I/O library is awkward to use is that you must create many classes—the “core”

I/O type plus all the decorators—in order to get the single I/O object that you want.

The classes that provide the decorator interface to control a particular InputStream or

OutputStream are the FilterInputStream and FilterOutputStream, which don’t have very

intuitive names. FilterInputStream and FilterOutputStream are derived from the base classes