An interface declares a contract — a set of methods a type must provide — with no (or minimal) implementation. An abstract class is a partially implemented class that can hold shared state and concrete methods but cannot be instantiated. The key distinction: a class can implement many interfaces but inherit from only one class.
| Interface | Abstract class | |
|---|---|---|
| Instantiable | No | No |
| Multiple inheritance | Yes (implement many) | No (single base) |
| Fields / state | No (constants only*) | Yes |
| Method bodies | Default methods only* | Yes, fully |
| Models | A capability ("can do") | An is-a with shared code |
*Modern Java allows default methods and constants; the spirit still holds.
interface Drawable { // a capability
void draw();
}
abstract class Shape { // shared identity + state
protected String color;
Shape(String color) { this.color = color; }
abstract double area(); // subclasses must define
String describe() { // shared concrete behavior
return color + " shape, area=" + area();
}
}
class Circle extends Shape implements Drawable {
private double r;
Circle(String c, double r) { super(c); this.r = r; }
double area() { return Math.PI * r * r; }
public void draw() { /* render */ }
}
Circle is a Shape (one base, shared code) and can be Drawable (a capability mixed in).
Choosing wrong locks in your design: an abstract base forces a single inheritance line, while an interface keeps types free to combine capabilities.
Interfaces are the preferred default for decoupling — depending on a contract rather than a concrete hierarchy keeps code testable and extensible.