Magyarázza el a protected hozzáférés módosító használatának különbségeit Java és Kotlin nyelveken.

Java-ban a protected hozzáférés módosító azt jelenti, hogy a osztály tagja:

• A saját osztályán belül
• Minden öröklődő osztályban (még akkor is, ha más csomagban vannak)
• Minden osztályban ugyanabban a csomagban

Tehát, a Java-ban a protected egy kombinációja az öröklődésen alapuló és a csomagon belüli hozzáférésnek.

Kotlinban viszont a protected csak az osztályon belül és annak leszármazottain belül teszi lehetővé a hozzáférést, de nem elérhető más osztályokból ugyanabban a csomagban. Kotlinban nincs csomag alapú hozzáférés fogalma, ezért a protected szigorúbb, mint Java-ban.

Példa:

// 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; // Elérhető, mert ugyanabban a csomagban
    }
}

package pkg2;
public class C extends A {
    void test() {
        int val = x; // Elérhető, mert leszármazott
    }
}

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

class B : A() {
    fun test() {
        println(x) // Elérhető, leszármazott
    }
}

class C {
    fun test() {
        val a = A()
        // println(a.x) // Hiba: `protected` nem elérhető osztályon kívül és leszármazottain kívül
    }
}

Ezért a fő különbség az, hogy Kotlinban a protected nem engedélyezi a csomagon belüli hozzáférést, csak öröklődésen keresztül, míg Java-ban mindkettő lehetséges.