Dominando interfaces en Java: Conceptos, implementación y mejores prácticas

Interfaces en Java explicadas

Las interfaces en Java definen un contrato que las clases implementadoras deben cumplir. Permiten abstracción, herencia múltiple y promueven una arquitectura limpia y modular.

Definiendo una interfaz

Una interfaz es un tipo completamente abstracto. Todos sus métodos son implícitamente public abstract, y todos los campos son public static final. Se declara con la palabra clave interface:

interface Lenguaje { void obtenerTipo(); void obtenerVersion(); }

Aquí, Lenguaje es una interfaz que contiene dos métodos abstractos.

Implementando una interfaz

Las interfaces no pueden instanciarse. Las clases las implementan usando la palabra clave implements y proporcionan cuerpos concretos para todos los métodos abstractos.

Ejemplo 1: Interfaz Polígono

interface Poligono { void obtenerArea(int largo, int ancho); } class Rectangulo implements Poligono { @Override public void obtenerArea(int largo, int ancho) { System.out.println("El área del rectángulo es " + (largo * ancho)); } } class Main { public static void main(String[] args) { Rectangulo r = new Rectangulo(); r.obtenerArea(5, 6); } }

Salida:

El área del rectángulo es 30

Ejemplo 2: Interfaz Lenguaje

interface Lenguaje { void obtenerNombre(String nombre); } class LenguajeProgramacion implements Lenguaje { @Override public void obtenerNombre(String nombre) { System.out.println("Lenguaje de programación: " + nombre); } } class Main { public static void main(String[] args) { LenguajeProgramacion lang = new LenguajeProgramacion(); lang.obtenerNombre("Java"); } }

Salida:

Lenguaje de programación: Java

Implementando múltiples interfaces

Una clase puede implementar varias interfaces:

interface A { /* miembros */ } interface B { /* miembros */ } class C implements A, B { /* implementaciones */ }

Extender una interfaz

Las interfaces pueden extender otras interfaces usando extends:

interface Linea { /* miembros */ } interface Poligono extends Linea { /* miembros */ }

Una clase que implementa Poligono debe proporcionar métodos para miembros de tanto Linea como Poligono.

Extender múltiples interfaces

interface A { /* ... */ } interface B { /* ... */ } interface C extends A, B { /* ... */ }

¿Por qué usar interfaces?

• Abstracción: Define operaciones sin dictar implementación, permitiendo comportamiento variado entre clases.
• Especificación: Establece un contrato claro que las clases implementadoras deben cumplir.
• Herencia múltiple: Permite a una clase adoptar comportamientos de múltiples fuentes.
• Visibilidad por defecto: Todos los métodos son implícitamente public; los campos son public static final.

Ejemplo de constantes implícitas:

interface Lenguaje { String TIPO = "lenguaje de programación"; // implícitamente public static final void obtenerNombre(); // implícitamente public }

Métodos default (Java 8+)

Java 8 introdujo métodos default, permitiendo que las interfaces contengan cuerpos de métodos concretos:

default void obtenerLados() { System.out.println("Puedo obtener lados de un polígono."); }

Los métodos default permiten compatibilidad hacia atrás al agregar nuevos métodos a interfaces sin romper implementaciones existentes.

Ejemplo: Uso de método default

interface Poligono { void obtenerArea(); default void obtenerLados() { System.out.println("Puedo obtener lados de un polígono."); } } class Rectangulo implements Poligono { @Override public void obtenerArea() { int largo = 6; int ancho = 5; int area = largo * ancho; System.out.println("El área del rectángulo es " + area); } @Override public void obtenerLados() { System.out.println("Tengo 4 lados."); } } class Cuadrado implements Poligono { @Override public void obtenerArea() { int largo = 5; int area = largo * largo; System.out.println("El área del cuadrado es " + area); } } class Main { public static void main(String[] args) { Rectangulo r = new Rectangulo(); r.obtenerArea(); r.obtenerLados(); Cuadrado c = new Cuadrado(); c.obtenerArea(); c.obtenerLados(); } }

Salida:

El área del rectángulo es 30 Tengo 4 lados. El área del cuadrado es 25 Puedo obtener lados de un polígono.

Métodos estáticos y privados (Java 9+)

Las interfaces ahora pueden contener métodos static, invocables vía el nombre de la interfaz:

interface Poligono { static void helper() { /* ... */ } } Poligono.helper();

Los métodos privados proporcionan utilidades internas para otros métodos de la interfaz, asegurando encapsulación.

Ejemplo práctico: Cálculos de polígonos

import java.lang.Math; interface Poligono { void obtenerArea(); default void obtenerPerimetro(int... lados) { int perimetro = 0; for (int lado : lados) perimetro += lado; System.out.println("Perímetro: " + perimetro); } } class Triangulo implements Poligono { private final int a, b, c; private double area; Triangulo(int a, int b, int c) { this.a = a; this.b = b; this.c = c; } @Override public void obtenerArea() { double s = (a + b + c) / 2.0; area = Math.sqrt(s * (s - a) * (s - b) * (s - c)); System.out.println("Área: " + area); } } class Main { public static void main(String[] args) { Triangulo t = new Triangulo(2, 3, 4); t.obtenerArea(); t.obtenerPerimetro(2, 3, 4); } }

Salida:

Área: 2.9047375096555625 Perímetro: 9

En este ejemplo, la interfaz Poligono provee un método obtenerPerimetro reutilizable, mientras cada forma implementa su propio cálculo de área.