Expliquez les différences dans l'utilisation du modificateur d'accès protected en Java et Kotlin.

En Java, le modificateur d’accès protected signifie que le membre de la classe est accessible :

• Dans la classe elle-même
• Dans toutes les classes héritées (même si elles sont dans un paquet différent)
• Dans toutes les classes du même paquet

Autrement dit, protected en Java est une combinaison d’accès par héritage et par paquet.

En Kotlin, cependant, protected signifie un accès uniquement à l’intérieur de la classe elle-même et de ses sous-classes, mais pas accessible depuis d’autres classes du même paquet. En Kotlin, il n’y a pas de concept d’accès par paquet, donc protected est plus strict qu’en Java.

Exemple :

// Java
package pkg1;
public class A {
    protected int x = 10;
}

package pkg1;
public class B {
    void test() {
        A a = new A();
        int val = a.x; // Accessible, car dans le même paquet
    }
}

package pkg2;
public class C extends A {
    void test() {
        int val = x; // Accessible, car héritier
    }
}

// Kotlin
open class A {
    protected val x = 10
}

class B : A() {
    fun test() {
        println(x) // Accessible, héritier
    }
}

class C {
    fun test() {
        val a = A()
        // println(a.x) // Erreur : `protected` non accessible en dehors de la classe et de ses héritiers
    }
}

Ainsi, la principale différence est que en Kotlin protected ne donne pas accès par paquet, seulement par héritage, alors qu’en Java, il donne accès dans les deux cas.