interfaz Palabra clave en Java

La palabra clave interface en Java se utiliza para declarar un tipo especial de clase que sólo contiene métodos abstractos, métodos por defecto, métodos estáticos y variables finales. Las interfaces proporcionan una forma de lograr la abstracción y la herencia múltiple en Java.

Utilización

Las interfaces se utilizan para especificar un conjunto de métodos que una clase debe aplicar. Son especialmente útiles para definir un contrato al que puedan adherirse varias clases, garantizando que proporcionan funcionalidades específicas.

Syntax

interface InterfaceName {
    // constant fields
    // abstract methods
    // default methods
    // static methods
}

• InterfaceName: El nombre de la interfaz.
• Campos constantes: Los campos declarados en una interfaz son implícitamente public, static, y final.
• Métodos abstractos: Métodos sin cuerpo que deben ser implementados por las clases que implementan la interfaz.
• Métodos por defecto: Métodos con cuerpo que proporcionan una implementación por defecto.
• Métodos estáticos: Métodos con cuerpo que pertenecen a la propia clase de la interfaz.

Ejemplos

Ejemplo 1: Interfaz básica

interface Animal {
    void eat();
    void sleep();
}

class Dog implements Animal {
    public void eat() {
        System.out.println("Dog is eating");
    }

    public void sleep() {
        System.out.println("Dog is sleeping");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
        dog.sleep();
    }
}

En este ejemplo, la interfaz Animal declara dos métodos abstractos: eat y sleep. La clase Dog implementa la interfaz Animal y proporciona implementaciones concretas para estos métodos.

Ejemplo 2: Interfaz con método por defecto

interface Vehicle {
    void start();
    default void stop() {
        System.out.println("Vehicle is stopping");
    }
}

class Car implements Vehicle {
    public void start() {
        System.out.println("Car is starting");
    }
}

public class DefaultMethodExample {
    public static void main(String[] args) {
        Car car = new Car();
        car.start();
        car.stop();
    }
}

Aquí, la interfaz Vehicle incluye un método por defecto stop. La clase Car implementa la interfaz Vehicle y proporciona una implementación para el método start. El método por defecto stop se hereda y puede utilizarse tal cual.

Ejemplo 3: Interfaz con método estático

interface Calculator {
    static int add(int a, int b) {
        return a + b;
    }
}

public class StaticMethodExample {
    public static void main(String[] args) {
        int result = Calculator.add(5, 3);
        System.out.println("Sum: " + result);
    }
}

Este ejemplo muestra una interfaz Calculator con un método estático add. El método estático puede invocarse directamente utilizando el nombre de la interfaz sin necesidad de una instancia.

Consejos y buenas prácticas

• Responsabilidad única: Mantén las interfaces centradas en una única responsabilidad. Esto facilita su comprensión y aplicación.
• Convenciones de nomenclatura: Utiliza nombres significativos para las interfaces. A menudo, los nombres de las interfaces son adjetivos o sustantivos que describen el comportamiento o la función, como Runnable, Serializable o List.
• Evita la sobrecarga: Evita sobrecargar los métodos en las interfaces para mantener la claridad y la simplicidad.
• Utiliza sabiamente los métodos por defecto: Los métodos por defecto pueden ser útiles para proporcionar compatibilidad con versiones anteriores, pero utilízalos con moderación para evitar complicar la interfaz.
• Interfaces de documentos: Documenta claramente la finalidad y el comportamiento esperado de cada método de la interfaz para guiar a los implementadores.
• Prefiere la Composición a la Herencia: Utiliza interfaces para definir capacidades y prefiere la composición a la herencia para conseguir un código flexible y fácil de mantener.

Conceptos adicionales

Múltiples interfaces

Una clase en Java puede implementar varias interfaces, lo que le permite heredar los métodos abstractos de todas las interfaces implementadas.

interface Movable {
    void move();
}

interface Stoppable {
    void stop();
}

class Robot implements Movable, Stoppable {
    public void move() {
        System.out.println("Robot is moving");
    }

    public void stop() {
        System.out.println("Robot has stopped");
    }
}

public class MultipleInterfacesExample {
    public static void main(String[] args) {
        Robot robot = new Robot();
        robot.move();
        robot.stop();
    }
}

En este ejemplo, la clase Robot implementa las interfaces Movable y Stoppable, proporcionando implementaciones para los métodos definidos en ambas interfaces.