Overview

In Java 8, a significant enhancement was introduced allowing interfaces to define implementation with default methods. This feature helps in extending interfaces without breaking the classes that implement these interfaces. However, it also introduces the possibility of conflicts when a class implements multiple interfaces that contain default methods with the same signature. Understanding how Java resolves these conflicts is crucial for designing interfaces and implementing classes in Java 8.

Key Concepts

1. Default Methods: Methods in an interface that have a body. They are not abstract and can provide a default implementation.
2. Multiple Inheritance of Behavior: With default methods, Java allows classes to inherit behavior from multiple interfaces.
3. Conflict Resolution Strategies: Java provides specific rules to resolve conflicts arising from multiple inherited default methods.

Common Interview Questions

Basic Level

1. What are default methods in Java 8 interfaces?
2. How does Java resolve a conflict when a class implements two interfaces that have default methods with the same signature?

Intermediate Level

3. How does the super keyword play a role in resolving default method conflicts in Java 8?

Advanced Level

4. Can you explain the rules for default method conflict resolution with an example where a class inherits a default method from an interface, and there is a method with the same signature in its superclass?

Detailed Answers

1. What are default methods in Java 8 interfaces?

Answer: Default methods are methods defined in an interface with a body. Before Java 8, interfaces could only have abstract methods. The introduction of default methods in Java 8 allows an interface to provide an implementation for methods. This feature helps to add new methods to interfaces without breaking the existing implementations.

Key Points:
- Default methods are declared using the default keyword.
- They provide flexibility to interface evolution.
- They enable "multiple inheritance of behavior" by allowing a class to inherit method implementations from multiple interfaces.

Example:

interface Vehicle {
    default void print() {
        System.out.println("I am a vehicle!");
    }
}

2. How does Java resolve a conflict when a class implements two interfaces that have default methods with the same signature?

Answer: When a class implements two or more interfaces that contain default methods with the same signature, Java follows specific rules to resolve the conflict:
1. The class implementing the interfaces must override the conflicting default method.
2. The overridden method can call a specific interface's default method using the InterfaceName.super.methodName() syntax.

Key Points:
- If a class does not override the conflicting default methods, a compile-time error occurs.
- Explicitly overriding and specifying which default method to use resolves the conflict.

Example:

interface FirstInterface {
    default void show() {
        System.out.println("FirstInterface's show");
    }
}

interface SecondInterface {
    default void show() {
        System.out.println("SecondInterface's show");
    }
}

class MyClass implements FirstInterface, SecondInterface {
    // Resolving conflict by overriding the conflicting method
    public void show() {
        FirstInterface.super.show(); // Chooses FirstInterface's version of show()
    }
}

3. How does the super keyword play a role in resolving default method conflicts in Java 8?

Answer: In the context of resolving default method conflicts, the super keyword is used to refer to the default method of a specific interface. It allows a class to explicitly specify which interface's default method it wants to use when there is a conflict between multiple implemented interfaces.

Key Points:
- The syntax InterfaceName.super.methodName() is used.
- It provides a precise way to invoke a specific interface's default method.
- It's essential when a class implements multiple interfaces with conflicting default methods.

Example:

interface FirstInterface {
    default void perform() {
        System.out.println("Performing from FirstInterface");
    }
}

interface SecondInterface {
    default void perform() {
        System.out.println("Performing from SecondInterface");
    }
}

class ActionClass implements FirstInterface, SecondInterface {
    // Using super to resolve default method conflict
    public void perform() {
        SecondInterface.super.perform(); // Explicitly using SecondInterface's perform
    }
}

4. Can you explain the rules for default method conflict resolution with an example where a class inherits a default method from an interface, and there is a method with the same signature in its superclass?

Answer: When a class inherits a method with the same signature from its superclass and a default method from an interface, the method from the superclass takes precedence over the interface's default method. This rule is part of Java's class wins rule in conflict resolution.

Key Points:
- Superclass method overrides the interface default method.
- If the superclass provides a concrete method, the default method acts as if it's not present for the inheriting class.
- This rule helps in preserving the behavior of existing classes when new interfaces are introduced into the application.

Example:

class SuperClass {
    void display() {
        System.out.println("Display from SuperClass");
    }
}

interface MyInterface {
    default void display() {
        System.out.println("Display from MyInterface");
    }
}

class SubClass extends SuperClass implements MyInterface {
    // No need to override display(), SuperClass's display() takes precedence
}

public class TestConflictResolution {
    public static void main(String[] args) {
        SubClass obj = new SubClass();
        obj.display(); // Prints "Display from SuperClass"
    }
}

In this example, even though SubClass inherits the default display() method from MyInterface, the implementation from SuperClass takes precedence, adhering to the class wins rule.