Jak zajistit bezpečnost typů v Kotlinu?

Typová bezpečnost v Kotlinu je zajištěna během kompilace pomocí několika klíčových mechanismů:

1. Systém ne-nullových typů: Kotlin rozlišuje referenční typy, které mohou nabývat hodnoty null (označované ? na konci názvu typu), a ty, které nemohou. Kompilátor vyžaduje explicitní kontroly na null nebo použití bezpečných volání (?.) a operátorů (?:, !!).

   // Referenční typ, který nemůže být null
   val nonNullableString: String = "Hello"
   
   // Referenční typ, který může být null
   var nullableString: String? = "World"
   nullableString = null // Povolené
   
   // Chyba při kompilaci: je třeba ošetřit null
   // val length = nullableString.length
   
   // Bezpečné volání
   val length: Int? = nullableString?.length
   
   // Elvis operátor
   val safeLength: Int = nullableString?.length ?: 0
   

2. Chytré přetypování (Smart Casts): Kompilátor automaticky převádí typ proměnné uvnitř bloků if, when, while, for a dalších výrazů po kontrole typu nebo null.

   fun printLength(obj: Any) {
       if (obj is String) {
           // Uvnitř tohoto bloku kompilátor ví, že obj je String
           println("Délka řetězce je ${obj.length}")
       }
   }
   
   fun processNullableString(str: String?) {
       if (str != null) {
           // Uvnitř tohoto bloku kompilátor ví, že str není null
           println("Řetězec není null, délka je ${str.length}")
       }
   }
   

3. Generické typy: Kotlin podporuje generika, která umožňují vytvářet třídy, rozhraní a funkce pracující s různými typy, zajišťující typovou bezpečnost během kompilace.

   class Box<T>(val item: T)
   
   fun printItem(box: Box<String>) {
       // Kompilátor ví, že item je String
       println(box.item.uppercase())
   }
   

4. Kovarience (out) a kontravariance (in): Umožňují upřesnit, jak mohou být podtypy používány v univerzálních typech, čímž se předchází chybám neslučitelnosti typů během kompilace.

   interface Source<out T> {
       fun nextT(): T
       // fun consumeT(t: T) // Chyba při kompilaci
   }
   
   interface Sink<in T> {
       // fun produceT(): T // Chyba při kompilaci
       fun consumeT(t: T)
   }
   

5. Sealed třídy: Představují omezenou hierarchii tříd, kde jsou všechny podtřídy známy během kompilace. To umožňuje kompilátoru kontrolovat úplnost výrazů when s podtřídami sealed třídy, zajišťující zpracování všech možných případů.

   sealed class Result {
       data class Success(val data: String) : Result()
       data class Error(val code: Int) : Result()
   }
   
   fun handleResult(result: Result) {
       when (result) {
           is Result.Success -> println("Data: ${result.data}")
           is Result.Error -> println("Chyba: ${result.code}")
           // Bez 'else' zaručuje kompilátor zpracování všech podtříd sealed třídy
       }
   }
   

Tyto mechanismy spolupracují, umožňují odhalit mnoho potenciálních chyb souvisejících s typy již v rané fázi vývoje, před spuštěním aplikace.