mot-clé par défaut en Java

Le mot-clé default en Java a de multiples usages, principalement dans les instructions de commutation et les méthodes d'interface. Il fournit un cas par défaut dans les instructions de commutation et permet aux méthodes des interfaces d'avoir une implémentation par défaut.

Utilisation

1. Cas par défaut dans les instructions de commutation

Dans une instruction switch, le mot-clé default spécifie le bloc de code à exécuter si aucun cas ne correspond à l'expression switch.

2. Méthodes par défaut dans les interfaces

Dans les interfaces, le mot-clé default permet de créer des méthodes avec une implémentation par défaut. Cette fonctionnalité, introduite dans Java 8, permet aux interfaces d'évoluer sans casser les implémentations existantes.

Syntax

Déclaration de l'interrupteur

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

Méthodes par défaut dans les interfaces

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

Exemples

Exemple 1 : Cas par défaut dans l'instruction de commutation

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;
        }
    }
}

Dans cet exemple, le cas default est exécuté si la valeur de day ne correspond à aucun des cas spécifiés.

Exemple 2 : Méthode par défaut dans l'interface

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
    }
}

Ici, l'interface MyInterface a une méthode par défaut display(). La classe DefaultMethodExample implémente cette interface mais ne surcharge pas la méthode display(), de sorte que l'implémentation par défaut est utilisée.

Exemple 3 : Surcharge de la méthode par défaut

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
    }
}

Dans cet exemple, la classe OverrideDefaultMethodExample remplace la méthode par défaut display() fournie par l'interface MyInterface.

Conseils et bonnes pratiques

• Énoncés sur les commutateurs: Incluez toujours un cas default dans les instructions de commutation pour gérer les valeurs inattendues.
• Évolution de l'interface: Utilisez les méthodes par défaut dans les interfaces pour ajouter de nouvelles méthodes sans casser les implémentations existantes.
• Gestion de l'héritage multiple: Lorsque plusieurs interfaces ont des méthodes par défaut portant le même nom, la classe qui les met en œuvre doit résoudre l'ambiguïté en surchargeant la méthode.
• Passer outre avec prudence: Lorsque vous remplacez des méthodes par défaut, assurez-vous que la nouvelle implémentation ne rompt pas le contrat existant de l'interface.
• Documentation: Documentez clairement le comportement des méthodes par défaut afin d'éviter toute confusion pour les utilisateurs de l'interface.