Factory method pattern

In computer programming, the factory method pattern is a software design pattern. The factory method pattern is useful to solve the common problem of constructing objects based on some input such that functions inside the objects depend upon the input.

Contents

1 Example 1.1 A bad solution 1.2 A better, but not perfect, solution 1.3 Using the factory pattern 2 See also 3 External links

Example

Consider as an example a class to read image files and make thumbnails out of them. This can be solved by bundling them all into one class and deciding which bit of code to run:

A bad solution

public class ImageReader {
    private int fileType;
    private String fileContents;
    private byte[] decodedImage;

    public ImageReader( InputStream in ) {
        // Figure out what type of file this input stream represents
        // (eg gif, jpeg, png, tif, etc )

        this.fileType = fileType;
        decodeFile();
    }

    private void decodeFile() {
        switch( fileType ) {
        case ImageReader.GIF:
            // do gif decoding (many lines)
            break;
        case ImageReader.JPEG:
            // do jpeg decoding (many lines)
            break;
        case ImageReader.PNG:
            // do png decoding (many lines)
            break;
        // etc...
        }
    }
}

This method has the advantage of abstracting the file type from the class that calls this ImageReader, but as the number of file types supported gets larger, the code will quickly become huge, unwieldy and hard to maintain.

A better, but not perfect, solution

Another solution that seems possible is to have a separate object for each of these file types:

public interface ImageReader {
    public DecodedImage getDecodedImage();
}

public class GifReader implements ImageReader {
    public GifReader( InputStream in ) {
        // check that it's a gif, throw exception if it's not, then if it is
        // decode it.
    }

    public DecodedImage getDecodedImage() {
       return decodedImage;
    }
}

public class JpegReader implements ImageReader {
    //...
}

// Then you would use them as:
public class MyProg {

    public static void main( String[] args ) {

        String filename = args[0];
        ImageReader out;

        if( endsInDotGif( filename )) {
            out = new GifReader( fileInputStream );
        }

        if( endsInDotJpeg( filename )) {
            out = new JpegReader( fileInputStream );
        }

        printOut( out.getDecodedImage );
    }
}

Again, there are advantages to this method (clean organisation of the ImageReader classes, the code being split up in several classes), but this is at the cost of the abstraction of the image type. Again, when dozens of file types need to be supported, this will be unsatisfactory and produce code that is hard to maintain.

Using the factory pattern

The factory pattern can be used instead to combine the better parts of the above solutions. The factory is a class that returns another class depending on the context. So in this situation, keeping the separate class design as in the last example:

public class ImageReaderFactory {
    public static ImageReader getImageReader( InputStream is ) {
        int imageType = figureOutImageType( is );

        switch( imageType ) {
        case ImageReaderFactory.GIF:
            GifReader r = new GifReader( is );
            return (ImageReader)r;
            break;
        case ImageReaderFactory.JPEG:
            JpegReader r = new JpegReader( is );
            return (ImageReader)r;
            break;
        // etc.
        }
    }
}

The combination of a type code and its associated specific factory object can be stored in a map. The switch statement can be avoided to create an extensible factory by a mapping.

See also

• ClassFactory
• Abstract factory pattern (When the object has no descriptive attributes)
• Interpreter pattern (When a language is used to describe the objects)

External links

• mode-x.com (http://www.mode-x.com/index.php?id=24) (contributed by author)
• Description from the Portland Pattern Repository (http://c2.com/cgi/wiki?FactoryMethodPattern)de:Fabrikmethode