Что означает восклицательный знак в Kotlin? (Single exclamation mark)

Платформенные типы (Platform Types) в Kotlin

Одинарный восклицательный знак после типа (String!) — это не настоящий тип Kotlin, а обозначение платформенного типа (platform type). Он возникает при взаимодействии Kotlin-кода с Java-кодом, где информация о null-безопасности не аннотирована (нет аннотаций @Nullable или @NotNull).

Kotlin строг к null-безопасности: типы с ? могут быть null, без ? — никогда. Но Java не делает такого различия. Поэтому Kotlin вводит понятие платформенного типа — это "серая зона", где компилятор не знает, может ли значение быть null. IDE отображает это как String!, но в исходном коде вы не можете явно указать такой тип — это внутреннее обозначение.

Как это работает на практике?

Когда вы объявляете переменную с платформенным типом, Kotlin ослабляет проверки на этапе компиляции. Вы можете обращаться с ней как с non-null типом (без ?), и компилятор не выдаст ошибку. Однако, если в рантайме значение окажется null, вы получите NullPointerException (NPE).

// Java класс
public class JavaService {
    public static String getName() { return null; }
}

// Kotlin использование
fun main() {
    val name = JavaService.getName() // тип name: String!
    
    // Компилятор НЕ ругается, хотя getName() вернул null
    println(name.length) // NPE в рантайме!
    
    // Но вы можете проверить на null:
    if (name != null) {
        println(name.length) // безопасно
    }
    
    // Или явно указать nullable тип:
    val nullableName: String? = JavaService.getName()
    println(nullableName?.length) // безопасно, выведет null
}

Почему это так сделано?

• Обратная совместимость: тысячи Java библиотек не имеют аннотаций null-безопасности. Если бы Kotlin требовал явной обработки null для каждого Java вызова, код был бы перегружен проверками.
• Производительность: платформенные типы не добавляют дополнительных проверок в рантайме — они работают как обычные Java ссылки.
• Гибкость: разработчик сам решает, как интерпретировать значение — как nullable или non-null, в зависимости от контекста.

Как правильно обрабатывать платформенные типы?

Рекомендуется явно указывать тип при присваивании, особенно при работе с публичными API:

// Плохо: неявный платформенный тип
val result = javaMethod() // тип: SomeType!

// Хорошо: явно указываем nullable
val result: String? = javaMethod()
println(result?.length) // безопасно

// Или, если уверены, что не null:
val result: String = javaMethod() // вызовет NPE при null, но явно
println(result.length)

Аннотации JSR-305 и @Nullable/@NotNull

Современные Java библиотеки часто используют аннотации для указания null-статуса. Kotlin их распознает:

// Java с аннотациями
public class SafeService {
    @Nullable
    public String getNullable() { return null; }
    
    @NotNull
    public String getNotNull() { return "hello"; }
}

// Kotlin
val a: String? = SafeService().getNullable() // автоматически String?
val b: String = SafeService().getNotNull()   // автоматически String

Вывод: String! — это сигнал от компилятора: "я не знаю, может ли это быть null, будь осторожен". Всегда старайтесь явно приводить платформенные типы к String? или String при первом присваивании, чтобы сделать код предсказуемым.

// Утилита для безопасного приведения
fun <T> T?.orThrow(message: String): T {
    return this ?: throw NullPointerException(message)
}

// Использование
fun main() {
    val javaService = JavaService()
    
    // Вместо рискованного:
    val name1 = javaService.getName() // String!
    println(name1.length) // может упасть
    
    // Делаем так:
    val name2 = javaService.getName().orThrow("Name is null!")
    println(name2.length) // если null - понятная ошибка
    
    // Или используем Elvis-оператор с значением по умолчанию:
    val name3 = javaService.getName() ?: "default"
    println(name3.length) // всегда безопасно
}