Abstract Class vs Interface in Java 8+ — Complete Comparison with Decision Rules

Q: Abstract Class vs Interface in Java 8+ — Complete Comparison with Decision Rules

**Abstract class** = partial implementation + state. Supports **instance fields**, **constructors**, **protected/package-private members**, single inheritance only (`extends`). **Interface** = pure contract, with `default` and `static` methods since Java 8 and `private` helpers since Java 9. Supports **public constants only** (no instance state), **no constructors**, a class can implement **many** interfaces. **Decision rule:** use an interface to declare a **capability** (`Comparable`, `Flyable`, `Serializable`); use an abstract class when you have **shared state or protected infrastructure** for a family of related types (e.g., `AbstractList`, `HttpServlet`).

Intermediate·2 min read·

AmazonGoogleMicrosoftOracleFlipkart

Fast recall

Quick revision

Core answer

Abstract class = partial implementation + state. Supports instance fields, constructors, protected/package-private members, single inheritance only (extends). Interface = pure contract, with default and static methods since Java 8 and private helpers since Java 9. Supports public constants only (no instance state), no constructors, a class can implement many interfaces. Decision rule: use an interface to declare a capability (Comparable, Flyable, Serializable); use an abstract class when you have shared state or protected infrastructure for a family of related types (e.g., AbstractList, HttpServlet).

Interview-ready guide

Interview answer

After Java 8, the line between them moved — interfaces got default, static, and (since Java 9) private methods, so the real differences come down to state and inheritance.

What still only abstract classes can do

Hold instance fields and mutable state
Define constructors that run initialization logic
Use protected and package-private access on members
Mark methods final to lock them down

What only interfaces can do

Be implemented by many types from unrelated hierarchies (implements A, B, C)
Be added to a type retroactively without disrupting its single-inheritance chain
Evolve safely via default methods without breaking existing implementors

The decision framework

Interface = capability that can apply to unrelated types (Comparable, AutoCloseable, Flyable)
Abstract class = family of related types that share state and protected infrastructure (AbstractList, HttpServlet)
The JDK pattern uses both together — List interface + AbstractList skeletal implementation

Sealed interfaces (Java 17+)

Restrict which types implement an interface — sealed interface Event permits UserCreated, UserDeleted
Enables exhaustive switch expressions; narrows the abstract class niche further

Recommendation: Default to interfaces for declaring contracts — they're more flexible and safer to evolve. Reach for an abstract class when multiple concrete types will share state or protected setup logic, and consider combining them (JDK pattern) when you want to offer both a clean contract and a convenience skeleton.

03 · Deep dive