I was asked this question recently during my job interview, and 开发者_开发百科I couldn't answer it. So, what is the most used pattern in java.io and how is it used? What are other patterns used in common java libraries?

BufferedReader etc implements decorator pattern. Any Reader, e.g. FileReader or StringReader, can be decorated with the buffering feature, which is really source-oblivious.

Other patterns

• java.util.Comparator<T> is a strategy pattern

Anti-patterns

To add to what others have said, these are several anti-patterns in the Java libraries:

Antipattern: inheritance instead of composition

From Effective Java 2nd Edition, Item 16: Favor composition over inheritance:

There are a number of obvious violations of this principle in the Java platform libraries. For example, a stack is not a vector, so Stack should not extend Vector. Similarly, a property list is not a hash table, so Properties should not extend Hashtable. In both cases, composition would have been preferable.

Related questions

• Prefer composition over inheritance?
• java inheritance versus composition (implementing a stack)
• Difference between Inheritance and Composition
• Inheritance or composition: Rely on “is-a” and “has-a”?
• Object Oriented Best Practices - Inheritance v Composition v Interfaces
• Should I use inheritance or composition?
• Inheritance vs. Aggregation
• Aggregation verses Composition
• Decorator Pattern Using Composition Instead of Inheritance

Antipattern: constant interfaces

From Effective Java 2nd Edition, Item 19: Use interfaces only to define types:

There are several constant interfaces in the Java platform libraries, such as java.io.ObjectStreamConstants. These interfaces should be regarded as anomalies and should not be emulated.

Related questions

• Should a class implement a constants-only interface?
• What is the best way to implement constants in Java ?

Antipattern: telescoping constructor and JavaBeans patterns

From Effective Java 2nd Edition, Item 2: Consider a builder when faced with many constructor parameters (excerpt online):

Traditionally, programmers have used the telescoping constructor pattern, in which you provide a constructor with only the required parameters, another with a single optional parameters, a third with two optional parameters, and so on [...] The telescoping constructor pattern works, but it is hard to write client code when there are many parameters, and harder still to write it.

A second alternative when you are faced with many constructor parameters is the JavaBeans pattern, in which you call a parameterless constructor to create the object, and then call setter methods to set each required parameter, and each optional parameter of interest. [...] Unfortunately the JavaBeans pattern has serious disadvantages of its own [...] a JavaBean may be in an inconsistent state partway through its construction [and it] precludes the possibility of making a class immutable.

Bloch recommends using a builder pattern instead.

Related questions

• Is this a well known design pattern? What is its name?
• What is the difference between Builder Design pattern and Factory Design pattern?
• When would you use the Builder Pattern?

I guess they wanted to hear about the Decorator pattern which can be found in the various Streams, Readers and Writers.

Other patterns (small selection):

• Observer pattern in the swing libraries
• Factory pattern in the javax.xml.parsers packages
• Iterator pattern, used in collections

I'm pretty sure that one can find examples for almost all patterns listed on this wikipedia page in the Java SDK.

The decorator pattern is often used in java i/o.

Example

BufferedReader br = new BufferedReader(new FileReader("filename.txt")); 

Decorator pattern, I think. To create all flavors of Readers, Writers, input and output streams. See this, for example.

Patterns used in java.io package.

1. Decorator_pattern.

   Examples:

   The abstract class java.io.FilterInputStream and its concrete subclasses : BufferedInputStream, CheckedInputStream etc

2. Abstract_factory_pattern and Factory_method_pattern patterns:

   Examples:

   The abstract class InputStream and its concrete sub classes: ByteArrayInputStream, FileInputStream, FilterInputStream etc.

   InputStream input = new FileInputStream("some_file.txt");
   

   Below classes enable unification of input from a byte-array, a file, a network connection, a persistent storage, a pipe, a string, etc:

   class java.io.InputStream 
         class java.io.ByteArrayInputStream 
         class java.io.FileInputStream 
         class java.io.FilterInputStream 
         class java.io.ObjectInputStream
         class java.io.PipedInputStream 
         class java.io.SequenceInputStream 
         class java.io.StringBufferInputStream
   

3. Adapter_pattern:

   Examples:

   java.io.InputStreamReader translates a byte stream into a character stream, and a java.io.OutputStreamWriter translates a character stream into a byte stream.

   You can find some more details in this article

4. Template_method_pattern (source: journaldev article)

   All non-abstract methods of java.io.InputStream, java.io.OutputStream, java.io.Reader and java.io.Writer.

For all other patterns in java, refer to this post:

Examples of GoF Design Patterns in Java's core libraries