Interface vs Abstract Class in Java

Expected Interview Answer

Step-by-Step Explanation

1. Step 1

   Check the relationship

   Use an abstract class for a true is-a hierarchy; use an interface for a capability shared across unrelated types.

2. Step 2

   Decide on shared code

   If subclasses need common implemented methods or fields, an abstract class fits; a contract-only need suits an interface.

3. Step 3

   Consider multiple inheritance

   A class extends one abstract class but can implement many interfaces, so interfaces allow mixing capabilities.

4. Step 4

   Account for state and constructors

   Abstract classes can hold instance state and constructors; interfaces cannot hold instance fields.

5. Step 5

   Leverage default methods carefully

   Since Java 8, interfaces can add default methods for evolution without breaking implementers.

Code Example

interface Drivable {
    void drive(); // contract only
    default void honk() { System.out.println("Beep"); } // Java 8+
}

abstract class Vehicle {
    private final String name; // state allowed
    Vehicle(String name) { this.name = name; } // constructor allowed
    abstract void start();
    String name() { return name; } // shared concrete method
}

class Car extends Vehicle implements Drivable {
    Car(String name) { super(name); }
    @Override void start() { System.out.println(name() + " started"); }
    @Override public void drive() { System.out.println(name() + " driving"); }
}

public class Demo {
    public static void main(String[] args) {
        Car c = new Car("Sedan");
        c.start();
        c.drive();
        c.honk();
    }
}

Follow-up Questions

• Can a Java class extend a class and implement an interface at the same time?
• What changed for interfaces in Java 8 and Java 9?
• Why does Java forbid multiple class inheritance but allow multiple interfaces?
• Can an abstract class implement an interface without defining all its methods?
• How do default methods cause the diamond problem and how is it resolved?