Interfaces en JAVA

En Java, una interfaz es un tipo abstracto que contiene una colección de métodos y variables constantes. Es uno de los conceptos básicos de Java y se utiliza para lograr abstracción, polimorfismo y herencias múltiples.

Vídeo explicativo

¿Qué es una interfaz en JAVA?

Una interfaz es una “clase abstracta” completamente que se utiliza para agrupar métodos relacionados con cuerpos vacíos. Ejemplo:

interface Vehiculo {
  void encenderMotor(); // método de interfaz (no tiene cuerpo)
  void conducir(); // método de interfaz (no tiene cuerpo)
}

Para acceder a los métodos de la interfaz, la interfaz debe ser “implementada” (algo así como heredada) por otra clase con la palabra clave implements (en lugar de extends). El cuerpo del método de interfaz lo proporciona la clase que implementa la interfaz:

// Coche "implementa" la interfaz Vehiculo
class Coche implements Vehiculo {
  public void encenderMotor() {
    // El cuerpo de encenderMotor() se implementa aquí
    System.out.println("El motor del coche está encendido");
  }
  public void conducir() {
    // El cuerpo de conducir() se implementa aquí
    System.out.println("El coche esta conduciendo");
  }
}

Reglas para crear interfaces

En una interfaz, podemos usar:

variables constantes
métodos abstractos
métodos static
métodos default

También debemos recordar que:

No podemos instanciar interfaces directamente
Una interfaz puede estar vacía, sin métodos o variables en ella
No podemos usar la última palabra en la definición de la interfaz, ya que dará como resultado un error de compilación
Todas las declaraciones de interfaz deben tener el modificador de acceso público o predeterminado; el compilador agregará automáticamente el modificador abstracto
Un método de interfaz no puede ser protegido o final
Hasta Java 9, los métodos de interfaz no podían ser private; sin embargo, Java 9 introdujo la posibilidad de definir métodos private en las interfaces
Las variables de interfaz son públicas, estáticas y finales por definición; no podemos cambiar su visibilidad

¿Para qué sirven las interfaces?

Funcionalidad interna en JAVA

Usamos interfaces para agregar cierta funcionalidad de comportamiento que pueden usar clases no relacionadas. Por ejemplo, Comparable, Comparator y Cloneable son interfaces de Java que pueden implementarse mediante clases no relacionadas. A continuación se muestra un ejemplo de la interfaz Comparator que se utiliza para comparar dos instancias de la clase Empleado:

public class Empleado {

    private double salario;

    public double getSalario() {
        return salario;
    }

    public void setSalario(double salario) {
        this.salario = salario;
    }
}

public class EmpleadoSalarioComparator implements Comparator<Empleado> {

    @Override
    public int compare(Empleado empleado1, Empleado empleado2) {
        if (empleado1.getSalario() < empleado2.getSalario()) {
            return -1;
        } else if (empleado1.getSalario() > empleado2.getSalario()) { 
            return 1;
        } else {
            return 0;
        }
    }
}

Herencias Múltiples

Las clases de Java admiten la herencia singular. Sin embargo, mediante el uso de interfaces, también podemos implementar herencias múltiples.

Polimorfismo

En Java, podemos lograr polimorfismo usando interfaces. Por ejemplo, la interfaz de Forma puede tomar diferentes formas: puede ser un círculo o un cuadrado.

public interface Forma {
    String name();
}

public class Circulo implements Forma {

    @Override
    public String name() {
        return "Circulo";
    }
}

public class Cuadrado implements Forma {

    @Override
    public String name() {
        return "Cuadrado";
    }
}

Finalmente, es hora de ver el polimorfismo en acción utilizando nuestra interfaz Forma y sus implementaciones. Instanciaremos algunos objetos Forma, agréguelos a una Lista y, finalmente, imprimamos sus nombres en un bucle:

List<Forma> formas = new ArrayList<>();
Forma circulo = new Circulo();
Forma cuadrado = new Cuadrado();

shapes.add(circulo);
shapes.add(cuadrado);

for (Forma forma : formas) {
    System.out.println(forma.name());
}

Reglas de herencia de interfaz

Interfaz que extiende otra interfaz

Cuando una interfaz extiende otra interfaz, hereda todos los métodos abstractos de esa interfaz. Comencemos creando dos interfaces, Caja y Forma:

public interface Forma {
    String getColor();
}

public interface Caja extends Forma {
    int getAltura();
}

En el ejemplo anterior, Caja hereda de Forma usando la palabra clave extends. Al hacerlo, la interfaz de Caja hereda getColor. Como resultado, la interfaz de Caja ahora tiene dos métodos: getColor y getAltura.

Clase abstracta que implementa una interfaz

Cuando una clase abstracta implementa una interfaz, hereda todos sus métodos abstractos y default. Consideremos la interfaz Forma y la clase abstracta Cuadrado que la implementa:

public interface Forma {
    
    void getColor();
    default void descripcion(){
        System.out.println("El color es:" + getColor());
    }
}

public abstract class Cuadrado implements Forma {}

En este ejemplo, la clase Cuadrado hereda dos métodos: el método de transformación abstracta y el método descripcion default