Interfaces & Abstract Classes in Java

Knowing when to use which is one of the most common interview questions. Both define contracts, but they serve different purposes.

Abstract Class

A class that cannot be instantiated and may contain both abstract (unimplemented) and concrete (implemented) methods.

public abstract class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;  // constructors allowed
    }

    public abstract void makeSound();  // must be implemented by subclass

    public void sleep() {  // concrete method — shared behavior
        System.out.println(name + " is sleeping");
    }
}

public class Dog extends Animal {
    public Dog(String name) { super(name); }

    @Override
    public void makeSound() {
        System.out.println(name + " barks!");
    }
}

Interface

A contract that defines what a class must do, without specifying how. Since Java 8, interfaces can also have default and static methods.

public interface Flyable {
    void fly();  // implicitly public abstract

    default void land() {  // default method (Java 8+)
        System.out.println("Landing...");
    }

    static boolean canFly(Object obj) {  // static method (Java 8+)
        return obj instanceof Flyable;
    }
}

public interface Swimmable {
    void swim();
}

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

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

Abstract Class vs Interface — Complete Comparison

When to Use Which

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
graph LR
    subgraph AC["🏛️ Use ABSTRACT CLASS when"]
        A1["✅ Classes share state - fields"]
        A2["✅ You need constructors"]
        A3["✅ You want protected/private members"]
        A4["✅ Designing a base class for a family of related types"]
    end
    subgraph IF["🔌 Use INTERFACE when"]
        I1["✅ Defining a capability/contract"]
        I2["✅ Multiple inheritance needed"]
        I3["✅ Unrelated classes share behavior"]
        I4["✅ You want loose coupling - program to an interface"]
    end

    style AC fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF
    style IF fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style A1 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style A2 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style A3 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style A4 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style I1 fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF
    style I2 fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF
    style I3 fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF
    style I4 fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF

Real-world examples

Java 8+ Interface Evolution

%%{init: {'theme': 'base', 'themeVariables': {'fontSize': '13px', 'fontFamily': 'Inter, -apple-system, sans-serif'}, 'flowchart': {'nodeSpacing': 30, 'rankSpacing': 50, 'padding': 12, 'curve': 'basis'}, 'sequence': {'actorMargin': 60, 'messageMargin': 40}, 'class': {'padding': 12}}}%%
graph LR
    J7["☕ Java 7<br/>Only abstract methods"] --> J8["🚀 Java 8<br/>+ default methods<br/>+ static methods"] --> J9["🔒 Java 9<br/>+ private methods<br/>helper methods for defaults"]

    style J7 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style J8 fill:#DBEAFE,stroke:#93C5FD,color:#1E40AF
    style J9 fill:#BFDBFE,stroke:#93C5FD,color:#1E40AF

Why default methods were added

Before Java 8, adding a method to Collection interface would break every class implementing it. Default methods allow interface evolution without breaking existing code.

// Java 8 added stream() to Collection — as a default method
public interface Collection<E> {
    default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }
}
// All existing implementations (ArrayList, HashSet, etc.) got stream() for free

Private methods in interfaces (Java 9)

public interface Logger {
    default void logInfo(String msg) {
        log("INFO", msg);
    }

    default void logError(String msg) {
        log("ERROR", msg);
    }

    private void log(String level, String msg) {  // shared helper — not exposed
        System.out.println("[" + level + "] " + msg);
    }
}

The Diamond Problem

What happens when a class implements two interfaces with the same default method?

public interface A {
    default void greet() { System.out.println("Hello from A"); }
}

public interface B {
    default void greet() { System.out.println("Hello from B"); }
}

public class C implements A, B {
    @Override
    public void greet() {
        A.super.greet();  // explicitly choose which one
    }
}

If you don't override, the compiler gives an error — you must resolve the ambiguity.

Marker Interfaces

Interfaces with no methods — they just "mark" a class as having a certain capability.

Since Java 5+, annotations (@Entity, @Service) mostly replaced marker interfaces because annotations can carry metadata.

Interview Questions