How does Java handle multiple inheritance?

The Restriction on Class Inheritance

Java explicitly forbids multiple inheritance of classes, meaning a class can only extend one superclass. This constraint exists primarily to avoid the 'Diamond Problem,' where a class inherits from two parents that share a common ancestor. If both parents provide conflicting implementations of a method from that ancestor, the compiler faces an undecidable situation regarding which implementation to invoke. By forcing a single inheritance hierarchy for state, Java ensures that the memory layout of an object is always deterministic and predictable. When you create a class, you are establishing an 'is-a' relationship that defines the core identity and data structure of that object. Restricting this to a single parent prevents fragile hierarchies where changes in distant base classes cause unpredictable side effects across complex, deeply nested object trees, maintaining stability in large-scale enterprise systems.

public class Vehicle {
    protected String brand = "Generic";
}

// Multiple inheritance of state is forbidden here
// public class FlyingCar extends Vehicle, Aircraft { } 

public class Car extends Vehicle {
    public void display() {
        System.out.println("Brand: " + brand);
    }
}

Interfaces as the Solution for Behavior

While class inheritance is limited, Java permits a class to implement an unlimited number of interfaces. This allows a class to exhibit multiple 'can-do' behaviors without inheriting the internal state or field variables of multiple parents. Interfaces serve as a contract, defining a set of methods that a class must provide, regardless of its position in the class hierarchy. This separation of concerns is fundamental: classes define the 'what' of an object—its data and identity—while interfaces define the 'how'—its capabilities and public interactions. Because interfaces traditionally contained no implementation, there was no risk of method conflicts regarding field initialization or complex logic. By separating state (classes) from capability (interfaces), Java provides a robust mechanism to share behavior across unrelated classes, enabling polymorphic design where components can be swapped or combined based on what they do rather than what they are.

interface Flyable { void takeOff(); }
interface Drivable { void drive(); }

// A class can implement multiple behaviors
public class FlyingCar implements Flyable, Drivable {
    public void takeOff() { System.out.println("Taking off"); }
    public void drive() { System.out.println("Driving on road"); }
}

Resolving Conflicts with Default Methods

Modern Java introduced 'default' methods, which allow interfaces to contain actual implementation logic. This reintroduced potential ambiguity, as a class might implement two interfaces that provide the same default method. To handle this, the Java compiler mandates that the implementing class must explicitly override any conflicting methods. This is a deliberate design choice that forces the developer to resolve the ambiguity at compile time, preventing runtime errors. By requiring an explicit override, Java maintains its commitment to type safety and predictability. When you override a conflicting method, you have the option to pick one parent's implementation, combine them, or provide entirely new logic. This mechanism ensures that the language remains flexible enough to evolve over time by adding new capabilities to interfaces, while simultaneously ensuring that the developer remains in full control over the final execution behavior of the class.

interface A { default void execute() { System.out.println("A"); } }
interface B { default void execute() { System.out.println("B"); } }

public class Processor implements A, B {
    @Override
    public void execute() {
        // Explicit resolution of ambiguity
        A.super.execute(); 
    }
}

Inheriting Constants from Interfaces

Interfaces in Java can define constant fields, which are implicitly public, static, and final. While this might look like multiple inheritance of state, it is functionally different because these fields are not instance variables; they are shared, immutable global constants. Because they are static, they do not participate in object instance creation or the object memory layout, effectively bypassing the ambiguity issues of class inheritance. When a class implements an interface, it gains access to these constants, facilitating a shared configuration or set of flags across disparate components. This pattern is often used for defining markers or common system settings. Since the values cannot change at runtime, there is zero risk of data inconsistency, ensuring that different classes implementing the same interface remain synchronized regarding their shared constants without needing to duplicate the underlying memory footprint or logic.

interface Settings {
    int MAX_SPEED = 200; // Implicitly public static final
}

public class Engine implements Settings {
    public void checkSpeed() {
        System.out.println("Max allowed: " + MAX_SPEED);
    }
}

Polymorphism through Interface References

The true power of interface-based design emerges through polymorphism, where you treat an object based on its interface rather than its concrete class. By coding against an interface, you decouple your business logic from specific implementation details. This makes your code highly maintainable because you can change the underlying class implementation—for example, swapping a database-backed storage service for an in-memory one—without modifying the consumer code. Because Java allows a single object to be passed as any of its implemented interfaces, you can write highly generic utility methods that operate on any object sharing a specific capability. This strategy leverages multiple inheritance of behavior to create highly modular, decoupled systems where components interact through well-defined contracts. This approach is the bedrock of professional enterprise development, ensuring that systems remain scalable even as the complexity of individual components grows significantly over time.

interface Worker { void work(); }

public class Manager {
    // Accepts any object that implements Worker
    public void executeTask(Worker w) { w.work(); }
}

public class Developer implements Worker {
    public void work() { System.out.println("Coding"); }
}

Interview questions

All java interview questions →

Check yourself

Take the full java quiz →