Doesn't Default in Java 8 destroy the whole idea of not allowing us to do multiple inheritance?

Question

Can someone help me understand why they would add Default in Java 8 to allow implementation to interfaces instead of just allowing us to have multiple inheritance in abstract classes? What exactly is the difference between just allowing us to extend multiple classes verses allowing us to create Default methods in interfaces?

Answer 1

No, default doesn't destroy the idea of not allowing multiple inheritence, at least not more than interfaces already do. The point is still that interfaces only specify an interface (method signatures and return values), whereas classes also specify the state of an object. This idea in not broken by default methods, that is, default methods only have access to the methods defined in the interface, not to any member variables (because interfaces cannot define member variables).

So with respect to state, each class still has a single superclass. But with respect to interface, it can have arbitrarily many supertypes.

Answer 2

Can someone help me understand why they would add Default in Java 8 to allow implementation to interfaces instead of just allowing us to have multiple inheritance in abstract classes?

One important reason is super class state. For example;

class OpticalDrive {

}

class DVDDrive extends OpticalDrive {
    protected int speed = 5;
}

class CDDrive extends OpticalDrive {
    protected int speed = 10;
}

class ComboDrive extends DVDDrive, CDDrive {
    ComboDrive() {
        System.out.println(super.speed); 
        super.speed = 15;
    }
}

In above hypothetical example speed state variable is multiple inherited and reading or modifying it creates ambiguity as to which one must be modified.

What exactly is the difference between just allowing us to extend multiple classes verses allowing us to create Default methods in interfaces?

Since interfaces can't have mutable state variables it is better to have default methods in interfaces rather than enabling multiple inheritance of abstract classes. Following example shows Java 8 default method in interface in action.

public interface DvdReader {
        default public void read() {
                System.out.println("DvdReader.read()");
        }
}

public interface CdReader {
        default public void read() {
                System.out.println("CdReader.read()");
        }
}

public class ComboReader implements CdReader, DvdReader {
        public void read() {
                CdReader.super.read();
                DvdReader.super.read();
        }

        public static void main(String[] args) {
                new ComboReader().read();
        }
}

In the above scenario if you ignore overriding read method in ComboReader, the compiler will complain with the following error.

ComboReader.java:1: error: class ComboReader inherits unrelated defaults for read() from types CdReader and DvdReader
public class ComboReader implements CdReader, DvdReader {
       ^
1 error

Furthermore enabling multiple abstract class inheritance means the syntax of Java code has to change significantly causing java's ability to backward compatibility.