Qual é a diferença entre uma interface e uma classe abstrata?

Question

Accepted Answer

Ambas definem tipos abstratos que não podem ser instanciados diretamente e se destinam a ser implementados/estendidos — mas servem a diferentes propósitos de design. As principais distinções são **herança múltipla**, **estado** e a relação que modelam.

## Interface — um contrato ("can-do" / capacidade)

```java
public interface Drawable {
    void draw();                          // abstract method (implicitly public abstract)

default void render() {                // default method — has a body (Java 8+)
        System.out.println("rendering");
    }
    int MAX = 100;                         // implicitly public static final (constant only)
}

class Circle implements Drawable {
    public void draw() { /* must implement */ }
}
```

Uma interface define um **contrato** de comportamento. Uma classe pode implementar **múltiplas** interfaces — é assim que Java consegue uma forma de herança múltipla. Interfaces (tradicionalmente) não têm estado de instância.

## Classe abstrata — uma base parcial ("is-a" com código compartilhado)

```java
public abstract class Animal {
    protected String name;                 // ✅ can have instance FIELDS (state)

public Animal(String name) {           // ✅ can have a constructor
        this.name = name;
    }
    public abstract void makeSound();      // abstract — subclasses must implement
    public void sleep() {                   // ✅ concrete method with shared logic
        System.out.println(name + " sleeps");
    }
}

class Dog extends Animal {                 // can extend only ONE class
    public Dog(String n) { super(n); }
    public void makeSound() { System.out.println("Woof"); }
}
```

Uma classe abstrata pode conter **estado (campos)**, **construtores** e métodos concretos com implementação compartilhada — mas uma classe pode estender apenas **uma** classe abstrata (herança única).

## Diferenças principais

```text
                    Interface              Abstract class
Multiple inheritance ✓ (implement many)    ✗ (extend only one)
Instance fields/state ✗ (constants only)   ✓ (fields)
Constructor           ✗                    ✓
Method bodies         default/static only  ✓ (concrete methods)
Models                capability ("can-do") "is-a" with shared base
```

## Quando usar qual

```text
Interface → define a capability multiple unrelated classes can have
            (Comparable, Runnable, Serializable); when you need multiple inheritance
Abstract class → share common state + code among closely related subclasses
            (a base class with fields and partial implementation)
```

## Por que isso importa

Escolher entre uma interface e uma classe abstrata é uma decisão fundamental de design em Java.

Interfaces definem **contratos/capacidades** e permitem que uma classe implemente muitos deles (resposta da Java à herança múltipla) — ideal para habilidades transversais.

Classes abstratas fornecem uma **base compartilhada com estado e implementação parcial** para subclasses intimamente relacionadas, mas limitam você a herança única.

Compreender os trade-offs (implementação múltipla vs estado compartilhado/construtores, capacidade vs relação is-a) orienta um bom design de API e hierarquia de classes.

Com métodos padrão do Java 8+ desfocando a linha, saber quando cada um se encaixa — e as restrições principais (uma classe abstrata mas muitas interfaces, estado apenas em classes abstratas) — é essencial para projetar código flexível e bem estruturado.