Question

I am trying to understand what design pattern I am stumbling towards… please bear with me the language I am using is Matlab and the OO is a bit weak in some areas, and I am relatively inexperienced in implementing design patterns.

I have a ComplexObject in which the constructor was becoming overly complicated. To begin with my constructor allowed 0, 1 or 2 arguments, that is an "empty" ComplexObject, a ComplexObject built from a ModelObject, or a ComplexObject built from ModelObject+ConfigObject. (The ModelObject and ConfigObject are basic file parsers).

I can’t overload constructors in Matlab, so I essentially switch’ed on the class type of the input arguments to the constructor, after I while I changed some of this to static methods so that the constructor was just an empty class initializer, and static ComplexObject.createFromModel and ComplexObject.createFromModelAndConfig classes produced ComplexObjects.

I then decided that my ComplexObject code was being dominated by all this construction stuff and the business logic wasnt clear, so I wrote a ComplexObjectFactory class and basically moved the static methods into that class. Now since the static methods are in fact calling more private (static!?) methods to build the ComplexObject I have run into some confusion about calling conventions of these private static methods 🙁

Finally, I am now trying to add some code to write part of ComplexObject back to disk. Interestingly this is actually the same disk file that is used to build a ConfigObject… so I want something like ComplexObject.writeConfigFile… or should that be ComplexObjectFactory.writeConfigFile(myComplexObject). To further complicate things I want multiple types of "config" file formats down the track.

My current classes look something like:

classdef ComplexObjectFactory
    methods (Static)
        function product = createFromModel(modelObj)
            product = ComplexObject()
            ComplexObjectFactory.helper1(product)
        end
        function product = createFromModelAndConfig(modelObj, configObj)
            product = ComplexObjectFactory.createFromModel(modelObj)
            ComplexObjectFactory.helper2(product, configObj)
        end
    end
    methods (Private, Static)
        function helper1(product)
        function helper2(product)
    end
end
classdef ComplexObject
    methods
        function self = ComplexObject(varargin)
            <init>
        end
    end
end

classdef ComplexObject 

Answer 1

Not sure I completely understand your question, tell me if I’m off topic here.

Just like you wrote, design pattern that creates objects is called factory. Other functionality that you mentioned, like writing to disk should be the responsibility of the object itself.