Multiple Interfaces in Java: Syntax, Examples, Default Methods & Polymorphism

Multiple Interfaces in Java

Real-world objects rarely have only one capability. A modern smartphone can make calls, connect to the internet, capture photos, play audio, and use location services. If we tried to model every capability using a single inheritance hierarchy, the design could quickly become restrictive.

Java solves this problem by allowing a class to implement multiple interfaces. Each interface can represent an independent capability, and one class can agree to fulfill several contracts at the same time.

A Java class can extend only one class, but it can implement multiple interfaces. This gives Java a safe and flexible way to achieve multiple inheritance of type.

Why Do We Need Multiple Interfaces?

Suppose a device can both print and scan documents. Printing and scanning are two different capabilities, so representing them as separate interfaces makes the design clear.

interface Printable
{
    void print();
}

interface Scannable
{
    void scan();
}

A single class can implement both interfaces.

class Printer implements Printable, Scannable
{
    @Override
    public void print()
    {
        System.out.println("Printing document");
    }

    @Override
    public void scan()
    {
        System.out.println("Scanning document");
    }
}

The class now has both capabilities without requiring either interface to inherit from the other.

Syntax for Multiple Interfaces

Multiple interfaces are specified after the implements keyword, separated by commas.

class ClassName implements InterfaceOne, InterfaceTwo, InterfaceThree
{
    // Implement required methods
}

For example:

class SmartPhone implements Camera, MusicPlayer, GPS
{
    // Implement methods from all interfaces
}

The class must satisfy the contracts defined by all three interfaces, assuming they contain abstract methods that require implementation.

Simple Multiple Interface Example

Let's model a worker who can both code and test software.

interface Developer
{
    void writeCode();
}

interface Tester
{
    void testSoftware();
}

class SoftwareEngineer implements Developer, Tester
{
    @Override
    public void writeCode()
    {
        System.out.println("Writing application code");
    }

    @Override
    public void testSoftware()
    {
        System.out.println("Testing application");
    }
}

The SoftwareEngineer class fulfills two independent contracts. It is both a Developer and a Tester from the perspective of the type system.

Why Java Allows Multiple Interfaces

Java does not allow a class to extend multiple classes:

class C extends A, B
{
    // Invalid Java syntax
}

One major reason is that multiple class inheritance can create ambiguity when parent classes contain the same members or state. Interfaces provide a cleaner mechanism for combining contracts and capabilities.

For example, Java can safely express:

class C implements A, B
{
}

The class is free to provide its own implementation for the required operations.

Multiple Interface References

When a class implements multiple interfaces, its object can be referenced through any compatible interface type.

interface Printable
{
    void print();
}

interface Scannable
{
    void scan();
}

class Printer implements Printable, Scannable
{
    @Override
    public void print()
    {
        System.out.println("Printing");
    }

    @Override
    public void scan()
    {
        System.out.println("Scanning");
    }
}

class Main
{
    public static void main(String[] args)
    {
        Printer printer = new Printer();

        Printable printable = printer;
        Scannable scannable = printer;

        printable.print();
        scannable.scan();
    }
}

The same object can be viewed through different interfaces depending on the capability the current code needs.

An object does not change when you assign it to different interface references. Only the set of members visible through the reference changes.

Multiple Interfaces and Polymorphism

Multiple interfaces work naturally with polymorphism. Each interface reference can invoke the behavior defined by its own contract.

interface Printable
{
    void print();
}

interface Shareable
{
    void share();
}

class Report implements Printable, Shareable
{
    @Override
    public void print()
    {
        System.out.println("Printing report");
    }

    @Override
    public void share()
    {
        System.out.println("Sharing report");
    }
}

class Main
{
    public static void main(String[] args)
    {
        Report report = new Report();

        Printable printable = report;
        Shareable shareable = report;

        printable.print();
        shareable.share();
    }
}

The code using Printable does not need to know that the object also implements Shareable. Each part of the application can depend only on the capability it requires.

Multiple Interfaces with a Common Method

Now consider a more interesting situation. Two interfaces define a method with the same signature.

interface A
{
    void display();
}

interface B
{
    void display();
}

class C implements A, B
{
    @Override
    public void display()
    {
        System.out.println("Display implementation");
    }
}

There is no problem here because both interfaces require the same method signature. One implementation can satisfy both contracts.

When multiple interfaces declare the same abstract method signature, a single compatible implementation in the class can satisfy both interface contracts.

Multiple Interfaces with Different Methods

When interfaces define different operations, the implementing class simply provides each required implementation.

interface Flyable
{
    void fly();
}

interface Swimmable
{
    void swim();
}

class Duck implements Flyable, Swimmable
{
    @Override
    public void fly()
    {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim()
    {
        System.out.println("Duck is swimming");
    }
}

This is a clean representation of a class possessing multiple independent capabilities.

Multiple Interfaces and Default Methods

Modern Java interfaces can contain default methods. This introduces an important rule when two interfaces provide default methods with the same signature.

Suppose two interfaces provide different implementations of the same default method.

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

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

class C implements A, B
{
}

The compiler cannot automatically choose between the two default implementations. Therefore, C must resolve the conflict by overriding the method.

class C implements A, B
{
    @Override
    public void display()
    {
        System.out.println("C display");
    }
}

If two interfaces provide conflicting default methods with the same signature, the implementing class must resolve the conflict by providing its own implementation.

Calling a Specific Interface Default Method

Java also provides a special syntax for explicitly calling a particular interface's default implementation.

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

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

class C implements A, B
{
    @Override
    public void display()
    {
        A.super.display();
    }
}

The expression A.super.display() explicitly selects the default implementation supplied by interface A.

You can similarly call B.super.display() when appropriate.

Interface Inheritance with Multiple Interfaces

Interfaces themselves can extend multiple interfaces.

interface Printable
{
    void print();
}

interface Scannable
{
    void scan();
}

interface MultiFunctionDevice extends Printable, Scannable
{
    void fax();
}

Now a class implementing MultiFunctionDevice must satisfy the contracts inherited from both parent interfaces as well as the new fax() method.

class OfficeMachine implements MultiFunctionDevice
{
    @Override
    public void print()
    {
        System.out.println("Printing");
    }

    @Override
    public void scan()
    {
        System.out.println("Scanning");
    }

    @Override
    public void fax()
    {
        System.out.println("Faxing");
    }
}

Class Extending a Class and Implementing Interfaces

A class can extend one class and implement multiple interfaces at the same time.

class Machine
{
    void powerOn()
    {
        System.out.println("Machine powered on");
    }
}

interface Printable
{
    void print();
}

interface Scannable
{
    void scan();
}

class Printer extends Machine implements Printable, Scannable
{
    @Override
    public void print()
    {
        System.out.println("Printing document");
    }

    @Override
    public void scan()
    {
        System.out.println("Scanning document");
    }
}

This is a very common Java design pattern. The class inherits implementation from one superclass while adopting multiple independent contracts from interfaces.

A useful mental model is: one class parent for shared inheritance, multiple interfaces for additional capabilities.

Practical Example: E-Commerce Order

Consider an e-commerce order that can be both payable and cancellable.

interface Payable
{
    void pay();
}

interface Cancellable
{
    void cancel();
}

class Order implements Payable, Cancellable
{
    @Override
    public void pay()
    {
        System.out.println("Order payment completed");
    }

    @Override
    public void cancel()
    {
        System.out.println("Order cancelled");
    }
}

class Main
{
    public static void main(String[] args)
    {
        Order order = new Order();

        order.pay();
        order.cancel();
    }
}

This design is easier to understand than putting unrelated responsibilities into one large parent class. Each interface represents a specific capability.

Programming to Multiple Abstractions

You can pass the same object to different methods that expect different interfaces.

interface Printable
{
    void print();
}

interface Shareable
{
    void share();
}

class Document implements Printable, Shareable
{
    @Override
    public void print()
    {
        System.out.println("Printing document");
    }

    @Override
    public void share()
    {
        System.out.println("Sharing document");
    }
}

class PrinterService
{
    void printDocument(Printable printable)
    {
        printable.print();
    }
}

class SharingService
{
    void shareDocument(Shareable shareable)
    {
        shareable.share();
    }
}

class Main
{
    public static void main(String[] args)
    {
        Document document = new Document();

        PrinterService printerService = new PrinterService();
        SharingService sharingService = new SharingService();

        printerService.printDocument(document);
        sharingService.shareDocument(document);
    }
}

This is a powerful architectural idea. Each service depends only on the capability it actually needs. PrinterService does not need to know that the document is also shareable.

Common Beginner Mistakes

Trying to extend multiple classes instead of implementing multiple interfaces.
Forgetting to implement methods from every interface.
Assuming conflicting default methods will automatically be resolved by Java.
Forgetting that a class can implement several interfaces separated by commas.
Creating one huge interface instead of several focused capability-based interfaces.
Confusing multiple interface references with multiple objects. Different references can point to the same object.

Best Practices

Use separate interfaces for separate capabilities or responsibilities.
Keep interfaces small and cohesive.
Use interface types in parameters and return values when you want interchangeable implementations.
Resolve conflicting default methods explicitly instead of relying on implicit behavior.
Use multiple interfaces when the capabilities are genuinely independent and meaningful.

Interview Insights

Question: Can a Java class implement multiple interfaces?

Answer: Yes. A class can implement multiple interfaces by separating their names with commas.

Question: Can a Java class extend multiple classes?

Answer: No. A class can directly extend only one class, but it can implement multiple interfaces.

Question: What happens when two interfaces contain the same abstract method?

Answer: A single compatible implementation in the class can satisfy both interface contracts.

Question: What happens when two interfaces contain conflicting default methods?

Answer: The implementing class must resolve the conflict by overriding the method. It can also explicitly invoke a particular interface's default implementation using the appropriate InterfaceName.super.method() syntax.

Question: Can an interface extend multiple interfaces?

Answer: Yes. An interface can extend multiple interfaces using a comma-separated list.

Quick Revision

Concept	Key Point
Multiple interfaces	A class can implement multiple interfaces using commas.
Multiple classes	A class cannot directly extend more than one class.
Common abstract method	One compatible implementation can satisfy multiple interfaces.
Conflicting default methods	The implementing class must resolve the conflict.
Interface inheritance	An interface can extend multiple interfaces.
Class + interfaces	A class can extend one class and implement multiple interfaces.
Capability design	Separate interfaces can represent independent responsibilities.
Polymorphism	The same object can be viewed through different compatible interface references.

Final Takeaway

Multiple interfaces allow a Java class to combine independent capabilities without inheriting implementation from multiple classes. This gives developers a clean way to model real-world behavior, keep responsibilities focused, and build loosely coupled systems. The key idea is simple: one class can fulfill many contracts. Once you understand that principle, multiple interfaces become a powerful design tool rather than just another Java syntax rule.

Multiple Interfaces in Java: Syntax, Examples, Default Methods & Polymorphism