I learnt that Java did not allow multiple inheritance using abstract classes for simplicity.
In java, after a good design of class hierarchy, SubType would not get into trouble of same method prototypes or same name variable, coming from both interface and abstract class as parent types, Because abstract class and interface are discovered(but not designed) based on implementation classes. I guess this is what it meant.
Here is the problem Java code, that still has multiple inheritance issue, using interface keyword:
abstract class SuperType1 {
protected int item;
}
interface SuperType2{
final float item=2.0;
}
public class SubType extends SuperType1 implements SuperType2{
public static void main(String[] args){
SubType s = new SubType();
//s.item = 2; //Compiler knows that 'item' is only mutable in 'class SuperType1', this code should not fail.
}
}
So,
As per above program, What exactly does it mean to say that, Java omits multiple inheritance?
3
The item field in SuperType2 class is static so there is no inheritance; there is just an ambiguous reference . All fields from interfaces are static and public by default. Java would have been better designed if static fields and methods can only be accessed through class name and not through a reference; but this is not a major flaw.
Since version 8, Java has the diamond problem and multiple inheritance because interfaces can have default methods. In the case of multiple inheritance the code won’t compile unless you overwrite the problematic method and specify how it should behave (you can also choose the implementation from a supperclass/interface by using the syntax SuperType.super.method() in the subclass implementation).
2