What is the difference between abstract class and interface?

Question

Accepted Answer

**Abstract class** — partial implementation, single inheritance. **Interface** — pure contract, multiple inheritance.

Analogy: **Abstract class** = partially-built house (some rooms done, some blueprints). **Interface** = building code (lists requirements, builds nothing).

**Abstract class:**
- `abstract` keyword.
- Concrete + abstract methods.
- Constructors, instance variables, static methods.
- Single inheritance.

```java
abstract class Shape {
    protected String color;

public Shape(String color) {
        this.color = color;
    }

public void display() {
        System.out.println("Color: " + color);
    }

public abstract double area();
}

class Circle extends Shape {
    private double radius;

public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }

@Override
    public double area() {
        return Math.PI * radius * radius;
    }
}
```

**Interface:**
- `interface` keyword.
- Methods are `public abstract` by default.
- No constructors.
- Multiple implementation.
- Java 8+: `default` and `static` methods.

```java
interface Drawable {
    void draw();

default void fill() {
        System.out.println("Default fill");
    }
}

interface Resizable {
    void resize(double factor);
}

class Rectangle implements Drawable, Resizable {
    @Override
    public void draw() { System.out.println("Drawing rectangle"); }

@Override
    public void resize(double factor) { System.out.println("Resizing by " + factor); }
}
```

**Key differences:**
- **Abstract** — single inheritance. **Interface** — multiple.
- **Abstract** — constructors allowed. **Interface** — not.
- **Abstract** — instance variables. **Interface** — only constants.
- **Abstract** — "is-a". **Interface** — "can-do".

**When to use:**
- **Abstract class** — shared state/behavior in hierarchy.
- **Interface** — capabilities unrelated classes can share.
- **Interface** — loose coupling, polymorphism.

Java: What is the difference between abstract class and interface?