A use for multiple inheritance?

by

Most uses of full scale Multiple inheritance are for mixins. As an example:

class DraggableWindow : Window, Draggable { }
class SkinnableWindow : Window, Skinnable { }
class DraggableSkinnableWindow : Window, Draggable, Skinnable { }

etc…

In most cases, it’s best to use multiple inheritance to do strictly interface inheritance. 

class DraggableWindow : Window, IDraggable { }

Then you implement the IDraggable interface in your DraggableWindow class. It’s WAY too hard to write good mixin classes.

The benefit of the MI approach (even if you are only using Interface MI) is that you can then treat all kinds of different Windows as Window objects, but have the flexibility to create things that would not be possible (or more difficult) with single inheritance.

For example, in many class frameworks you see something like this:

class Control { }
class Window : Control { }
class Textbox : Control { }

Now, suppose you wanted a Textbox with Window characteristics? Like being dragable, having a titlebar, etc… You could do something like this:

class WindowedTextbox : Control, IWindow, ITexbox { }

In the single inheritance model, you can’t easily inherit from both Window and Textbox without having some problems with duplicate Control objects and other kinds of problems. You can also treat a WindowedTextbox as a Window, a Textbox, or a Control.

Also, to address your .anotherClass() idiom, .anotherClass() returns a different object, while multiple inheritance allows the same object to be used for different purposes.

More Related Contents:

  1. What is the exact problem with multiple inheritance?
  2. Interface vs Abstract Class (general OO)
  3. What does ‘super’ do in Python? – difference between super().__init__() and explicit superclass __init__()
  4. Interface vs Base class
  5. What is a mixin and why is it useful?
  6. When to use an interface instead of an abstract class and vice versa?
  7. Calling parent class __init__ with multiple inheritance, what’s the right way?
  8. What does “program to interfaces, not implementations” mean?
  9. Why to use Interfaces, Multiple Inheritance vs Interfaces, Benefits of Interfaces?
  10. Why should I avoid multiple inheritance in C++?
  11. Method chaining – why is it a good practice, or not?
  12. What is the difference between an Instance and an Object?
  13. Does functional programming replace GoF design patterns?
  14. What is the definition of “interface” in object oriented programming
  15. Is returning null bad design? [closed]
  16. What is the scope of the Single Responsibility Principle? [closed]
  17. How much work should be done in a constructor?
  18. When to use mixins and when to use interfaces in Dart?
  19. Triple inheritance causes metaclass conflict… Sometimes
  20. Doctrine2 ORM does not save changes to a DateTime field
  21. Can’t seem to understand SOLID principles and design patterns [closed]
  22. Why not use instanceof operator in OOP design?
  23. How to create a “single dispatch, object-oriented Class” in julia that behaves like a standard Java Class with public / private fields and methods
  24. What is the difference between Composition and Association relationship?
  25. Constructors in Go
  26. Difference between Encapsulation and Abstraction
  27. Coupling, Cohesion and the Law of Demeter
  28. When to use delegation instead of inheritance? [closed]
  29. How do you explain OO to new programmers? [closed]
  30. Multiple Inheritance in java

Leave a Comment