Should constructors comply with the Liskov Substitution Principle?
ConstructorClass MethodLiskov Substitution-PrincipleConstructor Problem Overview
I usually try to make sure my object instances comply with the [Liskov Substitution Principle][1], but I've always wondered is do people think LSP should apply to constructors too?
I've tried googling for this but I haven't been able to find any strong opinions either way.
I should note that most of my coding is in Ruby, but I sometimes find that my subclass constructors are slightly different from the parent class. They take the same base set of arguments, and often extra args. Sometimes this also happens with other class methods.
In the back of my head this has always felt like an LSP violation, but I wanted to see if anyone else feels this way too.
[1]: http://c2.com/cgi/wiki?LiskovSubstitutionPrinciple "Liskov Substitution Principle"
Constructor Solutions
Solution 1 - Constructor
No, when you use a constructor you know you are dealing with the subtype. This allows you to have preconditions not required for the parent constructor such as other parameters. This is why in most languages the constructor name is that of the class being created.
A good example of how this is that a ColoredSquare could be a proper subtype of Square, but requires an extra parameter: color. If you couldn't do things like this subtypes would be much less useful.
In some sense, the constructor isn't really part of the type: it is a function that returns an element of that type. Thus, defining a new constructor for a subtype, doesn't break LSP.
Solution 2 - Constructor
Definitely No.
Constructors are normally specialized for subtypes. Trying to apply LSP to constructors would be like saying subtypes can't have added specific methods or members. But the restriction is only the other way around.
And I also agree with Philip, constructors are not really part of a type (and in some languages you can easily use other factories instead of constructors). Using smalltalk terminology you would say constructors are methods of meta-classes.
No violation of LSP here, it only applies to instance methods, not to class methods (constructors or any other class methods).
Solution 3 - Constructor
This is sort of an opinionated question but the way I tend to write mine is such that the extra parameters have no real bearing on changing functionality. By that I mean that when my constructor requires an extra parameter in a subclass it is to maintain the standard functionality (but doing different underlying things) this way lets say I create ClassA = new ClassB(with some args); then functionality is the same whether I do this or ClassA = new ClassA(); and I usually use some sort of Factory method to create them so it's seamless in how they work. Again this is just how I do things and is in no way the absolute correct way to do things.