Что означает восклицательный знак в Kotlin и как от него избавиться?

Что такое тип с восклицательным знаком в Kotlin?

Тип String! (с восклицательным знаком) — это платформенный тип (platform type). Он возникает при взаимодействии Kotlin-кода с Java-кодом, когда Kotlin не может определить, может ли Java-метод вернуть null или нет. Это не настоящий тип Kotlin, а лишь подсказка IDE.

Почему он появляется?

Kotlin строго различает nullable (String?) и non-null (String) типы. Но Java не имеет такой аннотации. Когда Kotlin вызывает Java-метод без аннотаций @Nullable/@NotNull, он создаёт платформенный тип T!, означающий: «Я не знаю, может ли это быть null, решай сам».

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

Есть три стратегии, от лучшей к худшей:

• Явно указать nullable тип — если есть вероятность null:

val name: String? = service.name  // безопасно
println(name?.length ?: 0)        // элвис-оператор
// или
name?.let { println(it.length) }  // безопасный вызов

• Явно указать non-null тип — если вы уверены, что null не будет:

val name: String = service.name!!  // утверждение not-null
println(name.length)                // рискуем NPE, если ошиблись

• Использовать smart cast — проверить перед использованием:

val name = service.name  // тип String! (платформенный)
if (name != null) {
    println(name.length)  // автоматически приведено к String
} else {
    println("Name is null")
}

Как избавиться от восклицательного знака?

Есть несколько способов:

1. Добавить аннотации в Java-код (рекомендуется):

// Java
import org.jetbrains.annotations.Nullable;
public class UserService {
    @Nullable
    public String getName() { return null; }
}

Тогда в Kotlin тип будет String?.

2. Использовать Kotlin-обёртку для Java-класса:

// Kotlin-файл
fun UserService.safeName(): String? = this.name  // тип String?

3. Настроить компилятор — включить строгий режим для платформенных типов:

// В build.gradle.kts
kotlin {
    compilerOptions {
        freeCompilerArgs.add("-Xstrict-java-nullability-assertions")
    }
}

Тогда Kotlin будет требовать явного указания nullable/non-null при присваивании.

Почему нельзя просто игнорировать?

Платформенные типы — основная причина NPE в Kotlin при работе с Java. Если вы напишете:

val name = service.name  // тип String!
println(name.length)     // может упасть с NPE

Компилятор не предупредит, потому что он «доверяет» Java. Всегда явно указывайте тип или используйте безопасные вызовы.

Итог

Восклицательный знак — это не синтаксис Kotlin, а подсказка IDE. В реальном коде вы работаете с nullable-типами. Лучшая практика — либо добавить аннотации в Java, либо всегда обрабатывать как String?. Никогда не полагайтесь на то, что «этот метод точно не вернёт null» — Java-код может измениться.

// Файл: JavaSafe.kt
fun <T> T?.orThrow(message: String = "Value is null"): T {
    return this ?: throw NullPointerException(message)
}

// Использование
val name = service.name.orThrow("Name from UserService is null")
println(name.length)  // безопасно, но упадёт с понятной ошибкой

inline fun <T, R> T?.ifNull(default: R, block: (T) -> R): R {
    return this?.let(block) ?: default
}

// Пример
val length = service.name.ifNull(0) { it.length }
println(length)  // 0 если null, иначе длина строки

inline fun <T, R> T?.logIfNull(tag: String, default: R, block: (T) -> R): R {
    return this?.let(block) ?: run {
        Log.w(tag, "Unexpected null value")
        default
    }
}