How about some code.
Here’s the State interface.

public interface TrafficLightState {
  public TrafficLightState transition();
  public Light[] illuminate();
}

Here’s the an example of a concrete State class, representing the Stop state. See how it defines the following state in its transition method. The illuminate method defines the state specific behaviour, in this case which lights should be turned on.

public class StopState implements TrafficLightState {

  public TrafficLightState transition()  {
    return new ReadyGoState();
  }

  public Light[] illuminate() {
      return new Light[]{Light.red, Light.greenWalkingMan};
  }
}

And here’s the context class.

public class TrafficLightContext {
  private TrafficLightState state;

  public TrafficLightContext()  {
    state = new StopState();
  }

  public void run()  {
    for (;;)  {
    try{
      for (Light light : state.illuminate()){
        System.out.print(light.name()+" ");
      }
      Thread.sleep(2000);
      state = state.transition();
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    }
  }

  public static void main(String[] args)  {
    TrafficLightContext context = new TrafficLightContext();
    context.run();
  }
}

Alternatively, the State objects could be passed a reference to the Context object so that they could access contextual data and modify the Context’s State at whatever point is appropriate.

The Decorators aren’t actually Christmas Trees themselves. In fact they are useless without a real tree to wrap themselves around. They impersonate a Tree by implementing the interface, but delegate all of the real work of being a tree to the wrapped instance. How about some code.
Here’s the abstract Decorator base class.

public abstract class ChristmasTreeDecorator implements ChristmasTree {
  private ChristmasTree wrappedChristmasTree;

  public ChristmasTreeDecorator(ChristmasTree tree) {
    wrappedChristmasTree = tree;
  }

  protected ChristmasTree getTree() {
    return wrappedChristmasTree;
  }
}

There’s a great opportunity here to use another GOF pattern – Template Method, but I’ve resisted the temptation to keep things simple. If you have time, have a look yourself at how it might fit in.

Here’s the an example of a concrete Decorator class.

public class FairyDecorator extends ChristmasTreeDecorator {
  public FairyDecorator(ChristmasTree tree){
    super(tree);
  }

  public void cheerRoom() {
    // could add behaviour before delegated call too if we want...
    getTree().cheerRoom();
    addFairy();
  }

  private void addFairy() {
    System.out.println("Top off with a festive fairy!");
  }
}

And here’s some test code.

public class DecoratorTest {
  public static void main(String[] args) {
    System.out.println("Here's my new tree, let's see how it cheers the room...");
    ChristmasTree tree = new NorwaySpruce();
    tree.cheerRoom();

    System.out.println("\nA bit dull, lets add some lights...");
    tree = new LightsDecorator(tree);
    tree.cheerRoom();

    System.out.println("\nNot bad, how about some tinsel...");
    tree = new TinselDecorator(tree);
    tree.cheerRoom();

    System.out.println("\nAnd now the finishing touch, a fairy...");
    tree = new FairyDecorator(tree);
    tree.cheerRoom();
  }
}

Notice how Decorators can be nested. A good example of this pattern in the Java APIs is the I/O Stream classes.

What interested me even more was that once I started to study them, many of them represent very simple concepts that I’d been using in my designs for years.  Having studied the approach of the Head First Design Patterns book (highly recommended!), I wondered whether it might be possible to write short, self describing examples of each pattern that could get the fundamental concept across in a quick and memorable way.  I am going to give it a go and post them onto this blog. If they help you to grasp the concept of even one new pattern then I’d love to hear from you!

This is a C based mechanism that allows you to build different flavours of a product from the same code base at compile time by a combination of #define and #ifdef primitives and a pre-processing step which occurred before compilation. As the name suggests, this process enabled blocks of code to be included in the final executable (or not) dependent on predefined conditions.

I’ve dabbled with various ways of achieving a similar effect in Java and so far this is the simplest approach that I’ve come up with. Let me know if you have a better strategy. The scheme involves simply running a single ant task prior to invoking the Java compiler which effectively selects the product flavour that you intend to build.
Firstly, define all of the different flavours of product that you wish to build in a class ProductType.java. For example:

1. public class ProductType {
2. public static final String BANANAS = “bananas”;
3. public static final String APPLES = “apples”;
4. public static boolean isBananas() {
5. return SetProduct.THIS_PRODUCT.equals(BANANAS);
6. }
7. public static boolean isApples() {
8. return SetProduct.THIS_PRODUCT.equals(APPLES);
9. }
10. }

Next, somewhere outside your source code tree, create a product directory for each of the product flavours you need to support. Each of these directories will hold its own version of the SetProduct.java class, which takes the following form:

1. public final class SetProduct {
2. public static final String THIS_PRODUCT = ProductType.BANANAS;
3. }

The ant task for each product flavour copies the SetProduct.java class from the specified product directory into the correct location in your java source code tree.

1. <target name=”bananas”>
2. <copy overwrite=”true” todir=”src/mypackage”>
3. <fileset dir=”products/bananas”>
4. <include name=”SetProduct.java”>
5. </fileset>
6. </copy>
7. </target>

It is important that no version of this class exists in the source code tree within your version control system. This ensures that a product flavour must be selected via an ant task before the code can be compiled successfully. (Other non-java files, such as web.xml which vary between product flavours can also be copied across at this point by the same ant task, but the SetProduct.java file is the only one that is required to support conditional compilation.)

Within your code base you can now define conditional blocks in the following way:

1. if (ProductType.isBananas()){
2. yellow = true;
3. peelable = true;
4. }
5. else if (ProductType.isApples()){
6. yellow = false;
7. peelable = true;
8. }

I’ll be a bit more specific. As Java’s my thing, I’m thinking of those open source gems that I really would not want to have to code again from scratch, even if I could, under any circumstances (although I can think of worse circumstances than under a coconut palm on a beach!)

Right at the top of my list, I would have to put xstream. In their own words:

XStream is a simple library to serialize objects to XML and back again.

I’ve been using this library for about 3 years, mainly to support the reading, writing and upgrading of configuration files for configurable systems. I initially used it to enable me to add configurable functionality into a prototype system very rapidly, but it was so effective that I saw no reason to change the approach in the production system. If you are taking an object-centric approach to XML then I can see no reason to use anything else.

In the early days the emphasis was on ease of use (which was and still is stunning!), but subsequent releases have provided much more flexibility in the way that objects graphs can be mapped to XML schemas. I’m still a big fan and the library has become an essential part of my toolkit for implementing configurable systems.

However the individuals that I’m posting about, whilst maybe not quite giants are certainly taller than me in their respective sphere and standing on their shoulders has improved my view! I’m actually talking about the rather pedestrian (to some!) matter of the look-and-feel of my blog, or more specifically, my WordPress theme.

So who’s shoulders am I actually talking about. Well firstly David Herreman who is responsible for the clean and beautiful graphic design and equally clean css work that I used for my theme. I loved his dkblog css template and bookmarked it as soon as I saw it. Secondly, Bob whose big-blue-01 WordPress theme I used as a skeleton over which to stretch David’s stylesheet (I’m no PHP wizard!). You’re looking at the result, unless I’ve changed theme since! Thanks guys…