Explique las diferencias en el uso del modificador de acceso protected en los lenguajes Java y Kotlin.

En Java, el modificador de acceso protected significa que el miembro de la clase es accesible:

• Dentro de la misma clase
• En todas las clases heredadas (incluso si están en paquetes diferentes)
• En todas las clases dentro del mismo paquete

Es decir, protected en Java es una combinación de acceso por herencia y por paquete.

En Kotlin, sin embargo, protected significa acceso solo dentro de la propia clase y sus subclases, pero no accesible desde otras clases del mismo paquete. En Kotlin no existe el concepto de acceso por paquete, por lo que protected es más estricto que en Java.

Ejemplo:

// 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; // Accesible, ya que es el mismo paquete
    }
}

package pkg2;
public class C extends A {
    void test() {
        int val = x; // Accesible, ya que es un heredero
    }
}

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

class B : A() {
    fun test() {
        println(x) // Accesible, heredero
    }
}

class C {
    fun test() {
        val a = A()
        // println(a.x) // Error: `protected` no accesible fuera de la clase y sus herederos
    }
}

Por lo tanto, la principal diferencia es que en Kotlin protected no permite acceso por paquete, solo por herencia, mientras que en Java permite ambos.