Multiple Inheritance In Java: How to Use


By squashlabs, Last Updated: July 20, 2023

Multiple Inheritance In Java: How to Use

Introduction to Multiple Inheritance

Multiple inheritance is a feature in object-oriented programming languages that allows a class to inherit properties and behavior from multiple parent classes. In Java, however, multiple inheritance of classes is not supported. This is because it can lead to the diamond problem, where conflicts arise when two parent classes have a method with the same name.

Related Article: How To Parse JSON In Java

The Concept of Interfaces

Interfaces in Java provide a way to achieve a form of multiple inheritance. An interface defines a contract for a class, specifying a set of methods that the class must implement. It allows classes to have multiple behaviors by implementing multiple interfaces.

Use Case: Multiple Inheritance in Data Models

public interface Auditable {
    void audit();

public interface Serializable {
    void serialize();

public class Customer implements Auditable, Serializable {
    // implementation of methods from Auditable and Serializable
    // ...

Use Case: Multiple Inheritance in Design Patterns

public interface MessageSender {
    void sendMessage(String message);

public interface MessageReceiver {
    void receiveMessage(String message);

public class MessageService implements MessageSender, MessageReceiver {
    // implementation of methods from MessageSender and MessageReceiver
    // ...

Related Article: How To Convert Array To List In Java

Use of Single Inheritance and Interfaces

In Java, a class can only inherit from a single parent class using single inheritance. This is done using the extends keyword. However, a class can implement multiple interfaces using the implements keyword.

The Role of Abstract Classes

Abstract classes in Java provide a way to partially implement an interface. They can have both abstract and non-abstract methods, allowing classes to inherit and implement common behavior. Abstract classes cannot be instantiated directly and require concrete subclasses to provide implementations for their abstract methods.

Code Snippet: Implementing Multiple Inheritance Using Interfaces

public interface Walkable {
    void walk();

public interface Swimmable {
    void swim();

public class Duck implements Walkable, Swimmable {
    public void walk() {
        System.out.println("Duck is walking");
    public void swim() {
        System.out.println("Duck is swimming");

Related Article: How To Iterate Over Entries In A Java Map

Code Snippet: Implementing Multiple Inheritance Using Abstract Classes

public abstract class Animal {
    public abstract void move();

public interface Flyable {
    void fly();

public class Bird extends Animal implements Flyable {
    public void move() {
        System.out.println("Bird is moving");
    public void fly() {
        System.out.println("Bird is flying");

Use Case: Multiple Inheritance in GUI Development

Multiple inheritance can be useful in GUI development. For example, a class can inherit from a base GUI class and implement additional interfaces for specific functionalities such as event handling or data binding.

Use Case: Multiple Inheritance in Database Interaction

Multiple inheritance can also be applied in database interaction scenarios. A class can inherit from a base database class and implement interfaces for different types of database operations, such as querying, inserting, or updating data.

Related Article: How To Split A String In Java

Best Practice: Avoiding Diamond Problem

The diamond problem occurs when a class inherits from two or more classes that have a common parent, leading to conflicts in method resolution. To avoid this problem, Java does not allow multiple inheritance of classes. Instead, interfaces can be used to achieve similar behavior without the conflicts.

Best Practice: Interface Segregation Principle

The interface segregation principle suggests that interfaces should be fine-grained and focused on specific behaviors. This helps in avoiding unnecessary dependencies and allows classes to implement only the interfaces they need, promoting better code organization and maintainability.

Performance Consideration: Memory Footprint

Using multiple interfaces can increase the memory footprint of an object, as each interface requires its own set of methods to be implemented. However, this increase is generally negligible unless a large number of interfaces are implemented.

Related Article: How To Convert Java Objects To JSON With Jackson

Performance Consideration: Execution Speed

There is no significant impact on execution speed when using multiple interfaces. The performance overhead is minimal, as method dispatch is usually determined at compile-time or runtime using efficient lookup tables.

Advanced Technique: Using Default Methods in Interfaces

Default methods in interfaces were introduced in Java 8 to provide a way to add new methods to existing interfaces without breaking compatibility with classes that implement them. Default methods have an implementation in the interface itself and can be overridden by implementing classes if needed.

Code Snippet: Default Methods in Action

public interface Printable {
    default void print() {

public class Document implements Printable {
    // no need to implement the print method

public class Report implements Printable {
    public void print() {
        System.out.println("Printing a report...");

Related Article: Storing Contact Information in Java Data Structures

Advanced Technique: Using Private Methods in Interfaces

Private methods in interfaces were also introduced in Java 9. They provide a way to share common code among default methods within the interface. Private methods cannot be accessed or overridden by implementing classes.

Code Snippet: Private Methods in Action

public interface Loggable {
    default void log() {
    private String getLogMessage() {
        return "Logging message";
    private void logMessage(String message) {

public class Logger implements Loggable {
    // no need to implement the log method

Error Handling: Dealing with Incompatible Method Signatures

In cases where two interfaces define methods with the same name but different parameters, implementing classes must provide distinct implementations for each method. This can be achieved by using method overloading or by explicitly implementing the methods with different names.

Related Article: How to Convert JSON String to Java Object

Error Handling: Resolving Ambiguities in Method Calls

If a class implements multiple interfaces that define methods with the same name and parameters, the implementing class must provide its own implementation of the method to resolve the ambiguity. The implementing class can choose to call one of the methods or provide a completely new implementation.

How to Reverse a String in Java

This article serves as a guide on reversing a string in Java programming language. It explores two main approaches: using a StringBuilder and using a char array.... read more

How to Generate Random Integers in a Range in Java

Generating random integers within a specific range in Java is made easy with the Random class. This article explores the usage of java.util.Random and ThreadLocalRandom... read more

How to Retrieve Current Date and Time in Java

Obtain the current date and time in Java using various approaches. Learn how to use the java.util.Date class and the java.time.LocalDateTime class to retrieve the... read more

Java Equals Hashcode Tutorial

Learn how to implement equals and hashcode methods in Java. This tutorial covers the basics of hashcode, constructing the equals method, practical use cases, best... read more

How To Convert String To Int In Java

How to convert a string to an int in Java? This article provides clear instructions using two approaches: Integer.parseInt() and Integer.valueOf(). Learn the process and... read more

Java Composition Tutorial

This tutorial: Learn how to use composition in Java with an example. This tutorial covers the basics of composition, its advantages over inheritance, and best practices... read more