Leg uit wat de verschillen zijn in het gebruik van de toegangsmodule protected in Java en Kotlin.

In Java betekent de toegangsmodule protected dat het lid van de klasse toegankelijk is:

• Binnen de klasse zelf
• In alle afgeleide klassen (zelfs als ze zich in een ander pakket bevinden)
• In alle klassen binnen hetzelfde pakket

Dus, protected in Java is een combinatie van toegang via overerving en via pakket.

In Kotlin betekent protected echter dat toegang alleen binnen de klasse zelf en haar subklassen is, maar niet toegankelijk vanuit andere klassen in hetzelfde pakket. In Kotlin bestaat het concept van toegang via pakket niet, dus protected is strenger dan in Java.

Voorbeeld:

// 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; // Toegankelijk, omdat in hetzelfde pakket
    }
}

package pkg2;
public class C extends A {
    void test() {
        int val = x; // Toegankelijk, omdat subklasse
    }
}

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

class B : A() {
    fun test() {
        println(x) // Toegankelijk, subklasse
    }
}

class C {
    fun test() {
        val a = A()
        // println(a.x) // Fout: `protected` niet toegankelijk buiten de klasse en haar subklassen
    }
}

Dus, het belangrijkste verschil is dat in Kotlin protected geen toegang via pakket toestaat, alleen via overerving, terwijl in Java beide mogelijk zijn.