Why Java Language doesn’t allow multiple inheritance of classes?

One of the design goals of the Java is to make the language “Simple, Object Oriented, and Familiar”. As Dr.James Gosling stated in his “The Java Language Environment” white paper and I quote “Even though C++ was rejected as an implementation language, keeping the Java programming language looking like C++ as far as possible results in it being a familiar language, while removing the unnecessary complexities of C++”. One such unnecessary complexity of c++ is the way it solves Diamond Problem, an ambiguity that arises as a result of using multiple inheritance of classes. The name Diamond comes from the shape of class inheritance diagram.

Suppose you have two classes Cat and Dog, both extending the Animal class and overriding the talk() method. Suppose we have a Hybrid >:XX class which extends both Cat and Dog classes.
Here’s what the code might look if Java supported traditional multiple inheritance:

abstract class Animal {
abstract void talk();
}
class Cat extends Animal {
void talk() {
System.out.println("Meow, meow.");
}
}
class Dog extends Animal {
void talk() {
System.out.println("Bark");
}
}
// (This won't compile, of course, because Java
// only supports single inheritance.)
class Hybrid extends Cat, Dog {
}

The diamond problem arises when someone tries to invoke the talk() object using the Animal reference to Hybrid object as follows
Animal obj=new Hybrid();
obj.talk()
So the ambiguity caused by the diamond problem is that it isn’t clear whether Cat’s talk() or Dog’s talk() method is invoked at runtime. The situation would be the same if Animal had a public instance variable which is inherited to the Hybrid class from both Cat and Dog classes. So now if you invoke the variable using the Hybrid object it is unclear as to which instance variable is called or if there was only one copy of the instance variable stored in Hybrid class.
c++ solves this problem using Virtual inheritance . So Java avoids this complexity and uses interfaces for multiple inheritance. The problem is therefore avoided since there is always only one implementation to a specific method or property and no ambiguity arises.