What is the difference between abstract class and interface?

Question

Accepted Answer

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

Analogy: An **abstract class** is a partially-built house — some rooms are done (concrete methods), some are blueprints (abstract methods). An **interface** is a building code — it lists what capabilities a house MUST have, but doesn't build anything.

**Abstract class:**
- Declared with `abstract` keyword.
- Can have both **concrete** and **abstract** methods.
- Can have **constructors**, **instance variables**, **static methods**.
- A class can extend **only ONE** abstract class.
- Cannot be instantiated directly.

```java
abstract class Vehicle {
    protected String brand;
    protected int year;

// Constructor
    public Vehicle(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

// Concrete method — shared behavior
    public void start() {
        System.out.println(brand + " starting...");
    }

// Abstract method — subclasses must implement
    public abstract double calculateFuelEfficiency();

// Static method
    public static boolean isNewerThan(Vehicle a, Vehicle b) {
        return a.year > b.year;
    }
}

class Car extends Vehicle {
    private double mpg;

public Car(String brand, int year, double mpg) {
        super(brand, year);
        this.mpg = mpg;
    }

@Override
    public double calculateFuelEfficiency() {
        return mpg;
    }
}

Vehicle v = new Car("Toyota", 2023, 32.5);
v.start(); // Toyota starting...
System.out.println(v.calculateFuelEfficiency()); // 32.5
```

**Interface:**
- Declared with `interface` keyword.
- Methods are `public abstract` by default.
- Variables are `public static final` (constants) by default.
- No constructors allowed.
- A class can implement **MULTIPLE** interfaces.
- Java 8+: `default` and `static` methods allowed.

```java
interface Drawable {
    void draw(); // public abstract by default
}

interface Resizable {
    void resize(double factor);

// Default method (Java 8+)
    default void doubleSize() {
        resize(2.0);
    }
}

// Multiple interface implementation
class Circle implements Drawable, Resizable {
    private double radius;

public Circle(double radius) {
        this.radius = radius;
    }

@Override
    public void draw() {
        System.out.println("Drawing circle with radius " + radius);
    }

@Override
    public void resize(double factor) {
        radius *= factor;
    }
}

Circle c = new Circle(5);
c.draw();       // Drawing circle with radius 5
c.doubleSize(); // Uses default method — radius becomes 10
c.draw();       // Drawing circle with radius 10
```

**Key differences:**
- **Abstract class** — single inheritance. **Interface** — multiple inheritance.
- **Abstract class** — can have constructors. **Interface** — cannot.
- **Abstract class** — instance variables allowed. **Interface** — only constants.
- **Abstract class** — any access modifier. **Interface** — public by default.
- **Abstract class** — "is-a" relationship. **Interface** — "can-do" capability.

**When to use which:**
- Use **abstract class** when classes share common state and behavior.
- Use **interface** when defining capabilities unrelated classes can share.
- Use **interface** for loose coupling and polymorphism.
- Use **abstract class** when you need constructors or protected fields.

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