Definición y propósito de clases abstractas

En el mundo de la programación orientada a objetos, las clases abstractas permiten crear diseños mucho más flexibles. Se trata de un tipo especial de clase que no puede ser instanciada directamente, sino que está diseñada para ser extendida por otras clases.

Una clase abstracta se define en Java utilizando la palabra clave abstract antes de la declaración de la clase. Esta característica indica al compilador que dicha clase existe principalmente como un molde conceptual para otras clases, estableciendo una estructura común que sus subclases deben seguir.

public abstract class Figura {
    // Atributos y métodos
}

El propósito principal de las clases abstractas es proporcionar una base común para un grupo de subclases relacionadas. Se utilizan cuando se quiere definir una abstracción que capture las características y comportamientos compartidos, pero que por sí misma no representa una entidad completa que deba existir de forma independiente.

Las clases abstractas permiten implementar el principio de diseño por contrato, donde se establece una especie de acuerdo sobre qué métodos deben implementar las subclases y cuáles ya están implementados en la clase base. Esto facilita la creación de jerarquías de clases estructuradas.

public abstract class Empleado {
    private String nombre;
    private String id;
    
    // Constructor
    public Empleado(String nombre, String id) {
        this.nombre = nombre;
        this.id = id;
    }
    
    // Métodos concretos (implementados)
    public String getNombre() {
        return nombre;
    }
    
    public String getId() {
        return id;
    }
    
    // Método abstracto (sin implementación)
    public abstract double calcularSalario();
}

En este ejemplo, la clase Empleado define atributos comunes como nombre e id, junto con sus correspondientes métodos de acceso. Sin embargo, el cálculo del salario varía según el tipo de empleado, por lo que se declara como un método abstracto que las subclases deberán implementar obligatoriamente.

Las clases abstractas se diferencian de las clases concretas en que:

• No se pueden instanciar directamente con el operador new
• Pueden contener métodos abstractos (sin implementación)
• Obligan a las subclases a implementar los métodos abstractos (a menos que la subclase también sea abstracta)

Cuando se intenta crear una instancia directa de una clase abstracta, se produce un error de compilación:

// Esto generará un error de compilación
Empleado emp = new Empleado("Juan", "E001");

Sin embargo, se puede utilizar una referencia de tipo abstracto para apuntar a objetos de sus subclases concretas, lo que permite aprovechar el polimorfismo:

// Esto es válido
Empleado emp = new EmpleadoTiempoCompleto("Juan", "E001", 3000);

Las clases abstractas son útiles en los siguientes escenarios:

• Cuando se quiere compartir código entre varias clases estrechamente relacionadas
• Cuando las clases que comparten la interfaz también necesitan compartir implementaciones
• Cuando se necesita definir métodos no públicos o mantener campos que no son constantes
• Cuando se busca establecer un esqueleto algorítmico común, pero permitiendo variaciones en pasos específicos

Un patrón de diseño común que utiliza clases abstractas es el Template Method, donde se define la estructura de un algoritmo en la clase abstracta, pero se permite que ciertos pasos sean implementados por las subclases:

public abstract class ProcesadorDocumento {
    // Template method
    public final void procesarDocumento() {
        abrir();
        contenido();
        comprobarOrtografia();
        guardar();
    }
    
    // Métodos comunes con implementación por defecto
    protected void abrir() {
        System.out.println("Documento abierto");
    }
    
    protected void guardar() {
        System.out.println("Documento guardado");
    }
    
    // Métodos que deben ser implementados por las subclases
    protected abstract void contenido();
    protected abstract void comprobarOrtografia();
}

En este ejemplo, el método procesarDocumento() define el esqueleto del algoritmo, mientras que los métodos contenido() y comprobarOrtografia() deben ser implementados por cada tipo específico de procesador de documentos.

Las clases abstractas se utilizan a menudo en el desarrollo de frameworks y bibliotecas, donde proporcionan puntos de extensión bien definidos para los desarrolladores que utilizan esas herramientas. Por ejemplo, en Java, clases como AbstractList, AbstractMap y AbstractCollection son clases abstractas que facilitan la implementación de nuevos tipos de colecciones.

Métodos abstractos vs. métodos concretos

Dentro de una clase abstracta en Java, se pueden definir dos tipos fundamentales de métodos: métodos abstractos y métodos concretos.

Los métodos abstractos son aquellos que se declaran sin proporcionar una implementación. Se definen utilizando la palabra clave abstract y terminan con punto y coma en lugar de un bloque de código. Estos métodos representan comportamientos que deben ser definidos por las subclases.

public abstract class Instrumento {
    // Método abstracto - sin implementación
    public abstract void tocar();
}

Por otro lado, los métodos concretos son aquellos que incluyen una implementación completa dentro de la clase abstracta. Estos métodos funcionan exactamente igual que los métodos en clases normales, proporcionando funcionalidad que será heredada por todas las subclases.

public abstract class Instrumento {
    // Método abstracto
    public abstract void tocar();
    
    // Método concreto con implementación
    public void afinar() {
        System.out.println("Afinando el instrumento...");
    }
}

Características de los métodos abstractos

Los métodos abstractos se caracterizan por:

• Llevar la palabra clave abstract en su declaración
• No contener implementación (cuerpo del método)
• Terminar con punto y coma (;) en lugar de llaves ({})
• Obligar a las subclases no abstractas a proporcionar una implementación
• No poder ser declarados como private (sería contradictorio, ya que no podrían ser sobrescritos)
• No poder ser final (también contradictorio, ya que deben ser sobrescritos)
• No poder ser static (los métodos estáticos no pueden ser sobrescritos)

public abstract class FiguraGeometrica {
    protected String color;
    
    // Constructor
    public FiguraGeometrica(String color) {
        this.color = color;
    }
    
    // Métodos abstractos
    public abstract double calcularArea();
    public abstract double calcularPerimetro();
}

En este ejemplo, cualquier clase que extienda FiguraGeometrica debe implementar los métodos calcularArea() y calcularPerimetro(), a menos que también sea declarada como abstracta.

Características de los métodos concretos

Los métodos concretos en clases abstractas:

• Contienen una implementación completa
• Pueden ser sobrescritos por las subclases si no son final
• Proporcionan funcionalidad común que todas las subclases heredan
• Pueden acceder a atributos y otros métodos de la clase abstracta
• Pueden tener cualquier modificador de acceso (public, protected, private)

public abstract class Animal {
    protected String nombre;
    
    // Constructor
    public Animal(String nombre) {
        this.nombre = nombre;
    }
    
    // Método abstracto
    public abstract void hacerSonido();
    
    // Métodos concretos
    public void comer() {
        System.out.println(nombre + " está comiendo");
    }
    
    public void dormir() {
        System.out.println(nombre + " está durmiendo");
    }
    
    public String getNombre() {
        return nombre;
    }
}

Interacción entre métodos abstractos y concretos

Una de las ventajas más importantes de las clases abstractas es la capacidad de los métodos concretos para utilizar métodos abstractos, incluso antes de que estos últimos sean implementados. Esto se conoce como el patrón de diseño Template Method.

public abstract class Bebida {
    // Método concreto que utiliza métodos abstractos
    public final void preparar() {
        hervirAgua();
        agregarIngredientes();
        verter();
        if (clienteQuiereCondimentos()) {
            agregarCondimentos();
        }
    }
    
    // Métodos concretos con implementación por defecto
    protected void hervirAgua() {
        System.out.println("Hirviendo agua");
    }
    
    protected void verter() {
        System.out.println("Vertiendo en la taza");
    }
    
    // Métodos abstractos que deben ser implementados por las subclases
    protected abstract void agregarIngredientes();
    protected abstract void agregarCondimentos();
    
    // Método concreto que puede ser sobrescrito (hook method)
    protected boolean clienteQuiereCondimentos() {
        return true;
    }
}

En este ejemplo, el método concreto preparar() define el algoritmo general para preparar una bebida, pero delega pasos específicos a métodos abstractos que serán implementados por las subclases. Esto permite mantener la estructura del algoritmo consistente mientras se personalizan ciertos pasos.

Implementación en subclases

Cuando una clase extiende una clase abstracta, debe proporcionar implementaciones para todos los métodos abstractos, a menos que también sea declarada como abstracta.

public class Cafe extends Bebida {
    @Override
    protected void agregarIngredientes() {
        System.out.println("Agregando café molido");
    }
    
    @Override
    protected void agregarCondimentos() {
        System.out.println("Agregando azúcar y leche");
    }
    
    @Override
    protected boolean clienteQuiereCondimentos() {
        // Lógica para preguntar al cliente
        return false; // Por ejemplo, este cliente no quiere condimentos
    }
}

Sobrescritura de métodos concretos

Las subclases pueden optar por sobrescribir los métodos concretos heredados de la clase abstracta para proporcionar implementaciones específicas:

public class Gato extends Animal {
    public Gato(String nombre) {
        super(nombre);
    }
    
    @Override
    public void hacerSonido() {
        System.out.println("Miau miau");
    }
    
    // Sobrescribiendo un método concreto
    @Override
    public void dormir() {
        System.out.println(getNombre() + " está durmiendo acurrucado");
    }
}

Comparativa práctica

Para ilustrar mejor las diferencias y el uso combinado de métodos abstractos y concretos, veamos un ejemplo más completo:

public abstract class Vehiculo {
    private String marca;
    private String modelo;
    protected int velocidad;
    
    // Constructor
    public Vehiculo(String marca, String modelo) {
        this.marca = marca;
        this.modelo = modelo;
        this.velocidad = 0;
    }
    
    // Métodos concretos
    public void frenar(int decremento) {
        if (velocidad - decremento >= 0) {
            velocidad -= decremento;
        } else {
            velocidad = 0;
        }
        System.out.println("Frenando. Velocidad actual: " + velocidad + " km/h");
    }
    
    public String getInfo() {
        return marca + " " + modelo;
    }
    
    // Métodos abstractos
    public abstract void acelerar(int incremento);
    public abstract String getTipo();
}

// Implementación concreta
public class Coche extends Vehiculo {
    private int numeroPuertas;
    
    public Coche(String marca, String modelo, int numeroPuertas) {
        super(marca, modelo);
        this.numeroPuertas = numeroPuertas;
    }
    
    @Override
    public void acelerar(int incremento) {
        velocidad += incremento;
        System.out.println("Acelerando coche. Velocidad actual: " + velocidad + " km/h");
    }
    
    @Override
    public String getTipo() {
        return "Coche de " + numeroPuertas + " puertas";
    }
}

En este ejemplo, la clase Vehiculo proporciona implementaciones concretas para operaciones comunes como frenar() y getInfo(), mientras que deja los comportamientos específicos como acelerar() y getTipo() como métodos abstractos que cada tipo de vehículo debe implementar según sus características particulares.

Implementación y extensión de clases abstractas

Cuando se trabaja con clases abstractas, se establece un contrato de implementación que las subclases deben cumplir para poder funcionar correctamente.

Para extender una clase abstracta, se utiliza la palabra clave extends, similar a la herencia regular en Java. Sin embargo, la diferencia crucial radica en la obligación de implementar todos los métodos abstractos declarados en la superclase, a menos que la subclase también se declare como abstracta.

public class Rectangulo extends FiguraGeometrica {
    private double base;
    private double altura;
    
    public Rectangulo(String color, double base, double altura) {
        super(color);
        this.base = base;
        this.altura = altura;
    }
    
    @Override
    public double calcularArea() {
        return base * altura;
    }
    
    @Override
    public double calcularPerimetro() {
        return 2 * (base + altura);
    }
}

En este ejemplo, la clase Rectangulo extiende la clase abstracta FiguraGeometrica e implementa los métodos abstractos calcularArea() y calcularPerimetro(). Si alguno de estos métodos no se implementara, el compilador generaría un error.

Implementación de múltiples métodos abstractos

Cuando una clase abstracta contiene varios métodos abstractos, la subclase debe proporcionar implementaciones para todos ellos. Este requisito garantiza que el contrato completo definido por la clase abstracta se cumpla en las implementaciones concretas.

public abstract class Reproductor {
    protected String marca;
    
    public Reproductor(String marca) {
        this.marca = marca;
    }
    
    public abstract void reproducir();
    public abstract void pausar();
    public abstract void detener();
    public abstract void avanzar();
    public abstract void retroceder();
}

public class ReproductorMP3 extends Reproductor {
    private String modelo;
    
    public ReproductorMP3(String marca, String modelo) {
        super(marca);
        this.modelo = modelo;
    }
    
    @Override
    public void reproducir() {
        System.out.println("Reproduciendo archivo MP3");
    }
    
    @Override
    public void pausar() {
        System.out.println("Pausando reproducción");
    }
    
    @Override
    public void detener() {
        System.out.println("Deteniendo reproducción");
    }
    
    @Override
    public void avanzar() {
        System.out.println("Avanzando a la siguiente pista");
    }
    
    @Override
    public void retroceder() {
        System.out.println("Retrocediendo a la pista anterior");
    }
}

Cadenas de herencia con clases abstractas

En Java, se pueden crear cadenas de herencia que involucren múltiples clases abstractas. En estos casos, cada clase en la cadena puede implementar algunos métodos abstractos de su superclase y añadir nuevos métodos abstractos para las subclases siguientes.

public abstract class Empleado {
    protected String nombre;
    
    public Empleado(String nombre) {
        this.nombre = nombre;
    }
    
    public abstract double calcularSalario();
}

public abstract class EmpleadoTiempoParcial extends Empleado {
    protected int horasTrabajadas;
    
    public EmpleadoTiempoParcial(String nombre, int horasTrabajadas) {
        super(nombre);
        this.horasTrabajadas = horasTrabajadas;
    }
    
    public abstract double getTarifaPorHora();
    
    @Override
    public double calcularSalario() {
        return horasTrabajadas * getTarifaPorHora();
    }
}

public class Becario extends EmpleadoTiempoParcial {
    public Becario(String nombre, int horasTrabajadas) {
        super(nombre, horasTrabajadas);
    }
    
    @Override
    public double getTarifaPorHora() {
        return 8.50; // Tarifa fija para becarios
    }
}

En este ejemplo, EmpleadoTiempoParcial implementa el método abstracto calcularSalario() de Empleado, pero introduce un nuevo método abstracto getTarifaPorHora(). La clase concreta Becario debe implementar este último método para completar la cadena de implementación.

Constructores en clases abstractas

Aunque las clases abstractas no pueden ser instanciadas directamente, sí contienen constructores que son invocados cuando se crean instancias de sus subclases. Estos constructores se utilizan para inicializar los atributos definidos en la clase abstracta.

public abstract class Producto {
    private String codigo;
    private String nombre;
    private double precio;
    
    public Producto(String codigo, String nombre, double precio) {
        this.codigo = codigo;
        this.nombre = nombre;
        this.precio = precio;
    }
    
    // Getters
    public String getCodigo() {
        return codigo;
    }
    
    public String getNombre() {
        return nombre;
    }
    
    public double getPrecio() {
        return precio;
    }
    
    // Método abstracto
    public abstract double calcularImpuesto();
}

public class ProductoAlimenticio extends Producto {
    private boolean perecedero;
    
    public ProductoAlimenticio(String codigo, String nombre, double precio, boolean perecedero) {
        super(codigo, nombre, precio); // Llamada al constructor de la clase abstracta
        this.perecedero = perecedero;
    }
    
    @Override
    public double calcularImpuesto() {
        // Los productos alimenticios tienen un impuesto reducido del 4%
        return getPrecio() * 0.04;
    }
}

Implementación de clases abstractas anidadas

Java permite definir clases abstractas anidadas dentro de otras clases. Estas clases anidadas pueden ser extendidas e implementadas como cualquier otra clase abstracta.

public class SistemaAudio {
    // Clase abstracta anidada
    public abstract static class Dispositivo {
        protected String nombre;
        
        public Dispositivo(String nombre) {
            this.nombre = nombre;
        }
        
        public abstract void encender();
        public abstract void apagar();
    }
    
    // Implementación de la clase abstracta anidada
    public static class Altavoz extends Dispositivo {
        private int volumen;
        
        public Altavoz(String nombre) {
            super(nombre);
            this.volumen = 0;
        }
        
        @Override
        public void encender() {
            System.out.println("Altavoz " + nombre + " encendido");
        }
        
        @Override
        public void apagar() {
            System.out.println("Altavoz " + nombre + " apagado");
        }
        
        public void ajustarVolumen(int nivel) {
            this.volumen = nivel;
            System.out.println("Volumen ajustado a " + nivel);
        }
    }
}

Uso del patrón Factory con clases abstractas

Las clases abstractas se utilizan a menudo en el patrón Factory, donde una clase fábrica se encarga de crear instancias de diferentes subclases de una clase abstracta según los parámetros proporcionados.

public abstract class Conexion {
    protected String url;
    
    public Conexion(String url) {
        this.url = url;
    }
    
    public abstract void abrir();
    public abstract void cerrar();
    public abstract void ejecutarConsulta(String consulta);
}

public class ConexionMySQL extends Conexion {
    public ConexionMySQL(String url) {
        super(url);
    }
    
    @Override
    public void abrir() {
        System.out.println("Abriendo conexión MySQL a " + url);
    }
    
    @Override
    public void cerrar() {
        System.out.println("Cerrando conexión MySQL");
    }
    
    @Override
    public void ejecutarConsulta(String consulta) {
        System.out.println("Ejecutando en MySQL: " + consulta);
    }
}

public class ConexionPostgreSQL extends Conexion {
    public ConexionPostgreSQL(String url) {
        super(url);
    }
    
    @Override
    public void abrir() {
        System.out.println("Abriendo conexión PostgreSQL a " + url);
    }
    
    @Override
    public void cerrar() {
        System.out.println("Cerrando conexión PostgreSQL");
    }
    
    @Override
    public void ejecutarConsulta(String consulta) {
        System.out.println("Ejecutando en PostgreSQL: " + consulta);
    }
}

// Fábrica de conexiones
public class FabricaConexiones {
    public static Conexion crearConexion(String tipo, String url) {
        if (tipo.equalsIgnoreCase("mysql")) {
            return new ConexionMySQL(url);
        } else if (tipo.equalsIgnoreCase("postgresql")) {
            return new ConexionPostgreSQL(url);
        } else {
            throw new IllegalArgumentException("Tipo de conexión no soportado: " + tipo);
        }
    }
}

Extensión de clases abstractas con genéricos

Las clases abstractas en Java pueden utilizar genéricos para crear implementaciones más flexibles y reutilizables:

public abstract class Procesador<T> {
    protected List<T> elementos;
    
    public Procesador() {
        this.elementos = new ArrayList<>();
    }
    
    public void agregarElemento(T elemento) {
        elementos.add(elemento);
    }
    
    public List<T> getElementos() {
        return new ArrayList<>(elementos);
    }
    
    public abstract void procesar();
    public abstract T obtenerResultado();
}

public class ProcesadorTexto extends Procesador<String> {
    private StringBuilder resultado;
    
    public ProcesadorTexto() {
        super();
        this.resultado = new StringBuilder();
    }
    
    @Override
    public void procesar() {
        resultado.setLength(0); // Limpiar resultado anterior
        for (String texto : elementos) {
            resultado.append(texto.toUpperCase()).append(" ");
        }
    }
    
    @Override
    public String obtenerResultado() {
        return resultado.toString().trim();
    }
}

Buenas prácticas en la implementación de clases abstractas

Al implementar y extender clases abstractas, se recomienda seguir estas buenas prácticas:

• Documentar claramente el propósito de cada método abstracto y qué se espera de su implementación
• Proporcionar implementaciones por defecto cuando sea posible para reducir la carga en las subclases
• Utilizar modificadores de acceso adecuados para proteger la integridad de la clase abstracta
• Evitar dependencias circulares entre la clase abstracta y sus implementaciones
• Considerar el uso de métodos finales para algoritmos críticos que no deban ser modificados por las subclases

public abstract class Validador {
    // Método template final que no puede ser sobrescrito
    public final boolean validar(String entrada) {
        if (entrada == null || entrada.isEmpty()) {
            return false;
        }
        
        // Preprocesamiento común
        String datosProcesados = preprocesar(entrada);
        
        // Validación específica implementada por subclases
        return validarEspecifico(datosProcesados);
    }
    
    // Método con implementación por defecto que puede ser sobrescrito
    protected String preprocesar(String entrada) {
        return entrada.trim();
    }
    
    // Método abstracto que debe ser implementado
    protected abstract boolean validarEspecifico(String entrada);
}

Cuándo usar clases abstractas vs. interfaces

La elección entre clases abstractas e interfaces representa una de las decisiones de diseño más importantes en la programación orientada a objetos en Java. Ambos mecanismos permiten definir contratos que las clases deben implementar, pero presentan diferencias fundamentales que determinan cuándo es más apropiado utilizar uno u otro.

Diferencias clave entre clases abstractas e interfaces

• Estado y comportamiento: Las clases abstractas pueden contener atributos con estado y métodos con implementación, mientras que las interfaces tradicionalmente solo definían métodos (aunque desde Java 8 pueden incluir métodos default y static).

// Clase abstracta con estado
public abstract class Vehiculo {
    protected int velocidad;  // Atributo con estado
    
    public void frenar() {    // Método con implementación
        velocidad = 0;
        System.out.println("Vehículo detenido");
    }
    
    public abstract void acelerar(int incremento);
}

// Interfaz
public interface Conducible {
    void girarIzquierda();
    void girarDerecha();
    
    // Método default (desde Java 8)
    default void tocarBocina() {
        System.out.println("¡Beep!");
    }
}

• Herencia: Java solo permite herencia simple de clases (incluidas las abstractas), mientras que una clase puede implementar múltiples interfaces.

// Una clase solo puede extender una clase abstracta
public class Coche extends Vehiculo implements Conducible, Rastreable {
    // Implementación
}

• Constructores: Las clases abstractas pueden tener constructores que inicialicen el estado, mientras que las interfaces no pueden tener constructores.

public abstract class Animal {
    protected String nombre;
    
    // Constructor en clase abstracta
    public Animal(String nombre) {
        this.nombre = nombre;
    }
}

• Modificadores de acceso: En las clases abstractas, los métodos pueden tener cualquier modificador de acceso (public, protected, private), mientras que en las interfaces todos los métodos son implícitamente public.

Escenarios para usar clases abstractas

Se recomienda utilizar clases abstractas cuando:

• Se necesita compartir código entre clases estrechamente relacionadas que forman parte de la misma jerarquía.

public abstract class BaseDeDatos {
    protected Connection conexion;
    
    // Código compartido para establecer conexión
    public void conectar(String url, String usuario, String password) {
        // Implementación común para establecer conexión
    }
    
    // Métodos específicos que varían según el tipo de BD
    public abstract void ejecutarConsulta(String sql);
}

• Se requiere mantener un estado común entre las implementaciones.

public abstract class Empleado {
    protected String nombre;
    protected double salarioBase;
    
    public Empleado(String nombre, double salarioBase) {
        this.nombre = nombre;
        this.salarioBase = salarioBase;
    }
    
    // El cálculo específico varía según el tipo de empleado
    public abstract double calcularSalario();
}

• Se quiere proporcionar una implementación parcial con métodos que las subclases pueden utilizar o sobrescribir.

public abstract class Notificador {
    // Implementación común
    public void formatearMensaje(String mensaje) {
        // Lógica de formateo
    }
    
    // Método template con implementación parcial
    public final void enviarNotificacion(String destinatario, String mensaje) {
        String mensajeFormateado = formatearMensaje(mensaje);
        validarDestinatario(destinatario);
        enviar(destinatario, mensajeFormateado);
        registrarEnvio(destinatario, mensaje);
    }
    
    // Método que varía según el canal de notificación
    protected abstract void enviar(String destinatario, String mensaje);
    
    // Implementación común que puede ser sobrescrita
    protected void registrarEnvio(String destinatario, String mensaje) {
        System.out.println("Notificación enviada a: " + destinatario);
    }
}

• Se necesitan métodos no públicos que no formen parte del contrato externo pero sean útiles para la implementación interna.

public abstract class Procesador {
    // Método protegido - no forma parte del contrato público
    protected void validarEntrada(String entrada) {
        if (entrada == null || entrada.isEmpty()) {
            throw new IllegalArgumentException("Entrada inválida");
        }
    }
    
    public abstract void procesar(String entrada);
}

• Se quiere evitar que las clases implementadoras sobrescriban ciertos métodos utilizando la palabra clave final.

public abstract class Autenticador {
    // Algoritmo crítico que no debe ser modificado
    public final boolean autenticar(String usuario, String password) {
        // Lógica de autenticación segura
        return validarCredenciales(usuario, password);
    }
    
    // Método que puede variar según el mecanismo de autenticación
    protected abstract boolean validarCredenciales(String usuario, String password);
}

Escenarios para usar interfaces

Las interfaces son más adecuadas cuando:

• Se necesita que una clase pertenezca a múltiples tipos o categorías de comportamiento.

public interface Nadador {
    void nadar();
}

public interface Volador {
    void volar();
}

// Una clase puede implementar múltiples interfaces
public class Pato implements Nadador, Volador {
    @Override
    public void nadar() {
        System.out.println("El pato nada en el agua");
    }
    
    @Override
    public void volar() {
        System.out.println("El pato vuela por el aire");
    }
}

• Se quiere definir un contrato sin imponer una relación de herencia específica.

public interface Pagable {
    double calcularMonto();
    void procesar();
}

// Diferentes clases no relacionadas pueden implementar la misma interfaz
public class Factura implements Pagable { /* implementación */ }
public class Salario implements Pagable { /* implementación */ }
public class Prestamo implements Pagable { /* implementación */ }

• Se busca aprovechar la herencia múltiple de tipo sin las complicaciones de la herencia múltiple de implementación.

public class SmartDevice implements Telefono, Camara, Navegador {
    // Implementa comportamientos de múltiples dispositivos
}

• El diseño puede cambiar con frecuencia, ya que agregar métodos a interfaces (con implementaciones default) es menos disruptivo que modificar clases abstractas.

public interface Reproductor {
    void reproducir();
    void pausar();
    
    // Se puede agregar un nuevo método con implementación default
    // sin romper las implementaciones existentes
    default void detener() {
        System.out.println("Reproducción detenida");
    }
}

• Se está diseñando para ser implementado por clases de diferentes jerarquías que no comparten una estructura común.

public interface Exportable {
    byte[] exportar();
    String obtenerFormato();
}

// Clases de diferentes jerarquías
public class Documento implements Exportable { /* implementación */ }
public class BaseDeDatos implements Exportable { /* implementación */ }
public class Grafico implements Exportable { /* implementación */ }

Patrones de diseño y casos de uso

Ciertos patrones de diseño favorecen el uso de uno u otro mecanismo:

• El patrón Template Method se implementa bien con clases abstractas, ya que permite definir el esqueleto de un algoritmo en la clase base y delegar pasos específicos a las subclases.

public abstract class OrdenProcesador {
    // Template method
    public final void procesarOrden() {
        validarOrden();
        calcularImpuestos();
        aplicarDescuentos();
        enviar();
        notificarCliente();
    }
    
    // Métodos que varían según el tipo de orden
    protected abstract void calcularImpuestos();
    protected abstract void aplicarDescuentos();
    
    // Implementaciones comunes
    protected void validarOrden() { /* implementación */ }
    protected void enviar() { /* implementación */ }
    protected void notificarCliente() { /* implementación */ }
}

• El patrón Strategy se implementa mejor con interfaces, ya que permite intercambiar algoritmos sin cambiar la estructura de herencia.

public interface EstrategiaOrdenamiento {
    <T extends Comparable<T>> void ordenar(List<T> lista);
}

public class QuickSort implements EstrategiaOrdenamiento {
    @Override
    public <T extends Comparable<T>> void ordenar(List<T> lista) {
        // Implementación QuickSort
    }
}

public class MergeSort implements EstrategiaOrdenamiento {
    @Override
    public <T extends Comparable<T>> void ordenar(List<T> lista) {
        // Implementación MergeSort
    }
}

Enfoque híbrido: combinando clases abstractas e interfaces

En muchos casos, el mejor diseño combina ambos mecanismos:

// Interfaz que define el contrato público
public interface Mensajero {
    void enviarMensaje(String destinatario, String contenido);
    boolean verificarEntrega(String idMensaje);
}

// Clase abstracta que proporciona implementación parcial
public abstract class MensajeroBase implements Mensajero {
    protected final String remitente;
    protected final Logger logger;
    
    public MensajeroBase(String remitente) {
        this.remitente = remitente;
        this.logger = Logger.getLogger(this.getClass().getName());
    }
    
    // Implementación común del contrato
    @Override
    public boolean verificarEntrega(String idMensaje) {
        logger.info("Verificando entrega del mensaje: " + idMensaje);
        return consultarEstadoEntrega(idMensaje);
    }
    
    // Método protegido para las subclases
    protected abstract boolean consultarEstadoEntrega(String idMensaje);
}

// Implementación concreta
public class MensajeroEmail extends MensajeroBase {
    private final String servidorSMTP;
    
    public MensajeroEmail(String remitente, String servidorSMTP) {
        super(remitente);
        this.servidorSMTP = servidorSMTP;
    }
    
    @Override
    public void enviarMensaje(String destinatario, String contenido) {
        // Implementación específica para email
    }
    
    @Override
    protected boolean consultarEstadoEntrega(String idMensaje) {
        // Implementación específica para verificar emails
        return true;
    }
}

Consideraciones de evolución y mantenimiento

Al tomar la decisión, es importante considerar cómo evolucionará el código:

• Las interfaces son más fáciles de evolucionar desde Java 8 gracias a los métodos default, que permiten agregar funcionalidad sin romper implementaciones existentes.
• Las clases abstractas ofrecen mayor flexibilidad para refactorizar implementaciones internas sin afectar a las subclases, siempre que se mantenga la API pública.
• Si se prevé que el modelo de dominio cambiará bastante, las interfaces pueden proporcionar mayor flexibilidad.
• Si se necesita mantener un comportamiento consistente a lo largo del tiempo, las clases abstractas pueden ofrecer mejor encapsulación y control.

Recomendaciones prácticas

Para tomar la decisión correcta, se pueden seguir estas pautas:

• Comenzar preguntándose: "¿Es esto un es-un (is-a) o un puede-hacer (can-do)?" Las relaciones "es-un" suelen modelarse mejor con clases abstractas, mientras que las capacidades "puede-hacer" encajan mejor con interfaces.
• Evaluar si las clases que implementarán el contrato comparten código común. Si es así, una clase abstracta puede evitar duplicación.
• Considerar si las clases implementadoras necesitarán pertenecer a múltiples categorías. En ese caso, las interfaces son la única opción viable.
• Analizar si se requiere control sobre la visibilidad de los métodos. Las clases abstractas ofrecen mayor flexibilidad en este aspecto.
• Pensar en términos de evolución futura: ¿Qué cambios son más probables? ¿Cómo afectarían estos cambios a las implementaciones existentes?