Default methods in Java - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of default method call in interface

What is the output of this Java code?

Java

interface Speaker {
    default void sayHello() {
        System.out.println("Hello from Speaker");
    }
}

class Person implements Speaker {
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person();
        p.sayHello();
    }
}

A Compilation error: sayHello() not implemented

B No output

C Runtime error: NullPointerException

D Hello from Speaker

💡 Hint

Remember that default methods in interfaces provide an implementation that classes can inherit.

The interface Speaker has a default method sayHello(). The class Person implements Speaker but does not override sayHello(), so the default method is called, printing "Hello from Speaker".

❓ Predict Output

intermediate

Output when overriding default method

What will be printed when running this code?

Java

interface Printer {
    default void print() {
        System.out.println("Printing from Printer");
    }
}

class Document implements Printer {
    public void print() {
        System.out.println("Printing from Document");
    }
}

public class Main {
    public static void main(String[] args) {
        Document doc = new Document();
        doc.print();
    }
}

A Printing from Printer

B Printing from Document

C Runtime error: MethodNotFoundException

D Compilation error: print() must be public

💡 Hint

Check if the class overrides the default method.

The class Document overrides the default print() method from Printer interface. So when print() is called on Document instance, the overridden method runs, printing "Printing from Document".

❓ Predict Output

advanced

Resolving conflict between two default methods

What is the output of this code?

Java

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

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

class C implements A, B {
    public void show() {
        A.super.show();
    }
}

public class Main {
    public static void main(String[] args) {
        C c = new C();
        c.show();
    }
}

A Compilation error: class C must override show()

B B show

C A show

D Runtime error: AmbiguousMethodException

💡 Hint

When two interfaces have the same default method, the implementing class must resolve the conflict explicitly.

Class C implements both interfaces A and B which have default show() methods. To resolve the conflict, C overrides show() and calls A's version explicitly using A.super.show(). So output is "A show".

🔧 Debug

advanced

Identify the compilation error in default method usage

This code does not compile. What is the cause of the compilation error?

Java

interface X {
    default void doSomething() {
        System.out.println("Doing something");
    }
}

class Y implements X {
    public void doSomething() {
        System.out.println("Doing something else");
    }
}

public class Main {
    public static void main(String[] args) {
        Y y = new Y();
        y.doSomething();
    }
}

A Method doSomething() in class Y must be public to override interface method

B Interface X cannot have default methods

C Class Y must be abstract

D Main class must implement interface X

💡 Hint

Check the access modifier of the overriding method compared to the interface method.

Interface methods are implicitly public. When overriding, the method in the class must be public or more accessible. Here, doSomething() in Y has default (package-private) access, causing a compilation error.

🧠 Conceptual

expert

Behavior of default methods with multiple inheritance and diamond problem

Consider interfaces I1 and I2 both have a default method foo(). Class D implements both interfaces but does NOT override foo(). What happens when foo() is called on an instance of D?

A Compilation error due to diamond problem; class D must override foo()

B Runtime error due to ambiguous method call

C The foo() method from I2 is called by default

D The foo() method from I1 is called by default

💡 Hint

Java requires explicit resolution when multiple interfaces provide the same default method.

When a class implements two interfaces that have the same default method, Java forces the class to override that method to resolve the conflict. Otherwise, it causes a compilation error.