Spiega le differenze nell'uso del modificatore di accesso protected nei linguaggi Java e Kotlin.

In Java, il modificatore di accesso protected significa che il membro della classe è accessibile:

• All’interno della stessa classe
• In tutte le classi ereditarie (anche se si trovano in pacchetti diversi)
• In tutte le classi all’interno dello stesso pacchetto

Quindi, protected in Java è una combinazione di accesso tramite ereditarietà e tramite pacchetto.

In Kotlin, invece, protected significa accesso solo all’interno della stessa classe e delle sue sottoclassi, ma non accessibile da altre classi dello stesso pacchetto. In Kotlin non esiste il concetto di accesso tramite pacchetto, quindi protected è più restrittivo rispetto a Java.

Esempio:

// 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; // Accessibile, perché nello stesso pacchetto
    }
}

package pkg2;
public class C extends A {
    void test() {
        int val = x; // Accessibile, perché sottoclasse
    }
}

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

class B : A() {
    fun test() {
        println(x) // Accessibile, sottoclasse
    }
}

class C {
    fun test() {
        val a = A()
        // println(a.x) // Errore: `protected` non accessibile fuori dalla classe e dalle sue sottoclassi
    }
}

Pertanto, la principale differenza è che in Kotlin protected non consente l’accesso tramite pacchetto, solo tramite ereditarietà, mentre in Java permette entrambi.