Abstract classes and Multiple Inheritance

Question

We can achieve the same functionality as interfaces by using abstract classes, So why java doesn't allow the following code?

abstract class Animals
{
    public abstract void run();
}

abstract class Animals1
{
    public abstract void run1();
}

class Dog extends Animals,Animals1
{
  public void run() {System.out.println("Run method");}
  public void run1() {System.out.println("Run1 method");}
}

I know that multiple inheritance can be achieved by using only interfaces but the above code does the same thing as the interfaces would have done it.

Solution 1

This is not allowed because you can do more than this with abstract classes. It wouldn't make sense to allow multiple inheritance, provided you only used an abstract class when you could have used an interface.

It is simpler to only use abstract classes for things you can't do with an interface, in which case you wouldn't be able to use two abstract parent classes.

Note: with Java 8 there is less you can't do with an interface, you can have public instance and static methods with implementations.

In Java 9 you will be able to have private methods in interfaces ;)

Solution 2

This is because abstract classes are still classes, and inheritance is different than implementing an interface. Please see the differences between abstract class and interface. Also please see differences between inplementing an interface and extending a class in Java.

This both questions covers all the information you need to know to understand why you can't have multiple inheritance of abstract classes.

Also let me give you an example why this should not be allowed: Suppose you have the both Animals and Animals1 implementing the same interface IAnimals:

interface IAnimals
{
    public string eat();
}

abstract class Animals implements IAnimals
{
    public abstract void run();
    public string eat(){ return "Animals eating"; } 
}

abstract class Animals1 implements IAnimals
{
    public abstract void run1();
    public string eat(){ return "Animals1 eating"; } 
}

If you now define your Dog class as you did:

class Dog extends Animals,Animals1
{
  public void run() {System.out.println("Run method");}
  public void run1() {System.out.println("Run1 method");}
}

It will have the method eat() too, which is not abstract so it can use it directly. What would be the return of this method for a dog? Which string will be returned, the one with Animals, or the one with Animals1?

This is called the diamond problem, and it is a reason why in some programming languages it is not allowed multiple inheritance.