I'm wondering about the differences between inheritance and composition examined with concrete code relevant arguments.
In particular my example was:
class Do: def do(self): self.doA() self.doB() def doA(self): pass def doB(self): pass class MyDo(Do): def doA(self): print("A") def doB(self): print("B") x=MyDo()
class Do: def __init__(self, a, b): self.a=a self.b=b def do(self): self.a.do() self.b.do() x=Do(DoA(), DoB())
(Note for composition I'm missing code so it's not actually shorter)
Can you name particular advantages of one or the other?
I'm think of:
- composition is useful if you plan to reuse DoA() in another context
- inheritance seems easier; no additional references/variables/initialization
- method doA can access internal variable (be it a good or bad thing :) )
- inheritance groups logic A and B together; even though you could equally introduce a grouped delegate object
- inheritance provides a preset class for the users; with composition you'd have to encapsule the initialization in a factory so that the user does have to assemble the logic and the skeleton
Basically I'd like to examine the implications of inheritance vs composition. I heard often composition is preferred, but I'd like to understand that by example.
Of course I can always start with one and refactor later to the other.