Multiple Inheritance Through Interfaces

A smartphone is a phone, a camera and a music player at the same time. A Java class can extend only one class, but it can implement as many interfaces as it needs. That's how Java offers multiple inheritance of type: one object can be used wherever any of its interfaces is expected, without the diamond problem that multiple class inheritance would bring.

One Class, Several Interfaces

public class Gadgets {
    interface Phone { String call(String who); }
    interface Camera { String click(); }
    interface MusicPlayer { String play(String song); }
 
    static class Smartphone implements Phone, Camera, MusicPlayer {
        public String call(String who) { return "Calling " + who; }
        public String click() { return "Photo saved"; }
        public String play(String song) { return "Playing " + song; }
    }
 
    static void ring(Phone p) { System.out.println(p.call("Srihitha")); }
    static void shoot(Camera c) { System.out.println(c.click()); }
 
    public static void main(String[] args) {
        Smartphone mine = new Smartphone();
        ring(mine);
        shoot(mine);
        MusicPlayer player = mine;
        System.out.println(player.play("Navika's playlist"));
        System.out.println(mine instanceof Camera);
    }
}

Calling Srihitha
Photo saved
Playing Navika's playlist
true

How it works

1. Smartphone implements Phone, Camera, MusicPlayer: one class signs three contracts, separated by commas.
2. The same object is passed to ring as a Phone and to shoot as a Camera. Each method sees only the part of the object it needs.
3. mine instanceof Camera is true: the object is a Camera, as well as a Phone and a MusicPlayer.

Try it yourself: add an interface Torch with String lightOn() and make Smartphone implement it too.

Interfaces Extending Interfaces

An interface can extend several interfaces at once, combining their contracts:

public class Combined {
    interface Readable { String read(); }
    interface Writable { void write(String text); }
    interface Notebook extends Readable, Writable { int pages(); }
 
    static class SchoolNotebook implements Notebook {
        private final StringBuilder text = new StringBuilder();
        public String read() { return text.toString(); }
        public void write(String t) { text.append(t); }
        public int pages() { return 100; }
    }
 
    public static void main(String[] args) {
        Notebook book = new SchoolNotebook();
        book.write("Advitha's science notes");
        System.out.println(book.read() + ", " + book.pages() + " pages");
    }
}

Advitha's science notes, 100 pages

Notebook extends Readable and Writable, so a class implementing Notebook must provide all three methods.

Why No Diamond Problem

Interfaces carry no instance fields, so a class can never end up with two copies of the same state. Abstract methods with the same signature from two interfaces simply merge: the class implements the method once and satisfies both. Only default methods with code can clash, and Java then refuses to compile until the class decides (see "Diamond Problem with Default Methods").

Common Mistakes

Writing implements before extends. The order is fixed: class C extends B implements X.

Using implements between interfaces. An interface extends other interfaces.

Building one giant interface. Classes then have to implement methods they don't need.

Interview Corner

Practice

1. Easy: Create interfaces Swimmer and Runner and a class Triathlete that implements both. Pass the same object to a method that takes a Swimmer and another that takes a Runner.
2. Harder: Create interface Account extends Depositable, Withdrawable and a SavingsAccount that implements it. Show that a SavingsAccount can be passed where any of the three types is expected.

Key Takeaways