Что такое Unit и Nothing в Kotlin? Для чего нужен тип Nothing и какие выражения имеют такой тип?

В чем разница между protected в Java и protected в Kotlin?

Protected в Java и Kotlin имеют разные модификаторы доступа. Это один из важных отличий между двумя языками, который часто игнорируют при переходе с Java на Kotlin.

Protected в Java

В Java protected означает, что видимость класса/члена распространяется на:

1. Сам пакет (package-private)
2. Все подклассы (даже из других пакетов)

// Java
package com.example;

public class Parent {
    protected void method() {
        System.out.println("Protected method");
    }
}

// Доступно в этом же пакете
class Child {
    Parent parent = new Parent();
    parent.method();  // OK
}

// Доступно в других пакетах если наследоваться
package com.other;

public class GrandChild extends Parent {
    @Override
    protected void method() {
        super.method();  // OK, наследуемый класс видит protected
    }
}

Protected в Kotlin

В Kotlin protected имеет другое значение. Оно видимо только в подклассах, но НЕ в пакете.

// Kotlin
package com.example

open class Parent {
    protected fun method() {
        println("Protected method")
    }
}

// НЕ доступно в этом же пакете (!)
class Child {
    val parent = Parent()
    parent.method()  // ОШИБКА! Protected не видно
}

// Доступно в подклассах из любого пакета
package com.other

class GrandChild : Parent() {
    override fun method() {
        super.method()  // OK
    }
}

Таблица сравнения

Почему это отличие

Kotlin был создан с идеей о том, что protected должен означать "для подклассов", а не "для пакета". Это более строгое инкапсулирование.

Если в Kotlin нужна видимость в пакете, используй internal вместо protected:

package com.example

open class Parent {
    internal fun method() {  // Видно везде в пакете, но НЕ в подклассах
        println("Internal method")
    }
    
    protected fun protectedMethod() {  // Видно только в подклассах
        println("Protected method")
    }
}

class Child {
    val parent = Parent()
    parent.method()  // OK — internal видно в пакете
    parent.protectedMethod()  // ОШИБКА — protected НЕ видно в пакете
}

Модификаторы доступа в Kotlin

• public — всюду (по умолчанию)
• internal — в модуле
• protected — в подклассах
• private — в файле/классе

Практический пример

// Java привычка в Kotlin (будет ошибка)
open class DatabaseHelper {
    protected fun executeQuery(sql: String): List<Any> {
        // Java разработчик думает: "protected, значит видно в пакете"
        return emptyList()
    }
}

class UserRepository {
    val db = DatabaseHelper()
    fun getUsers() {
        db.executeQuery("SELECT * FROM users")  // ОШИБКА в Kotlin!
    }
}

// Правильно в Kotlin
open class DatabaseHelper {
    internal fun executeQuery(sql: String): List<Any> {  // internal для пакета
        return emptyList()
    }
}

class UserRepository {
    val db = DatabaseHelper()
    fun getUsers() {
        db.executeQuery("SELECT * FROM users")  // OK
    }
}

Migration Java → Kotlin

Если мигрируешь Java код где используется protected в пакете:

// Java
public class Parent {
    protected void packageVisibleMethod() {}
}

class Child {
    Parent p = new Parent();
    p.packageVisibleMethod();  // OK в Java
}

// Kotlin — нужно менять на internal
open class Parent {
    internal fun packageVisibleMethod() {}  // internal вместо protected
}

class Child {
    val p = Parent()
    p.packageVisibleMethod()  // OK
}

Правила использования

• Используй protected — только для методов, которые должны быть переопределены в подклассах
• Используй internal — для функций/классов видимых в пакете/модуле
• Используй private — по умолчанию для всего остального

Ответ: Protected в Java видимо в пакете и подклассах, в Kotlin protected видимо только в подклассах. Для пакета используй internal.