En el desarrollo de software, especialmente en Java, entender la distinción entre interfaces y clases abstractas es fundamental para un diseño robusto y escalable. A menudo surge en entrevistas técnicas, y una respuesta clara y concisa puede marcar la diferencia.

Propósito Fundamental

La principal diferencia radica en su propósito conceptual:

• Interfaces: Definen un contrato de comportamiento. Especifican qué métodos una clase debe implementar, sin preocuparse por el "cómo". Se centran en lo que un objeto "puede hacer" (por ejemplo, Serializable, Comparable). Un tipo puede implementar múltiples interfaces, permitiendo la composición de comportamientos.
• Clases Abstractas: Sirven para definir una relación de herencia y encapsular código común. Permiten compartir estado (variables de instancia) y comportamiento (métodos concretos) entre clases relacionadas. Se centran en lo que un objeto "es" (por ejemplo, una clase Animal abstracta de la que heredan Dog y Cat). En Java, la herencia es simple, por lo que una clase solo puede heredar de una clase abstracta.

Características de Sintaxis y Comportamiento

Interfaces en Java

Antes de Java 8, las interfaces solo podían contener declaraciones de métodos abstractos y constantes (implícitamente public static final).

Con Java 8 y posteriores, las interfaces pueden incluir:

• Métodos por Defecto (default methods): Métodos con implementación que pueden ser heredados por las clases implementadoras. Permiten agregar nuevas funcionalidades a las interfaces sin romper el código existente.
• Métodos Estáticos (static methods): Métodos utilitarios asociados a la interfaz misma, no a una instancia específica.

A partir de Java 9, también se admiten métodos privados.

// Ejemplo de Interfaz
public interface Movable {
    // Constante (implícitamente public static final)
    double DEFAULT_VELOCITY = 50.0;

    // Método abstracto (implícitamente public abstract)
    void move();

    // Método por defecto (Java 8+)
    default void stop() {
        System.out.println("Deteniendo el movimiento...");
    }

    // Método estático (Java 8+)
    static boolean canMove(Object obj) {
        return obj instanceof Movable;
    }
}

Clases Abstractas en Java

Las clases abstractas pueden contener:

• Variables de Instancia: Con cualquier modificador de acceso (public, protected, private, package-private) y no necesariamente inicializadas.
• Métodos Abstractos: Deben ser implementados por las subclases concretas.
• Métodos Concretos: Métodos con implementación completa que pueden ser usados directamente por las subclases.
• Constructores: Aunque no se pueden instanciar directamente, tienen constructores que son llamados por los constructores de las subclases para inicializar el estado heredado.

// Ejemplo de Clase Abstracta
public abstract class Vehicle {
    protected String model;
    protected int year;

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

    // Método abstracto
    public abstract void startEngine();

    // Método concreto
    public void displayInfo() {
        System.out.println("Modelo: " + model + ", Año: " + year);
    }

    // Método estático
    public static boolean isVehicle(Object obj) {
        return obj instanceof Vehicle;
    }
}

Diferencias Clave Resumidas

• Implementación de Métodos: Las interfaces (pre-Java 8) no tenían métodos implementados. Las clases abstractas pueden tener tento métodos abstractos como concretos.
• Variables Miembro: Las interfaces solo pueden tener constantes public static final. Las clases abstractas pueden tener variables miembro con cualquier modificador de acceso.
• Constructores: Las interfaces no pueden tener constructores. Las clases abstractas sí pueden, para la inicialización de sus miembros.
• Herencia Múltiple: Una clase puede implementar múltiples interfaces, pero solo heredar de una clase (abstracta o concreta).
• Estado: Las clases abstractas pueden mantener el estado del objeto a través de variables miembro, mientras que las interfaces no.
• Reutilización de Código: Las clases abstractas facilitan la reutilización de código a través de métodos concretos y el estado compartido. Las interfaces reutilizan código principalmente a través de métodos por defecto y estáticos (desde Java 8+).

Cuándo Elegir Uno u Otro

Prefiera Interfaces cuando:

• Desea definir un contrato de comportamiento que puede ser implementado por clases en jerarquías de herencia no relacionadas.
• Necesita que una clase tenga "capacidades" específicas que pueden componerse (ej. Runnable, Serializable).
• Está diseñando una API pública donde la abstracción del comportamiento es clave.

Prefiera Clases Abstractas cuando:

• Quiere compartir código común (estado y/o comportamiento) entre varias clases estrechamente relacionadas.
• Necesita que las subclases compartan el mismo estado (variables miembro).
• Desea proporcionar una implementación base y permitir que las subclases la extiendan o modifiquen (patrón Template Method).
• La relación "es un" es fuerte entre la clase base y sus subclases.

Preguntas Avanzadas para Entrevistas

1. ¿Las interfaces con métodos por defecto reemplazan a las clases abstractas? No completamente. Las interfaces aún no pueden mantener estado de instancai (variables no estáticas y no finales), que es una función clave de las clases abstractas para compartir información entre objetos relacionados.
2. ¿Cómo decidir entre interfaz y clase abstracta? Considere la relación "es un" (clase abstracta) versus "puede hacer" (interfaz). Favorezca la composición sobre la herencia y prefiera interfaces para definir contratos flexibles.
3. ¿Por qué las interfaces no tienen constructores? Las interfaces definen contratos y no son instanciadas directamente; son implementadas por clases. Las clases abstractas, al ser parte de una jerarquía de herencia, requieren constructores para inicializar las partes heredadas del objeto.

Al explicar estas diferencias, usar ejemplos concretos como los de la API de Java (AbstractList implementando List) puede demostrar una comprensión profunda.