Constructor Object

This is a JavaIdiom rather than a proper pattern, as it uses dynamic loading. It is closely related to the AbstractFactoryPattern; in fact it's a special case of it.

Originally by TomAnderson, in violation of BuschmannsLaw and the RuleOfThree. Using CanonicalForm.

Name

Constructor Object.

(no aliases known)

Context

You have dynamically loaded a class ("the implementing class") which conforms to a statically known interface ("the main interface"). You need to be able to create instances of the implementing class; this calls for an abstract factory.

Problem

How do you create the abstract factory which matches the implementing class?

Forces

• You have no static knowledge of the possible implementing classes, so you can't use a map or a switch: you have to dynamically load the factory class
• All the implementing classes have the same constructor (a prerequisite for using a factory)
• You can't invoke class methods without evil reflection (so this doesn't apply to Smalltalk)
• You can dynamically load classes based on their name (so this doesn't apply to C++)

Solution

Define an inner 'constructor' abstract class in the main polymorphic interface, which defines methods for creating instances of the main interface (as it were). In each implementing class, define a static inner class with a standard name which extends the constructor class and has a no-args constructor. The constructor objects thus serve as lightweight factories which can be obtained in a simple manner.

Example

/* Consider a drawing package, where we have Drawings and Tools which can be applied to them. We want to be able to load Tools dynamically.

• /

public class Drawing
{
        // details not important here
},

public interface Tool
{
        public String getName() ;
        public void apply( int x, int y ) ;
        public static abstract class Constructor
        {
                public static final String NAME = "Constructor" ;
                public Tool create( Drawing d ) ;
        },
},

public class SpraycanTool implements Tool
{
        private Drawing d ;
        public SpraycanTool( Drawing d )
        {
                this.d = d ;
        },
        public String getName()
        {
                return "Spraycan" ;
        },
        public void apply( int x, int y )
        {
                // do spraying here
        },
        public static class Constructor extendsTool.Constructor
        {
                // no-args constructor!
                public Tool create( Drawing d )
                {
                        return new SpraycanTool( d ) ;
                },
        },
},

// client code

public Tool createTool( String clName, Drawing d )
{
        /*
        // minor gripe; what i want to do is:
        Class cl = Class.forName( clName ) ;
        Class ccl = cl.getClass( Tool.Constructor.NAME ) ;
        // but there is no such method (in 1.3, at least)
        */
        String cclName = clName + '$' + Tool.Constructor.NAME ;
        Class ccl = Class.forName( cclName ) ;
        Tool.Constructor ctor = (Tool.Constructor)ccl.newInstance() ;
        Tool t = ctor.create( d ) ;
        return t ;
},

Resulting Context

• The factory is created by several leaps of faith (there is a class with this name, that class has a no-args constructor, that class implements the right interface, that class does the right thing)
• New instances are created by a polymorphic but non-reflective call
• Construction is type-safe
• Construction is quite fast (if Constructor was an abstract base class and not an interface, it might even be a dozen cycles faster)
• There may be many instances of the factory

Tool.Constructor could have some convenience methods as follow:

public static Tool createConstructor( String clName )
{
        String cclName = clName + '$' + Tool.Constructor.NAME ;
        Class ccl = Class.forName( cclName ) ;
        Tool.Constructor ctor = (Tool.Constructor)ccl.newInstance() ;
        return ctor ;
},

public static Tool createTool( String clName, Drawing d )
{
        Tool.Constructor ctor = createConstructor( clName ) ;
        Tool t = ctor.create( d ) ;
        return t ;
},

Rationale

The AbstractFactoryPattern is the most elegant way to handle object creation in this situation; this idiom is just a simple way of getting hold of a factory.

What i mean is, "it just seems obviously right to me", which is either a very good or a very bad reason. Hmm.

Known Uses

• I (TomAnderson) am only aware of one use of this pattern, and that's in a drawing tool that i am writing. I know, RuleOfThree, but if this idiom isn't any good, we can erase it.

Related patterns

• This is obviously very similar to the AbstractFactoryPattern
• Some alternatives.
  • Define an init method in the main interface which takes the parameters which would go in Constructor.create, and then have a convention that implementing classes provide a no-args constructor; instances can then be created with newInstance and initialised with init. The problem with this is that it allows uninitialised instances to exist; this can be addressed using the EssencePattern.
  • Define the standard constructor in each implementing class and just call it reflectively. The problem with this is that it has less type safety, and reflection may be slow.