Interfaces Java

Programación

1. Información general

En este tutorial, hablaremos sobre interfaces en Java. También veremos cómo los usa Java para implementar polimorfismo y herencias múltiples.

2. ¿Qué son las 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 centrales en Java y se utiliza para lograr abstracción, polimorfismo y herencias múltiples .

Veamos un ejemplo simple de una interfaz en Java:

public interface Electronic { // Constant variable String LED = "LED"; // Abstract method int getElectricityUse(); // Static method static boolean isEnergyEfficient(String electtronicType) { if (electtronicType.equals(LED)) { return true; } return false; } //Default method default void printDescription() { System.out.println("Electronic Description"); } }

Podemos implementar una interfaz en una clase Java utilizando la palabra clave implements .

A continuación, creemos también una clase Computer que implemente la interfaz electrónica que acabamos de crear:

public class Computer implements Electronic { @Override public int getElectricityUse() { return 1000; } }

2.1. Reglas para crear interfaces

En una interfaz, podemos usar:

  • variables constantes
  • métodos abstractos
  • métodos estáticos
  • métodos predeterminados

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 resultará en un error del compilador
  • todas las declaraciones de interfaz deben tener el modificador de acceso público o predeterminado; el modificador abstracto será agregado automáticamente por el compilador
  • un método de interfaz no puede ser privado , protegido o final
  • las variables de interfaz son públicas , estáticas y finales por definición; no se nos permite cambiar su visibilidad

3. ¿Qué podemos lograr usándolos?

3.1. Funcionalidad conductual

Usamos interfaces para agregar ciertas funciones de comportamiento que pueden ser utilizadas por clases no relacionadas. Por ejemplo, Comparable , Comparator y Cloneable son interfaces Java que pueden ser implementadas por clases no relacionadas. A continuación se muestra un ejemplo de la interfaz del comparadorque se usa para comparar dos instancias de la clase Empleado :

public class Employee { private double salary; public double getSalary() { return salary; } public void setSalary(double salary) { this.salary = salary; } } public class EmployeeSalaryComparator implements Comparator { @Override public int compare(Employee employeeA, Employee employeeB) { if (employeeA.getSalary()  employeeB.getSalary()) { return 1; } else { return 0; } } }

Para obtener más información, visite nuestro tutorial sobre Comparador y Comparable en Java.

3.2. Herencias múltiples

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

Por ejemplo, en el ejemplo siguiente, notamos que la clase Carimplementa las interfaces Fly y Transform . Al hacerlo, hereda los métodos fly y transform :

public interface Transform { void transform(); } public interface Fly { void fly(); } public class Car implements Fly, Transform { @Override public void fly() { System.out.println("I can Fly!!"); } @Override public void transform() { System.out.println("I can Transform!!"); } }

3.3. Polimorfismo

Comencemos con la pregunta: ¿qué es el polimorfismo? Es la capacidad de un objeto de adoptar diferentes formas durante el tiempo de ejecución. Para ser más específico, es la ejecución del método de anulación que está relacionado con un tipo de objeto específico en tiempo de ejecución.

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

Comencemos por definir la interfaz Shape :

public interface Shape { String name(); }

Ahora creemos también la clase Circle :

public class Circle implements Shape { @Override public String name() { return "Circle"; } }

Y también la clase Square :

public class Square implements Shape { @Override public String name() { return "Square"; } }

Finalmente, es hora de ver el polimorfismo en acción utilizando nuestra interfaz Shape y sus implementaciones. Vamos a ejemplifican algunos Forma objetos, añadirlos a una lista , y, finalmente, imprimir sus nombres en un bucle:

List shapes = new ArrayList(); Shape circleShape = new Circle(); Shape squareShape = new Square(); shapes.add(circleShape); shapes.add(squareShape); for (Shape shape : shapes) { System.out.println(shape.name()); }

4. Métodos predeterminados en interfaces

Las interfaces tradicionales en Java 7 y versiones anteriores no ofrecen compatibilidad con versiones anteriores.

Lo que esto significa es que si tiene un código heredado escrito en Java 7 o anterior y decide agregar un método abstracto a una interfaz existente, todas las clases que implementan esa interfaz deben anular el nuevo método abstracto . De lo contrario, el código se romperá.

Java 8 resolvió este problema al introducir el método predeterminado que es opcional y se puede implementar a nivel de interfaz.

5. Reglas de herencia de interfaz

Para lograr múltiples herencias a través de interfaces, debemos recordar algunas reglas. Repasemos estos en detalle.

5.1. Interfaz que extiende otra interfaz

When an interface extends another interface, it inherits all of that interface's abstract methods. Let's start by creating two interfaces, HasColor and Shape:

public interface HasColor { String getColor(); } public interface Box extends HasColor { int getHeight() }

In the example above, Box inherits from HasColor using the keyword extends. By doing so, the Box interface inherits getColor. As a result, the Box interface now has two methods: getColor and getHeight.

5.2. Abstract Class Implementing an Interface

When an abstract class implements an interface, it inherits all of its abstract and default methods. Let's consider the Transform interface and the abstract class Vehicle that implements it:

public interface Transform { void transform(); default void printSpecs(){ System.out.println("Transform Specification"); } } public abstract class Vehicle implements Transform {}

In this example, the Vehicle class inherits two methods: the abstract transform method and the default printSpecs method.

6. Functional Interfaces

Java has had many functional interfaces since its early days, such as Comparable (since Java 1.2) and Runnable (since Java 1.0).

Java 8 introdujo nuevas interfaces funcionales como Predicate , Consumer y Function . Para obtener más información sobre estos, visite nuestro tutorial sobre interfaces funcionales en Java 8.

7. Conclusión

En este tutorial, dimos una descripción general de las interfaces de Java y hablamos sobre cómo usarlas para lograr polimorfismo y herencias múltiples.

Como siempre, las muestras de código completas están disponibles en GitHub.