¿Cuál es la diferencia entre una interfaz y una clase abstracta?

Question

Accepted Answer

Ambas definen tipos abstractos que no pueden instanciarse directamente y están pensadas para ser implementadas/extendidas — pero sirven diferentes propósitos de diseño. Las diferencias clave son **herencia múltiple**, **estado** y la relación que modelan.

## Interfaz — un contrato ("puede hacer" / capacidad)

```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 */ }
}
```

Una interfaz define un **contrato** de comportamiento. Una clase puede implementar **múltiples** interfaces — esta es la forma en que Java logra una forma de herencia múltiple. Las interfaces (tradicionalmente) no tienen estado de instancia.

## Clase abstracta — una base parcial ("es un" con código compartido)

```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"); }
}
```

Una clase abstracta puede contener **estado (campos)**, **constructores** y métodos concretos con implementación compartida — pero una clase solo puede extender **una** clase abstracta (herencia simple).

## Diferencias clave

```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
```

## Cuándo usar cuál

```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 qué es importante

Elegir entre una interfaz y una clase abstracta es una decisión fundamental de diseño en Java.

Las interfaces definen **contratos/capacidades** y permiten que una clase implemente muchas de ellas (la respuesta de Java a la herencia múltiple) — ideal para capacidades transversales.

Las clases abstractas proporcionan una **base compartida con estado e implementación parcial** para subclases estrechamente relacionadas, pero te limitan a herencia simple.

Entender los compromisos (implementación múltiple vs estado/constructores compartidos, capacidad vs relación "es un") guía el buen diseño de API y jerarquía de clases.

Con los métodos default de Java 8+ difuminando la línea, saber cuándo se ajusta cada uno — y las restricciones básicas (una clase abstracta pero muchas interfaces, estado solo en clases abstractas) — es esencial para diseñar código flexible y bien estructurado.