Should constructors comply with the Liskov Substitution Principle? [closed]

Question

I usually try to make sure my object instances comply with the Liskov Substitution Principle, 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.

Answer 1

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.

Answer 2

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).