Hybrid Inheritance in Java

Hybrid inheritance is a combination of two or more types of inheritance — such as single, multiple, and hierarchical inheritance — used together in the same program. It allows a design to model more complex relationships between classes.

Why Java Doesn't Support Hybrid Inheritance with Classes

Since hybrid inheritance often involves multiple inheritance as one of its components, and Java doesn't allow a class to extend more than one class (to avoid the "Diamond Problem"), true hybrid inheritance through classes alone isn't possible in Java.

The Diamond Problem

The diamond problem occurs when a class inherits from two classes that both define the same method, creating ambiguity about which version should be used. Java avoids this entirely by only allowing single class inheritance.

Achieving Hybrid Inheritance Using Interfaces

Java achieves the effect of hybrid inheritance by combining class inheritance (extends) with multiple interface implementation (implements), since a class can implement any number of interfaces.

interface Flyable {
    void fly();
}

interface Swimmable {
    void swim();
}

class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

class Duck extends Animal implements Flyable, Swimmable {
    public void fly() {
        System.out.println("Duck can fly");
    }
    public void swim() {
        System.out.println("Duck can swim");
    }
}

How This Models Hybrid Behavior

In the example above, Duck uses single inheritance from Animal combined with multiple interface implementation from Flyable and Swimmable — together forming a hybrid structure without any ambiguity, since interfaces (prior to default methods) don't carry implementation that could conflict.

• Hybrid inheritance combines two or more inheritance types in one design
• Java can't do this purely with classes due to the diamond problem
• Interfaces let Java simulate hybrid inheritance safely and predictably