Why Java Doesn't Support Multiple Inheritance

Direct Answer

Java's class model allows one direct superclass. This avoids having to define how a subclass combines two sets of instance state, constructor chains, and competing inherited implementations—the family of problems illustrated by a diamond hierarchy. Java allows a class to implement multiple interfaces and has explicit rules for conflicting default methods.

Code Example

// Two interfaces — both define a default move()
interface Swimmer {
    default String move() { return "swim"; }
}

interface Walker {
    default String move() { return "walk"; }
}

// A class CAN implement both interfaces
class Amphibian implements Swimmer, Walker {

    @Override
    public String move() {
        // Must override — Java forces you to resolve the clash
        return Swimmer.super.move() + " and " + Walker.super.move();
    }
}

// This would NOT compile — classes can't multiply inherit
// class D extends B, C { }  // compile error: multiple inheritance not allowed

public class Main {
    public static void main(String[] args) {
        Amphibian frog = new Amphibian();
        System.out.println(frog.move()); // swim and walk
    }
}

Common Mistakes & Pitfalls

• Saying 'Java just doesn't allow it' with no reason — interviewers want the diamond problem named and explained; the rule exists to avoid ambiguous method, field, and constructor resolution, not arbitrarily.
• Claiming Java has no multiple inheritance at all — it does, of type, through interfaces; a class can implement as many as it needs.
• Assuming interfaces are immune to the diamond — since Java 8, two default methods with the same signature clash, and the implementing class must override and resolve it via InterfaceName.super.method().
• Forgetting the real danger is duplicated state — interfaces sidestep the problem only because they hold no instance fields; that's the insight that separates a good answer from a recited one.