Quelles sont les différences entre les interfaces en Kotlin et Java?

Principales différences :

• Implémentation des méthodes par défaut : En Java 8 et versions supérieures, il est possible d'implémenter des méthodes avec corps (méthodes par défaut) dans les interfaces. En Kotlin, les méthodes dans les interfaces ont des corps par défaut. Le mot-clé default n'est pas nécessaire.

• Méthodes abstraites et ouvertes : En Java, toutes les méthodes d'une interface sont implicitement abstraites. Pour faire une méthode avec corps, il faut utiliser default. En Kotlin, les méthodes avec corps dans une interface sont implicitement open et peuvent être redéfinies dans les classes qui implémentent l'interface. Les méthodes sans corps sont implicitement abstract.

• État (Propriétés) : En Java, les interfaces ne peuvent contenir que des constantes (final static), pas de champs. En Kotlin, les interfaces peuvent déclarer des propriétés abstraites, qui doivent être implémentées dans les classes, ou des propriétés avec getters/setters par défaut (les champs de soutien ne stockent pas de données).

• Constructeurs : En Java, les interfaces ne peuvent pas contenir de constructeurs. En Kotlin, les interfaces ne peuvent pas contenir de constructeurs.

• Modificateurs de visibilité : En Java, les méthodes d'interface sont implicitement public. En Kotlin, les méthodes d'interface sont implicitement public open.

Caractéristique	Kotlin	Java
Implémentation des méthodes	Permise (par défaut)	Permise (avec default)
Abstraction des méthodes	Sans corps - abstract, avec corps - open	Sans corps - abstract, avec corps - default
Propriétés (état)	Permises (abstraites ou avec accesseurs)	Non permises (seules des constantes)
Constructeurs	Non permises	Non permises
Modificateur de visibilité	public open par défaut	public par défaut

Exemple en Kotlin :

interface MyInterface {
    val myProperty: String // Propriété abstraite

    fun abstractMethod() // Méthode abstraite

    fun defaultMethod() {
        // Implémentation par défaut
        println("Implémentation par défaut dans l'interface Kotlin")
    }
}

Exemple en Java :

interface MyInterfaceJava {
    // Pas de propriétés, seulement des constantes autorisées
    // public static final String MY_CONSTANT = "valeur";

    void abstractMethod(); // Méthode abstraite (implicite public et abstract)

    default void defaultMethod() { // Méthode par défaut
        // Implémentation par défaut
        System.out.println("Implémentation par défaut dans l'interface Java");
    }
}