What is the difference between an interface and an abstract class in Java?

Answer

Interface vs Abstract Class in Java

Abstract Class

A class declared with abstract keyword. Can have both abstract methods (no body) and concrete methods (with body). Can have fields/state.

Java

abstract class Vehicle {
    // Field — state is allowed
    protected String brand;
    protected int speed;

    // Concrete method — has implementation
    public void startEngine() {
        System.out.println(brand + " engine started");
    }

    // Abstract method — subclass MUST implement
    abstract void refuel();

    // Constructor allowed
    Vehicle(String brand) {
        this.brand = brand;
    }
}

class Car extends Vehicle {
    Car(String brand) { super(brand); }

    @Override
    void refuel() { System.out.println("Filling petrol"); }
}

Interface

A pure contract — defines WHAT to do, not HOW. Before Java 8: all methods abstract. Java 8+: allows default and static methods.

Java

interface Drivable {
    void drive();          // abstract (implicitly public abstract)
    void applyBrakes();    // abstract

    // Java 8+ default method — has body
    default void honk() {
        System.out.println("Beep beep!");
    }

    // Java 8+ static method
    static String getType() { return "Motor Vehicle"; }
}

interface Flyable {
    void fly();
}

// A class can implement MULTIPLE interfaces
class FlyingCar implements Drivable, Flyable {
    public void drive()       { System.out.println("Driving"); }
    public void applyBrakes() { System.out.println("Braking"); }
    public void fly()         { System.out.println("Flying"); }
}

Comparison Table

Feature	Abstract Class	Interface
`extends` / `implements`	`extends` (one only)	`implements` (multiple)
Method types	Abstract + Concrete	Abstract + default + static
Fields	Any (static, instance)	Only `public static final` constants
Constructor	✅ Yes	❌ No
Access modifiers	Any	`public` only
Multiple inheritance	❌ One parent only	✅ Multiple interfaces
When to use	IS-A with shared code	CAN-DO contract

When to Use Which

Use Abstract Class when:

✓Classes share common code/state
✓IS-A relationship (Car IS-A Vehicle)
✓You need constructors or non-public methods

Use Interface when:

✓Unrelated classes share a capability (Flyable — birds AND planes)
✓You want multiple inheritance
✓Defining a contract (API design)

In Automation Frameworks

Java

// Interface — contract for all page objects
interface PageObject {
    boolean isPageLoaded();
    String getPageTitle();
}

// Abstract class — shared Selenium setup
abstract class BasePage implements PageObject {
    protected WebDriver driver;
    protected WebDriverWait wait;

    BasePage(WebDriver driver) {
        this.driver = driver;
        this.wait   = new WebDriverWait(driver, Duration.ofSeconds(10));
        PageFactory.initElements(driver, this);
    }

    // Concrete shared utility
    protected void click(WebElement el) {
        wait.until(ExpectedConditions.elementToBeClickable(el)).click();
    }

    // Subclasses define these
    public abstract boolean isPageLoaded();
    public String getPageTitle() { return driver.getTitle(); }
}