Why is there no multiple inheritance in Java but implementing multiple interfaces is allowed

Question

Java doesn t allow multiple inheritance  but it allows implementing multiple interfaces  Why

User · Accepted Answer

Because interfaces specify only what the class is doing  not how it is doing it    The problem with multiple inheritance is that two classes may define different ways of doing the same thing  and the subclass can t choose which one to pick

User · Answer

The answer of this question is lies in the internal working of java compiler constructor chaining   If we see the internal working of java compiler   public class Bank     public void printBankBalance        System out println  10k          class SBI extends Bank   public void printBankBalance        System out println  20k            After compiling this look like   public class Bank     public Bank       super          public void printBankBalance        System out println  10k          class SBI extends Bank    SBI       super        public void printBankBalance        System out println  20k            when we extends class and create an object of it  one constructor chain will run till Object class   Above code will run fine  but if we have another class called Car which extends Bank and one hybrid multiple inheritance  class called SBICar   class Car extends Bank     Car         super          public void run        System out println  99Km h          class SBICar extends Bank  Car     SBICar         super      NOTE  compile time ambiguity        public void run         System out println  99Km h          public void printBankBalance        System out println  20k            In this case SBICar  will fail to create constructor chain compile time ambiguity    For interfaces this is allowed because we cannot create an object of it   For new concept of default and static method kindly refer default in interface   Hope this will solve your query   Thanks

User · Answer

Implementing multiple interfaces is very useful and doesn t cause much problems to language implementers nor programmers  So it is allowed  Multiple inheritance while also useful  can cause serious problems to users  dreaded diamond of death   And most things you do with multiple inheritance can be also done by composition or using inner classes  So multiple inheritance is forbidden as bringing more problems than gains

User · Answer

One of my college instructors explained it to me this way      Suppose I have one class  which is a Toaster  and another class  which is NuclearBomb  They both might have a  darkness  setting  They both have an on   method   One has an off    the other doesn t   If I want to create a class that s a subclass of both of these   as you can see  this is a problem that could really blow up in my face here    So one of the main issues is that if you have two parent classes  they might have different implementations of the same feature     or possibly two different features with the same name  as in my instructor s example  Then you have to deal with deciding which one your subclass is going to use  There are ways of handling this  certainly     C   does so     but the designers of Java felt that this would make things too complicated   With an interface  though  you re describing something the class is capable of doing  rather than borrowing another class s method of doing something  Multiple interfaces are much less likely to cause tricky conflicts that need to be resolved than are multiple parent classes

User · Answer

in simple manner we all know  we can inherit extends  one class but we can implements so many interfaces   that is because in interfaces we don t give an implementation just say the functionality  suppose if java can extends so many classes and those have same methods   in this point if we try to invoke super class method in the sub class what method suppose to run    compiler get confused  example - try to multiple extends but in interfaces those methods don t have bodies we should implement those in sub class    try to multiple implements so no worries

User · Answer

Java supports multiple inheritance through  interfaces only  A class can implement any number of interfaces but can extend only one class   Multiple inheritance is not supported because it leads to deadly diamond problem  However  it can be solved but it leads to complex system so multiple inheritance has been dropped by Java founders   In a white paper titled    Java  an Overview    by James Gosling in February 1995 link  gives an idea on why multiple inheritance is not supported in Java   According to Gosling        JAVA omits many rarely used  poorly understood  confusing features of   C   that in our experience bring more grief than bene t  This   primarily consists of operator overloading  although it does have   method overloading   multiple inheritance  and extensive automatic   coercions

User · Answer

Because an interface is just a contract  And a class is actually a container for data

User · Answer

Take for example the case where Class A has a getSomething method and class B has a getSomething method and class C extends A and B  What would happen if someone called C getSomething  There is no way to determine which method to call   Interfaces basically just specify what methods a implementing class needs to contain  A class that implements multiple interfaces just means that class has to implement the methods from all those interfaces   Whci would not lead to any issues as described above

User · Answer

This is a simple answer since I m a beginner in Java    Consider there are three classes X Y and Z   So we are inheriting like X extends Y  Z And both Y and Z is having a method alphabet   with same return type and arguments  This method alphabet   in Y says to display first alphabet and method alphabet in Z says display last alphabet  So here comes ambiguity when alphabet   is called by X  Whether it says to display first or last alphabet    So java is not supporting multiple inheritance  In case of Interfaces  consider Y and Z as interfaces  So both will contain the declaration of method alphabet   but not the definition  It won t tell whether to display first alphabet or last alphabet or anything but just will declare a method alphabet    So there is no reason to raise the ambiguity  We can define the method with anything we want inside class X   So in a word  in Interfaces definition is done after implementation so no confusion

User · Answer

Because inheritance is overused even when you can t say  hey  that method looks useful  I ll extend that class as well    public class MyGodClass extends AppDomainObject  HttpServlet  MouseAdapter                AbstractTableModel  AbstractListModel  AbstractList  AbstractMap

User · Answer

Consider a scenario where Test1  Test2 and Test3 are three classes  The Test3 class inherits Test2 and Test1 classes  If Test1 and Test2 classes have same method and you call it from child class object  there will be ambiguity to call method of Test1 or Test2 class but there is no such ambiguity for interface as in interface no implementation is there

User · Answer

Java does not support multiple inheritance   multipath and hybrid inheritance because of ambiguity problem    Scenario for multiple inheritance  Let us take class A   class B   class C  class A has alphabet    method   class B has also alphabet    method  Now class C extends A  B and we are creating object to the subclass i e   class C   so  C ob   new C    Then if you want call those methods ob alphabet    which class method takes   is class A method or class B method    So in the JVM level ambiguity problem occurred  Thus Java does not support multiple inheritance    multiple inheritance     Reference Link  https   plus google com u 0 communities 102217496457095083679

User · Answer

It is said that objects state is referred with respect to the fields in it and it would become ambiguous if too many classes were inherited  Here is the link   http   docs oracle com javase tutorial java IandI multipleinheritance html

User · Answer

For the same reason C  doesn t allow multiple inheritence but allows you to implement multiple interfaces   The lesson learned from C   w  multiple inheritence was that it lead to more issues than it was worth   An interface is a contract of things your class has to implement  You don t gain any functionality from the interface  Inheritence allows you to inherit the functionality of a parent class  and in multiple-inheritence  that can get extremely confusing    Allowing multiple interfaces allows you to use Design Patterns  like Adapter  to solve the same types of issues you can solve using multiple inheritence  but in a much more reliable and predictable manner

User · Answer

For example two class A B having same method m1    And class C extends both A  B    class C extends A  B    for explaining purpose    Now  class C will search the definition of m1  First  it will search in class if it didn t find then it will check to parents class  Both A  B having the definition So here ambiguity occur which definition should choose  So JAVA DOESN T SUPPORT MULTIPLE INHERITANCE

User · Answer

Java does not support multiple inheritance because of two reasons     In java  every class is a child of Object class  When it inherits from more than one super class  sub class gets the ambiguity to acquire the property of Object class   In java every class has a constructor  if we write it explicitly or not at all  The first statement is calling super   to invoke the supper class constructor  If the class has more than one super class  it gets confused    So when one class extends from more than one super class  we get compile time error

User · Answer

Since this topic is not close I ll post this answer  I hope this helps someone to understand why java does not allow multiple inheritance   Consider the following class   public class Abc       public void doSomething                In this case the class Abc does not extends nothing right  Not so fast  this class implicit extends the class Object  base class that allow everything work in java  Everything is an object   If you try to use the class above you ll see that your IDE allow you to use methods like  equals Object o   toString    etc  but you didn t declare those methods  they came from the base class Object  You could try   public class Abc extends String       public void doSomething                This is fine  because your class will not implicit extends Object but will extends String because you said it  Consider the following change   public class Abc       public void doSomething                 Override     public String toString            return  hello              Now your class will always return  hello  if you call toString     Now imagine the following class   public class Flyer       public void makeFly               public class Bird extends Abc  Flyer       public void doAnotherThing                Again class Flyer implicit extends Object which has the method toString    any class will have this method since they all extends Object indirectly  so  if you call toString   from Bird  which toString   java would have to use  From Abc or Flyer  This will happen with any class that try to extends two or more classes  to avoid this kind of  method collision  they built the idea of interface  basically you could think them as an abstract class that does not extends Object indirectly  Since they are abstract they will have to be implemented by a class  which is an object  you cannot instanciate an interface alone  they must be implemented by a class   so everything will continue to work fine   To differ classes from interfaces  the keyword implements was reserved just for interfaces   You could implement any interface you like in the same class since they does not extends anything by default  but you could create a interface that extends another interface  but again  the  father  interface would not extends Object    so an interface is just an interface and they will not suffer from  methods signature colissions   if they do the compiler will throw a warning to you and you will just have to change the method signature to fix it  signature   method name   params   return type    public interface Flyer       public void makeFly        lt - method without implementation     public class Bird extends Abc implements Flyer       public void doAnotherThing                 Override     public void makeFly        lt - implementation of Flyer interface                Flyer does not have toString   method or any method from class Object          no method signature collision will happen here

User · Answer

You can find accurate answer for this query in oracle documentation page about multiple inheritance   Multiple inheritance of state   Ability to inherit fields from multiple classes     One reason why the Java programming language does not permit you to extend more than one class is to avoid the issues of multiple inheritance of state  which is the ability to inherit fields from multiple classes   If multiple inheritance is allowed and  When you create an object by instantiating that class  that object will inherit fields from all of the class s superclasses  It will cause two issues    What if methods or constructors from different super classes instantiate the same field  Which method or constructor will take precedence   Multiple inheritance of implementation  Ability to inherit method definitions from multiple classes  Problems with this approach  name conflicts and ambiguity  If a subclass and superclass contain same method name  and signature   compiler can t determine which version to invoke    But java supports this type of multiple inheritance with default methods  which have been introduced since Java 8 release   The Java compiler provides some rules to determine which default method a particular class uses   Refer to below SE post for more details on resolving diamond problem   What are the differences between abstract classes and interfaces in Java 8  Multiple inheritance of type   Ability of a class to implement more than one interface     Since interface  does not contain mutable fields  you do not have to worry about problems that result from multiple inheritance of state here

[java] Why is there no multiple inheritance in Java, but implementing multiple interfaces is allowed?

Examples related to java

Examples related to oop

Examples related to inheritance

Examples related to interface

Examples related to language-design