Palabra clave por defecto en Java

La palabra clave default en Java tiene múltiples usos, principalmente en sentencias switch y métodos de interfaz. Proporciona un caso por defecto en las sentencias switch y permite que los métodos de las interfaces tengan una implementación por defecto.

Utilización

1. Caso por defecto en las sentencias switch

En una sentencia switch, la palabra clave default especifica el bloque de código que se ejecutará si ningún caso coincide con la expresión switch.

2. Métodos por defecto en las interfaces

En las interfaces, la palabra clave default permite crear métodos con una implementación por defecto. Esta característica, introducida en Java 8, permite que las interfaces evolucionen sin romper las implementaciones existentes.

Syntax

Declaración de cambio

switch (expression) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    default:
        // default code block
}

Métodos por defecto en las interfaces

public interface InterfaceName {
    default void methodName() {
        // default implementation
    }
}

Ejemplos

Ejemplo 1: Caso por defecto en la sentencia Switch

public class DefaultSwitchExample {
    public static void main(String[] args) {
        int day = 5;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            // other cases
            default:
                System.out.println("Invalid day");
                break;
        }
    }
}

En este ejemplo, el caso default se ejecuta si el valor de day no coincide con ninguno de los casos especificados.

Ejemplo 2: Método por defecto en la interfaz

public interface MyInterface {
    default void display() {
        System.out.println("Default display method");
    }
}

public class DefaultMethodExample implements MyInterface {
    public static void main(String[] args) {
        DefaultMethodExample example = new DefaultMethodExample();
        example.display(); // Calls the default method
    }
}

Aquí, la interfaz MyInterface tiene un método por defecto display(). La clase DefaultMethodExample implementa esta interfaz pero no anula el método display(), por lo que se utiliza la implementación por defecto.

Ejemplo 3: Anulación del método por defecto

public interface MyInterface {
    default void display() {
        System.out.println("Default display method");
    }
}

public class OverrideDefaultMethodExample implements MyInterface {
    @Override
    public void display() {
        System.out.println("Overridden display method");
    }

    public static void main(String[] args) {
        OverrideDefaultMethodExample example = new OverrideDefaultMethodExample();
        example.display(); // Calls the overridden method
    }
}

En este ejemplo, la clase OverrideDefaultMethodExample anula el método por defecto display() proporcionado por la interfaz MyInterface.

Consejos y buenas prácticas

• Declaraciones de cambio: Incluye siempre un caso default en las sentencias switch para manejar valores inesperados.
• Evolución de la interfaz: Utiliza métodos por defecto en las interfaces para añadir nuevos métodos sin romper las implementaciones existentes.
• Manejar la herencia múltiple: Cuando varias interfaces tienen métodos por defecto con el mismo nombre, la clase implementadora debe resolver la ambigüedad anulando el método.
• Anular con Precaución: Cuando sobrescribas métodos predeterminados, asegúrate de que la nueva implementación no rompe el contrato existente de la interfaz.
• Documentación: Documenta claramente el comportamiento de los métodos por defecto para evitar confusiones a los usuarios de la interfaz.