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

Question

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.

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.

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

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.

You can find accurate answer for this query in oracle documentation page about multiple inheritance

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

   1. What if methods or constructors from different super classes instantiate the same field?
   2. Which method or constructor will take precedence?

2. 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?

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