Interfaces en Java

Una interfaz en Java es un tipo especial de clase que define un conjunto de métodos abstractos y constantes. A diferencia de una clase regular, una interfaz no puede ser instanciada directamente, sino que debe ser implementada por otra clase.

Las interfaces se utilizan para establecer contratos que las clases implementadoras deben cumplir. Esto promueve la modularidad, la reutilización de código y el polimorfismo.

Ejemplo 1: Definición e implementación de una interfaz

Supongamos que queremos definir un comportamiento común para diferentes tipos de vehículos. Podemos crear una interfaz llamada Vehiculo:

public interface Vehiculo {
    void avanzar();
    void frenar();
    void cambiarVelocidad(int velocidad);
}

Ahora, podemos crear clases que implementen esta interfaz:

public class Automovil implements Vehiculo {
    @Override
    public void avanzar() {
        System.out.println("El automóvil avanza");
    }

    @Override
    public void frenar() {
        System.out.println("El automóvil frena");
    }

    @Override
    public void cambiarVelocidad(int velocidad) {
        System.out.println("El automóvil cambia su velocidad a " + velocidad + " km/h");
    }
}

public class Bicicleta implements Vehiculo {
    @Override
    public void avanzar() {
        System.out.println("La bicicleta avanza");
    }

    @Override
    public void frenar() {
        System.out.println("La bicicleta frena");
    }

    @Override
    public void cambiarVelocidad(int velocidad) {
        System.out.println("La bicicleta cambia su velocidad a " + velocidad + " km/h");
    }
}

Tanto Automovil como Bicicleta implementan la interfaz Vehiculo, por lo que deben proporcionar una implementación para todos los métodos definidos en la interfaz.

Ejemplo 2: Polimorfismo con interfaces

Una de las principales ventajas de las interfaces es que permiten el polimorfismo. Esto significa que podemos tratar objetos de diferentes clases como si fueran del mismo tipo, siempre que implementen la misma interfaz.

public class Main {
    public static void moverVehiculo(Vehiculo vehiculo) {
        vehiculo.avanzar();
        vehiculo.cambiarVelocidad(60);
        vehiculo.frenar();
    }

    public static void main(String[] args) {
        Automovil auto = new Automovil();
        Bicicleta bici = new Bicicleta();

        moverVehiculo(auto); // Salida: El automóvil avanza, El automóvil cambia su velocidad a 60 km/h, El automóvil frena
        moverVehiculo(bici); // Salida: La bicicleta avanza, La bicicleta cambia su velocidad a 60 km/h, La bicicleta frena
    }
}

En este ejemplo, el método moverVehiculo acepta un objeto de tipo Vehiculo. Tanto Automovil como Bicicleta implementan la interfaz Vehiculo, por lo que podemos pasar instancias de estas clases al método moverVehiculo.

Ejemplo 3: Interfaces y clases abstractas

Las interfaces y las clases abstractas son complementarias en Java. Las interfaces definen un contrato que las clases implementadoras deben cumplir, mientras que las clases abstractas pueden proporcionar implementaciones parciales o predeterminadas de los métodos.

public abstract class VehiculoBase implements Vehiculo {
    @Override
    public void avanzar() {
        System.out.println("El vehículo avanza");
    }

    @Override
    public void frenar() {
        System.out.println("El vehículo frena");
    }

    // Método abstracto que las subclases deben implementar
    public abstract void cambiarVelocidad(int velocidad);
}

public class Automovil extends VehiculoBase {
    @Override
    public void cambiarVelocidad(int velocidad) {
        System.out.println("El automóvil cambia su velocidad a " + velocidad + " km/h");
    }
}

En este ejemplo, tenemos una clase abstracta VehiculoBase que implementa la interfaz Vehiculo. Esta clase proporciona implementaciones predeterminadas para los métodos avanzar() y frenar(), pero declara el método cambiarVelocidad(int velocidad) como abstracto.

La clase Automovil extiende de VehiculoBase y debe proporcionar una implementación para el método cambiarVelocidad(int velocidad).

Esta combinación de interfaces y clases abstractas permite una mayor flexibilidad y reutilización de código, al tiempo que proporciona implementaciones parciales o predeterminadas cuando sea necesario.