Core Java

Design Patterns in the JDK

Brian Du Preez, our JCG partner from Zen in the art of IT has made a very fine job of collecting the most common design patterns found in the JDK. The pattern list is indeed impressive and long, so let us babble no more and present it to you.

I saw an article (well more of a rant) the other day, by Rob Williams Brain Drain in enterprise Dev. I have to say, I do agree with some of what he is saying. I know from my personal experience, I had spent a good 2 or so years just wallowing in the enterprise development world, not learning anything and actually losing my skills I developed before. The corporate confront zone is not conducive to eager technologists.

In this article he also stated:

“1 in 10 cant even pass a simple test like ‘which design pattern is used in the streams library that makes BufferedReader interchangeable with a FileReader?'”

I also tested it at work and I only had 1 out of the 8 people asked that got it right

Without much confidence, I had guessed Decorator based on “interchangeable”. I then decided that was actually some worth sneaking into future interviews, and probably a good time to revise a little.

So I went scouring the internet to find all I could on the topic and I didn’t actually find as much as I thought I would. Most of it came from BalusC at Stackoverflow, the rest was very scattered between blog posts, java ranch, some old pdf’s and articles I had. I didn’t take every single example of every single pattern I found, but rather the common ones.

This may be a good way for people to learn about patterns, quite often they are using them everyday without realizing.


This is used to convert the programming interface/class into that of another.

  • java.util.Arrays#asList()
  • javax.swing.JTable(TableModel)
  • javax.xml.bind.annotation.adapters.XmlAdapter#marshal()
  • javax.xml.bind.annotation.adapters.XmlAdapter#unmarshal()

This decouples an abstraction from the implementation of its abstract operations, so that the abstraction and its implementation can vary independently.

  • AWT (It provides an abstraction layer which maps onto the native OS the windowing support.)
  • JDBC

Lets clients treat individual objects and compositions of objects uniformly. So in other words methods on a type accepting the same type.

  • javax.swing.JComponent#add(Component)
  • java.awt.Container#add(Component)
  • java.util.Map#putAll(Map)
  • java.util.List#addAll(Collection)
  • java.util.Set#addAll(Collection)

Attach additional responsibilities to an object dynamically and therefore it is also an alternative to subclassing. Can be seen when creating a type passes in the same type. This is actually used all over the JDK, the more you look the more you find, so the list below is definitely not complete.

  • java.util.Collections#checked[List|Map|Set|SortedSet|SortedMap]()

To provide a simplified interface to a group of components, interfaces, abstractions or subsystems.

  • java.lang.Class
  • javax.faces.webapp.FacesServlet

Caching to support large numbers of smaller objects efficiently. I stumbled apon this a couple months back.

  • java.lang.Integer#valueOf(int)
  • java.lang.Boolean#valueOf(boolean)
  • java.lang.Byte#valueOf(byte)
  • java.lang.Character#valueOf(char)

The Proxy pattern is used to represent with a simpler object an object that is complex or time consuming to create.

  • java.lang.reflect.Proxy
  • RMI


Abstract factory:
To provide a contract for creating families of related or dependent objects without having to specify their concrete classes. It enables one to decouple an application from the concrete implementation of an entire framework one is using. This is also found all over the JDK and a lot of frameworks like Spring. They are simple to spot, any method that is used to create an object but still returns a interface or abstract class.

  • java.util.Calendar#getInstance()
  • java.util.Arrays#asList()
  • java.util.ResourceBundle#getBundle()
  • java.sql.DriverManager#getConnection()
  • java.sql.Connection#createStatement()
  • java.sql.Statement#executeQuery()
  • java.text.NumberFormat#getInstance()
  • javax.xml.transform.TransformerFactory#newInstance()

Used simplify complex object creation by defining a class whose purpose is to build instances of another class. The builder pattern also allows for the implementation of a Fluent Interface.

  • java.lang.StringBuilder#append()
  • java.lang.StringBuffer#append()
  • java.sql.PreparedStatement
  • javax.swing.GroupLayout.Group#addComponent()

Factory method:
Simply a method that returns an actual type.

  • java.lang.Proxy#newProxyInstance()
  • java.lang.Object#toString()
  • java.lang.Class#newInstance()
  • java.lang.reflect.Array#newInstance()
  • java.lang.reflect.Constructor#newInstance()
  • java.lang.Boolean#valueOf(String)
  • java.lang.Class#forName()

Allows for classes whose instances can create duplicates of themselves. This can be used when creating an instance of a class is very time-consuming or complex in some way, rather than creating new instances, you can make copies of the original instance and modify it.

  • java.lang.Object#clone()
  • java.lang.Cloneable

This tries to ensure that there is only a single instance of a class. I didn’t find an example but another solution would be to use an Enum as Joshua Bloch suggests in Effective Java.

  • java.lang.Runtime#getRuntime()
  • java.awt.Toolkit#getDefaultToolkit()
  • java.awt.GraphicsEnvironment#getLocalGraphicsEnvironment()
  • java.awt.Desktop#getDesktop()


Chain of responsibility:
Allows for the decoupling between objects by passing a request from one object to the next in a chain until the request is recognized. The objects in the chain are different implementations of the same interface or abstract class.

  • java.util.logging.Logger#log()
  • javax.servlet.Filter#doFilter()

To wrap a command in an object so that it can be stored, passed into methods, and returned like any other object.

  • java.lang.Runnable
  • javax.swing.Action

This pattern generally describes defining a grammar for that language and using that grammar to interpret statements in that format.

  • java.util.Pattern
  • java.text.Normalizer
  • java.text.Format

To provide a consistent way to sequentially access items in a collection that is independent of and separate from the underlying collection.

  • java.util.Iterator
  • java.util.Enumeration

Used to reduce the number of direct dependencies between classes by introducing a single object that manages message distribution.

  • java.util.Timer
  • java.util.concurrent.Executor#execute()
  • java.util.concurrent.ExecutorService#submit()
  • java.lang.reflect.Method#invoke()

This is a snapshot of an object’s state, so that the object can return to its original state without having to reveal it’s content. Date does this by actually having a long value internally.

  • java.util.Date

Null Object:
This can be used encapsulate the absence of an object by providing an alternative ‘do nothing’ behavior. It allows you to abstract the handling of null objects.

  • java.util.Collections#emptyList()
  • java.util.Collections#emptyMap()
  • java.util.Collections#emptySet()

Used to provide a way for a component to flexibly broadcast messages to interested receivers.

  • java.util.EventListener
  • javax.servlet.http.HttpSessionBindingListener
  • javax.servlet.http.HttpSessionAttributeListener
  • javax.faces.event.PhaseListener

This allows you easily change an object’s behavior at runtime based on internal state.

  • java.util.Iterator
  • javax.faces.lifecycle.LifeCycle#execute()

Is intended to provide a means to define a family of algorithms, encapsulate each one as an object. These can then be flexibly passed in to change the functionality.

  • java.util.Comparator#compare()
  • javax.servlet.http.HttpServlet
  • javax.servlet.Filter#doFilter()

Template method:
Allows subclasses to override parts of the method without rewriting it, also allows you to control which operations subclasses are required to override.

  • java.util.Collections#sort()
  • java.util.AbstractList#indexOf()

To provide a maintainable, easy way to perform actions for a family of classes. Visitor centralizes the behaviors and allows them to be modified or extended without changing the classes they operate on.

  • javax.lang.model.element.Element and javax.lang.model.element.ElementVisitor
  • javax.lang.model.type.TypeMirror and javax.lang.model.type.TypeVisitor

Better is the enemy of good!


Related Articles:

Notify of

This site uses Akismet to reduce spam. Learn how your comment data is processed.

1 Comment
Newest Most Voted
Inline Feedbacks
View all comments
Neo Lite
Neo Lite
11 years ago

I just stumbled on this article and quite interested to know the various patterns used in JDK . I am failing to understand why some classes/methods fall into a specified category of pattern. Is it deduced or is there some substance? I guess that is left for us to figure out.


Back to top button