Java Multiple Inheritance

Question

In an attempt to fully understand how to solve Java s multiple inheritance problems I have a classic question that I need clarified   Lets say I have class Animal this has sub classes Bird and Horse and I need to make a class Pegasus that extends from Bird and Horse since Pegasus is both a bird and a horse   I think this is the classic diamond problem  From what I can understand the classic way to solve this is to make the Animal  Bird and Horse classes interfaces and implement Pegasus from them    I was wondering if there was another way to solve the problem in which I can still create objects for birds and horses  If there was a way to be able to create animals also that would be great but not necessary

User · Answer

I have a stupid idea   public class Pegasus       private Horse horseFeatures       private Bird birdFeatures       public Pegasus Horse horse  Bird bird         this horseFeatures   horse       this birdFeatures   bird          public void jump         horseFeatures jump           public void fly         birdFeatures fly

User · Answer

To reduce the complexity and simplify the language  multiple inheritance is not supported in java   Consider a scenario where A  B and C are three classes  The C class inherits A and B classes  If A and B classes have same method and you call it from child class object  there will be ambiguity to call method of A or B class   Since compile time errors are better than runtime errors  java renders compile time error if you inherit 2 classes  So whether you have same method or different  there will be compile time error now   class A         void msg             System out println  From A               class B         void msg             System out println  From B               class C extends A B      suppose if this was possible     public static void main String   args              C obj   new C              obj msg       which msg   method would be invoked

User · Answer

Ehm  your class can be the subclass for only 1 other  but still  you can have as many interfaces implemented  as you wish    A Pegasus is in fact a horse  it is a special case of a horse   which is able to fly  which is the  skill  of this special horse   From the other hand  you can say  the Pegasus is a bird  which can walk  and is 4legged - it all depends  how it is easier for you to write the code   Like in your case you can say   abstract class Animal      private Integer hp   0      public void eat            hp             interface AirCompatible       public void fly       class Bird extends Animal implements AirCompatible        Override    public void fly                Do something useful         class Horse extends Animal       Override    public void eat            hp  2            class Pegasus extends Horse implements AirCompatible        now every time when your Pegasus eats  will receive  2 hp       Override    public void fly                Do something useful

User · Answer

It is safe to keep a horse in a stable with a half door  as a horse cannot get over a half door    Therefore I setup a horse housing service that accepts any item of type horse and puts it in a stable with a half door   So is a horse like animal that can fly even a horse   I used to think a lot about multiple inheritance  however now that I have been programming for over 15 years  I no longer care about implementing multiple inheritance   More often than not  when I have tried to cope with a design that pointed toward multiple inheritance  I have later come to release that I had miss understood the problem domain   OR     If it looks like a duck and quacks like a duck but it needs   batteries  you probably have the wrong abstraction

User · Answer

Problem not solved  To sufficiently model this out and to prevent code replication you d either need multiple inheritance or mixins  Interfaces with default functions are not sufficient because you cannot hold members in interfaces  Interface modeling leads to code replication in subclasses or statics  which is both evil  All you can do is to use a custom construction and split it up in more components and compose it all together    toy language

User · Answer

you can have an interface hierarchy and then extend your classes from selected interfaces    public interface IAnimal      public interface IBird implements IAnimal      public  interface IHorse implements IAnimal      public interface IPegasus implements IBird IHorse      and then define your classes as needed   by extending a specific interface    public class Bird implements IBird      public class Horse implements IHorse     public class Pegasus implements IPegasus

User · Answer

Technically speaking  you can only extend one class at a time and implement multiple interfaces  but when laying hands on software engineering  I would rather suggest a problem specific solution not generally answerable  By the way  it is good OO practice  not to extend concrete classes only extend abstract classes to prevent unwanted inheritance behavior - there is no such thing as an  animal  and no use of an animal object but only concrete animals

User · Answer

Define interfaces for defining the capabilities  You can define multiple interfaces for multiple capabilities   These capabilities can be implemented by specific Animal or Bird   Use inheritance to establish relationships among classes by sharing non-static and non-public data methods   Use Decorator pattern to add capabilities dynamically  This will allow you to reduce number of inheritance classes  amp  combinations     Have a look at below example for better understanding  When to Use the Decorator Pattern

User · Answer

Interfaces don t simulate multiple inheritance  Java creators considered multiple inheritance wrong  so there is no such thing in Java   If you want to combine the functionality of two classes into one - use object composition  I e   public class Main       private Component1 component1   new Component1            private Component2 component2   new Component2        And if you want to expose certain methods  define them and let them delegate the call to the corresponding controller   Here interfaces may come handy - if Component1 implements interface Interface1 and Component2 implements Interface2  you can define  class Main implements Interface1  Interface2   So that you can use objects interchangeably where the context allows it   So in my point of view  you can t get into diamond problem

User · Answer

You could create interfaces for animal classes  class in the biological meaning   such as public interface Equidae for horses and public interface Avialae for birds  I m no biologist  so the terms may be wrong    Then you can still create a   public class Bird implements Avialae       and   public class Horse implements Equidae      and also  public class Pegasus implements Avialae  Equidae        Adding from the comments   In order to reduce duplicate code  you could create an abstract class that contains most of the common code of the animals you want to implement   public abstract class AbstractHorse implements Equidae     public class Horse extends AbstractHorse     public class Pegasus extends AbstractHorse implements Avialae        Update  I d like to add one more detail  As Brian remarks  this is something the OP already knew    However  I want to emphasize  that I suggest to bypass the  multi-inheritance  problem with interfaces and that I don t recommend to use interfaces that represent already a concrete type  such as Bird  but more a behavior  others refer to duck-typing  which is good  too  but I mean just  the biological class of birds  Avialae   I also don t recommend to use interface names starting with a capital  I   such as IBird  which just tells nothing about why you need an interface  That s the difference to the question  construct the inheritance hierarchy using interfaces  use abstract classes when useful  implement concrete classes where needed and use delegation if appropriate

User · Answer

As you will already be aware  multiple inheritance of classes in Java is not possible  but it s possible with interfaces  You may also want to consider using the composition design pattern   I wrote a very comprehensive article on composition a few years ago     https   codereview stackexchange com questions 14542 multiple-inheritance-and-composition-with-java-and-c-updated

User · Answer

To solve the problem of mutiple inheritance in Java  rarr  interface is used  J2EE  core JAVA  Notes By Mr  K V R Page 51     Day - 27         Interfaces are basically used to develop user defined data types    With respect to interfaces we can achieve the concept of multiple inheritances    With interfaces we can achieve the concept of polymorphism  dynamic binding and hence we can improve the performance of a JAVA program in   turns of memory space and execution time          An interface is a construct which contains the collection of purely   undefined methods or an interface is a collection of purely abstract   methods                  Day - 28       Syntax-1 for reusing the features of interface s  to class    abstract  class  lt clsname gt  implements  lt intf 1 gt   lt intf 2 gt           lt intf n gt        variable declaration      method definition or declaration           In the above syntax clsname represents name of the class which is   inheriting the features from    n    number of interfaces     Implements    is   a keyword which is used to inherit the features of    interface s  to a   derived class                  Syntax-2 inheriting    n    number of interfaces to another interface   interface  lt intf 0 name gt  extends  lt intf 1 gt   lt intf 2 gt           lt intf n gt             variable declaration cum initialization      method declaration                      Syntax-3    abstract  class  lt derived class name gt  extends  lt base class name gt  implements  lt intf 1 gt   lt intf 2 gt           lt intf n gt      variable declaration    method definition or declaration

User · Answer

I think it depends very much on your needs  and how your animal classes are to be used in your code   If you want to be able to make use of methods and features of your Horse and Bird implementations inside your Pegasus class  then you could implement Pegasus as a composition of a Bird and a Horse   public class Animals        public interface Animal          public int getNumberOfLegs            public boolean canFly            public boolean canBeRidden               public interface Bird extends Animal          public void doSomeBirdThing              public interface Horse extends Animal          public void doSomeHorseThing              public interface Pegasus extends Bird Horse              public abstract class AnimalImpl implements Animal          private final int numberOfLegs           public AnimalImpl int numberOfLegs                super                this numberOfLegs   numberOfLegs                      Override         public int getNumberOfLegs                 return numberOfLegs                       public class BirdImpl extends AnimalImpl implements Bird           public BirdImpl                 super 2                       Override         public boolean canFly                 return true                      Override         public boolean canBeRidden                 return false                      Override         public void doSomeBirdThing                 System out println  doing some bird thing                             public class HorseImpl extends AnimalImpl implements Horse           public HorseImpl                 super 4                       Override         public boolean canFly                 return false                      Override         public boolean canBeRidden                 return true                      Override         public void doSomeHorseThing                 System out println  doing some horse thing                             public class PegasusImpl implements Pegasus           private final Horse horse   new HorseImpl            private final Bird bird   new BirdImpl               Override         public void doSomeBirdThing                 bird doSomeBirdThing                        Override         public int getNumberOfLegs                 return horse getNumberOfLegs                        Override         public void doSomeHorseThing                 horse doSomeHorseThing                         Override         public boolean canFly                 return true                      Override         public boolean canBeRidden                 return true                      Another possibility is to use an Entity-Component-System approach instead of inheritance for defining your animals  Of course this means  that you will not have individual Java classes of the animals  but instead they are only defined by their components   Some pseudo code for an Entity-Component-System approach could look like this   public void createHorse Entity entity       entity setComponent NUMER OF LEGS  4       entity setComponent CAN FLY  false       entity setComponent CAN BE RIDDEN  true       entity setComponent SOME HORSE FUNCTIONALITY  new HorseFunction        public void createBird Entity entity       entity setComponent NUMER OF LEGS  2       entity setComponent CAN FLY  true       entity setComponent CAN BE RIDDEN  false       entity setComponent SOME BIRD FUNCTIONALITY  new BirdFunction        public void createPegasus Entity entity       createHorse entity       createBird entity       entity setComponent CAN BE RIDDEN  true

User · Answer

Java does not have a Multiple inheritance problem  since it does not have multiple inheritance  This is by design  in order to solve the real multiple inheritance problem  The diamond problem    There are different strategies for mitigating the problem  The most immediately achievable one being the Composite object that Pavel suggests  essentially how C   handles it   I don t know if multiple inheritence via C3 linearization  or similar  is on the cards for Java s future  but I doubt it   If your question is academic  then the correct solution is that Bird and Horse are more concrete  and it is false to assume that a Pegasus is simply a Bird and a Horse combined  It would be more correct to say that a Pegasus has certain intrinsic properties in common with Birds and Horses  that is they have maybe common ancestors   This can be sufficiently modeled as Moritz  answer points out

User · Answer

There are two fundamental approaches to combining objects together    The first is Inheritance  As you have already identified the limitations of inheritance mean that you cannot do what you need here  The second is Composition  Since inheritance has failed you need to use composition    The way this works is that you have an Animal object  Within that object you then add further objects that give the properties and behaviors that you require   For example    Bird extends Animal implements IFlier Horse extends Animal implements IHerbivore  IQuadruped Pegasus extends Animal implements IHerbivore  IQuadruped  IFlier   Now IFlier just looks like this    interface IFlier        Flier getFlier         So Bird looks like this    class Bird extends Animal implements IFlier         Flier flier   new Flier          public Flier getFlier     return flier         Now you have all the advantages of Inheritance  You can re-use code  You can have a collection of IFliers  and can use all the other advantages of polymorphism  etc   However you also have all the flexibility from Composition  You can apply as many different interfaces and composite backing class as you like to each type of Animal - with as much control as you need over how each bit is set up   Strategy Pattern alternative approach to composition  An alternative approach depending on what and how you are doing is to have the Animal base class contain an internal collection to keep the list of different behaviors  In that case you end up using something closer to the Strategy Pattern  That does give advantages in terms of simplifying the code  for example Horse doesn t need to know anything about Quadruped or Herbivore  but if you don t also do the interface approach you lose a lot of the advantages of polymorphism  etc

User · Answer

May I suggest the concept of Duck-typing   Most likely you would tend to make the Pegasus extend a Bird and a Horse interface but duck typing actually suggests that you should rather inherit behaviour  As already stated in the comments  a pegasus is not a bird but it can fly  So your Pegasus should rather inherit a Flyable-interface and lets say a Gallopable-interface   This kind of concept is utilized in the Strategy Pattern  The given example actually shows you how a duck inherits the FlyBehaviour and QuackBehaviour and still there can be ducks  e g  the RubberDuck  which can t fly  They could have also made the Duck extend a Bird-class but then they would have given up some flexibility  because every Duck would be able to fly  even the poor RubberDuck

User · Answer

In Java 8  which is still in the development phase as of February 2014  you could use default methods to achieve a sort of C  -like multiple inheritance  You could also have a look at this tutorial which shows a few examples that should be easier to start working with than the official documentation

[java] Java Multiple Inheritance

Examples related to java

Examples related to oop

Examples related to multiple-inheritance

Examples related to diamond-problem

Examples related to multiple-interface-implem