Develop Reference

Why does Java not allow multiple inheritance but does allow conforming to multiple interfaces with default implementations

I am not asking this -> Why is there no multiple inheritance in Java, but implementing multiple interfaces is allowed?
In Java, multiple inheritance isn't allowed, but, after Java 8, Interfaces can have default methods (can implement methods itself), just like abstract classes. Within this context, it multiple inheritance should also be allowed.
interface TestInterface
{
// abstract method
public void square(int a);
// default method
default void show()
{
System.out.println("Default Method Executed");
}
}

Things are not so simple.
If a class implements multiple interfaces that defines default methods with the same signature the compiler will force you to override this method for the class.
For example with these two interfaces :
public interface Foo {
default void doThat() {
// ...
}
}
public interface Bar {
default void doThat() {
// ...
}
}
It will not compile :
public class FooBar implements Foo, Bar{
}
You should define/override the method to remove the ambiguity.
You could for example delegate to the Bar implementation such as :
public class FooBar implements Foo, Bar{
#Override
public void doThat() {
Bar.super.doThat();
}
}
or delegate to the Foo implementation such as : :
public class FooBar implements Foo, Bar {
#Override
public void doThat() {
Foo.super.doThat();
}
}
or still define another behavior :
public class FooBar implements Foo, Bar {
#Override
public void doThat() {
// ...
}
}
That constraint shows that Java doesn't allow multiple inheritancy even for interface default methods.
I think that we cannot apply the same logic for multiple inheritances because multiples issues could occur which the main are :
overriding/removing the ambiguity for a method in both inherited classes could introduce side effects and change the overall behavior of the inherited classes if they rely on this method internally. With default interfaces this risk is also around but it should be much less rare since default methods are not designed to introduce complex processings such as multiple internal invocations inside the class or to be stateful (indeed interfaces cannot host instance field).
how to inherit multiple fields ? And even if the language allowed it you would have exactly the same issue as this previously quoted : side effect in the behavior of the inherited class : a int foo field defined in a A and B class that you want to subclass doesn't have the same meaning and intention.

The language designers already thought about that, so these things are enforced by the compiler. So if you define:
interface First {
default void go() {
}
}
interface Second {
default void go() {
}
}
And you implement a class for both interfaces:
static class Impl implements First, Second {
}
you will get a compilation error; and you would need to override go to not create the ambiguity around it.
But you could be thinking that you can trick the compiler here, by doing:
interface First {
public default void go() {
}
}
static abstract class Second {
abstract void go();
}
static class Impl extends Second implements First {
}
You could think that First::go already provides an implementation for Second::go and it should be fine. This is too taken care of, thus this does not compile either.
JLS 9.4.1.3 : Similarly, when an abstract and a default method with matching signatures are inherited, we produce an error. In this case, it would be possible to give priority to one or the other - perhaps we would assume that the default method provides a reasonable implementation for the abstract method, too. But this is risky, since other than the coincidental name and signature, we have no reason to believe that the default method behaves consistently with the abstract method's contract - the default method may not have even existed when the subinterface was originally developed. It is safer in this situation to ask the user to actively assert that the default implementation is appropriate (via an overriding declaration).
The last point I would bring in, to solidify that multiple inheritance is not allowed even with new additions in java, is that static methods from interfaces are not inherited. static methods are inherited by default:
static class Bug {
static void printIt() {
System.out.println("Bug...");
}
}
static class Spectre extends Bug {
static void test() {
printIt(); // this will work just fine
}
}
But if we change that for an interface (and you can implement multiple interfaces, unlike classes):
interface Bug {
static void printIt() {
System.out.println("Bug...");
}
}
static class Spectre implements Bug {
static void test() {
printIt(); // this will not compile
}
}
Now, this is prohibited by the compiler and JLS too:
JLS 8.4.8 : A class does not inherit static methods from its superinterfaces.

Java doesn't allow multiple inheritance for fields. This would be difficult to support in the JVM as you can only have references to the start of an object where the header is, not arbitrary memory locations.
In Oracle/Openjdk, objects have a header followed by the fields of the most super class, then the next most super class, etc. It would be a significant change to allow the fields of a class to appear at different offsets relative to the header of an object for different subclasses. Most likely object references would have to become a reference to the object header and a reference to the fields to support this.

default methods in interfaces pose a problem that :
If both of the implemented interfaces define a default method with
same method signature, then the implementation class does not know
which default method to use.
The implementation class should define explicitly specify which default method to use or define it's own one.
Thus default methods in Java-8 do not facilitate multiple inheritance. The main motivation behind default methods is that if at some point we need to add a method to an existing interface, we can add a method without changing the existing implementation classes. In this way, the interface is still compatible with older versions. However, we should remember the motivation of using Default Methods and should keep the separation of interface and implementation.

The main issues with multiple inheritance are ordering (for overriding and calls to super), fields and constructors; interfaces don't have fields or constructors, so they don't cause problems.
If you look at other languages they usually fall in two broad categories:
Languages with multiple inheritance plus a few features to disambiguate special cases: virtual inheritance [C++], direct calls to all superconstructors in the most-derived class [C++], linearization of superclasses [Python], complex rules for super [Python], etc.
Languages with a differente concept, usually called interfaces, traits, mixins, modules, etc. that impose some limitations such as: no constructors [Java] or no constructors with parameters [Scala until very recently], no mutable fields [Java], specific rules for overriding (e.g. mixins take precedence over base classes [Ruby] so you can include them when you need a bunch of utility methods), etc. Java has become a language like these.
Why just by disallowing fields and constructors you solve many issues related to multiple inheritance?
You can't have duplicated fields in duplicated base classes.
The main class hierarchy is still linear.
You can't construct your base objects the wrong way.
Imagine if Object had public/protected fields and all subclasses had constructors setting those fields. When you inherit from more than one class (all of them derived from Object), which one gets to set the fields? The last class? They become siblings in the hierarchy, so they know nothing about each other. Should you have multiple copies of Object to avoid this? Would all classes interoperate correctly?
Remember that fields in Java are not virtual (overridable), they are simply data storage.
You could make a language where fields behave like methods and could be overridden (the actual storage would be always private), but that would be a much bigger change and problably wouldn't be called Java anymore.
Interfaces can't be instantiated by themselves.
You should always combine them with a concrete class. That eliminates the need for constructors and makes the programmer's intent clearer too (that is, what is meant to be a concrete class and what's an accessory interface/mixin). This also provides a well-defined place to solve all ambiguities: the concrete class.

That is mostly related to "diamonds problem" i think. Right now if you implement multiple interfaces with the same method, compiler forces you to override method the one you want to implement, because it don't know which on to use. I guess Java creators wanted to remove this problem back when interfaces couldn't use default methods. Now they came up with idea, that is good to be able to have methods with implementation in interfaces, as you can still use those as functional interfaces in streams / lambda expressions and utilize their default methods in processing. You cannot do that with classes but diamond problem still exist there. That is my guess :)

class A{
void m1(){
System.out.println("m1-A");
}
}
class B{
void m1(){
System.out.println("m1-B");
}
}
class C extends A, B{ // this will give an error
// inheritance means making all variables and/or methods available to the child class, here child class will get confused as which m1() method to inherit, hence an error
}

JAVA DOES SUPPORT MULTIPLE INHERITANCE.
If you make a OVERALL COMPARISON OF THE PROGRAMMING LANGUAGE,JAVA,THEN YOU COME TO KNOW THAT I AM TRUE.
Java's topclass or the root class in the Ancestor Hierarchy is the Object class.
This class is a Superclass of all other classes. Hence, each class in Java that we declare or is predefined in the API itself inherits this Object class.
Moreover, Java provides us to inherit one more class of our choice.
Hence, we can say that we are performing INTERLOCKED BUT MULTIPLE INHERITANCE.
2ND Way
Java supports Multiple Inheritance of Interfaces. So you can use as many interface implementations you want. But note, implementing an interface does not define IS A relationship as in case of Inheritance of Classes is possible.

Interface extends 2 classes [duplicate]

Can an interface extend multiple interfaces in Java? This code appears valid in my IDE and it does compile:
interface Foo extends Runnable, Set, Comparator<String> { }
but I had heard that multiple inheritance was not allowed in Java. Why does there appear to be an exception for interfaces?

Yes, you can do it. An interface can extend multiple interfaces, as shown here:
interface Maininterface extends inter1, inter2, inter3 {
// methods
}
A single class can also implement multiple interfaces. What if two interfaces have a method defining the same name and signature?
There is a tricky point:
interface A {
void test();
}
interface B {
void test();
}
class C implements A, B {
#Override
public void test() {
}
}
Then single implementation works for both :).
Read my complete post here:
http://codeinventions.blogspot.com/2014/07/can-interface-extend-multiple.html

An interface can extend multiple interfaces.
A class can implement multiple interfaces.
However, a class can only extend a single class.
Careful how you use the words extends and implements when talking about interface and class.

From the Oracle documentation page about multiple inheritance type,we can find the accurate answer here.
Here we should first know the type of multiple inheritance in java:-
Multiple inheritance of state.
Multiple inheritance of implementation.
Multiple inheritance of type.
Java "doesn't support the multiple inheritance of state, but it support multiple inheritance of implementation with default methods since java 8 release and multiple inheritance of type with interfaces.
Then here the question arises for "diamond problem" and how Java deal with that:-
In case of multiple inheritance of implementation java compiler gives compilation error and asks the user to fix it by specifying the interface name.
Example here:-
interface A {
void method();
}
interface B extends A {
#Override
default void method() {
System.out.println("B");
}
}
interface C extends A {
#Override
default void method() {
System.out.println("C");
}
}
interface D extends B, C {
}
So here we will get error as:-
interface D inherits unrelated defaults for method() from types B and C interface D extends B, C
You can fix it like:-
interface D extends B, C {
#Override
default void method() {
B.super.method();
}
}
In multiple inheritance of type java allows it because interface doesn't contain mutable fields and only one implementation will belong to the class so java doesn't give any issue and it allows you to do so.
In Conclusion we can say that java doesn't support multiple inheritance of state but it does support multiple inheritance of implementation and multiple inheritance of type.

Can an interface extend multiple interfaces in java?
Answer is: Yes.
According to JLS
An interface may be declared to be a direct extension of one or more
other interfaces, meaning that it implicitly specifies all the member
types, abstract methods, and constants of the interfaces it extends,
except for any member types and constants that it may hide.

You can extend multiple Interfaces but you cannot extend multiple classes.
The reason that it is not possible in Java to extending multiple classes, is the bad experience from C++ where this is possible.
The alternative for multipe inheritance is that a class can implement multiple interfaces (or an Interface can extend multiple Interfaces)

I think your confusion lies with multiple inheritance, in which it is bad practise to do so and in Java this is also not possible. However, implementing multiple interfaces is allowed in Java and it is also safe.

A Java class can only extend one parent class. Multiple inheritance is not allowed. Interfaces are not classes, however, and an interface can extend more than one parent interface.
for example, take a look here: http://www.tutorialspoint.com/java/java_interfaces.htm

Java - Implement two interfaces with different methods

Say there are two interfaces, which have different methods. I am implementing both interfaces in a class and using methods of both the interfaces.
interface A { void show1(); }
interface B { void show(); }
public class test implements A, B{
#Override
void show1(){
System.out.println("show1");
}
#Override
void show(){
System.out.println("show");
}
}
Definition of Multiple Inhertiance:
Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit characteristics and features from more than one parent object or parent class.
Question
Can I say what I did in my program is Multiple Inheritance ? If No, Why ?
Note
I am using Java 7.

No. Because main purpose of interface is abstraction, which means hide implementation details from outside. So if you implement one or more interfaces, that relationship is a like a relationship and not is a relationship.
Another purpose of using interfaces is loose coupling between classes. (side outcome of abstraction).
See this is a nice example

I think implementation of multiple interfaces is not multiple inheritance.
Your object may have implementation of multiple interfaces. For example your Car object may have interface like BreakStatus, FuelTank interfaces but it's not defined Car as a sub-type/derived-type of BreakStatus, FuelTank.
Inheritance is: One object extends other object(parent) properties and/or behaviors.
Java object does not support multiple inheritance(extending multiple object) something like class Child extends Parent1, Parent2 {}
N.B. Java interfaces support extending multiple interfaces, e.g. interface I3 extends I1, I2 {}

Yes what you did in your program is multiple inheritance.
The Java programming language supports multiple inheritance of type, which is the ability of a class to implement more than one interface. An object can have multiple types: the type of its own class and the types of all the interfaces that the class implements.
https://docs.oracle.com/javase/tutorial/java/IandI/multipleinheritance.html

Yes you are achieving multiple inheritance using multiple interface, where you can inheriting the definition of two different interfaces.
In java, multiple Inheritance is achieved using Multiple interfaces. Methods in an interface are always abstract by default, which doesn’t let them to give their implementation (or method definition ) in interface itself.

Java allowing multiple inheritance

I am confused regarding a concept in multiple inheritance.
I have three classes A, B and C.
Class A {
// ...
}
Class B extends A {
// ...
}
Class C extends B {
// ...
}
I know this is a bad practice of multiple inheritance and I also read java allows multiple inheritance through interfaces. But I am not getting any error in the above code. Please can anyone explain me with a clear example without using interface.
Thanks!!

This is not multi-inheritance. Each class has exactly one direct super class. If your example was considered multi-inheritance, you wouldn't be able to use the extends keyword at all, since each class already extends by default the Object class.
Multi-inheritence would be
class C extends A,B {}
And that's illegal in Java.

Your code does not contain multiple inheritance, and is, indeed, legal Java syntax. Multiple inheritance refers to a case where a class directly extends two superclasses. For example:
public class MyClass extends MyFather, MyMother {
}
Note that this is, of course, illegal Java syntax.

"Multiple inheritance" in Java basically means inheriting multiple interfaces, not inheriting multiple implementations.
Now, there is a new feature of Java 8 that allows you to do something like multiple inheritance of actual implementations, via interfaces and something called default methods. I would strongly encourage you to really master the basics of Java first before trying them. Once you are ready, here is a good tutorial on default methods.

The code you have written above is an example of Multilevel inheritance not Multiple Inheritance.
Multiple Inheritance is like :
class A extends B,C {
//this code is not valid in JAVA
}
And, if you want to use interfaces for implementing a structure like multiple inheritance, then you could use:
interface test_interface1{
/*all the methods declared here in this interface should be the part
** of the class which is implementing this current interface
*/
}
Similarly :
interface test_interface2{
}
So, create a class TestClass like :
class TestClass implements test_interface1,test_interface2 {
//now you have to use each and every method(s) declared in both the interfaces
// i.e. test_interface1 & test_interface2
}
You could also use a syntax like:
class TestClass extends AnyClass implements test_interface1,test_interface2 {
/* but do keep in mind - use extends keyword before implements
** and now you know you cannot use more than 1 class names with extends keyword
** in java.
*/

Java instance vs Abstract Classes and methods

I am new to Java and have been reading up on its main topics. I recently covered abstract classes and instances. I have read their definitions so its not a definition i am looking for.
I need help understanding why I would need to use an interface. All the examples I have seen of interfaces on java tutorials online to me seem like they can be implemented using an abstract class/method combination instead.
Is there a common scenario where only an interface can be used to solve the issue and a combination of abstract class/method would not?

A good example from the Java APIs is the LinkedList class.
As you can see from the link, it implements both the List and the Deque interfaces (as well as a few others), allowing it to be used whenever one or the other is needed. This would not have been possible using only abstract classes.

An interface defines a new secondary
datatype in Java.
It (interface) is a group of final variables
and abstract methods only.
The members of an interface are "public"
by default. Infact private and protected
modifiers are not allowed in an interface.
An interface is a reference type only
its objects cannot be created.
An interface can inherit another interface
but cannot inherit any class.
A class cannot inherit any interface but
it (a class) can implement zero to many
interfaces.
If a class implements interfaces then
1) It has to override all the abstract
methods of all the implemented interfaces.
2) Type compatibilty gets created between
the interface and the class. It allows an
interface reference can refer to object
of implementing class.
interface Iface
{
int x = 3;//final and public by default
void f();//abstract and public by default
}
interface AnotherI extends Iface
{
//more declarations possible here
}
class InterfaceDemo implements Iface
{
public void f()
{
int i;
for(i =0 ; i< x; i++)
System.out.println("Interfaces are widely used");
}
public static void main(String args[])
{
Iface ref = new InterfaceDemo();
ref.f();//allowed
//ref.newMethodsOfClass();//not allowed
}
}

The main difference is that you can only extend one class but you can implement multiple interfaces.
This can be important if you want to (for example) implement a listener while also extending another class. Note though that in many cases you are better off using an anonymous inner class to do the listening.

Java does not support polymorphic inheritance - where a class can extend multiple classes. This choice was made to avoid the problems associated with hierarchical conflict resolution (where a method exists in both parent classes - which one do you use?). In simple parlance, in java there can only be one "is a" relationship.
However, to allow a form of polymorphism, interfaces were introduced. These are hollow templates for which the class must provide implementations, and offer a way of creating a "look like a" relationship. While only allowing an object to "be" a instance of one (parent) class, it may "look like" any number of interfaces.
By taking inheritance out of interfaces, it allows cross-cutting concepts to be handled - ie where classes of completely different inheritance structures may nevertheless share some abstract similarity. A good example from the JDK is Serializable, which is a marker interface (one without methods). Virtually any class has the possibility to be serializable, but virtually all serializable classes don't share any of their inheritance hierarchy. This concept couldn't be handled with abstract classes - you have to step out of the class hierarchy to achieve it - ie interfaces is the only way to do it.