Ako zabezpečiť bezpečnosť typov v Kotlin?

Bezpečnosť typov v Kotlin zabezpečuje počas kompilácie pomocou niekoľkých kľúčových mechanizmov:

1. Systém ne-null typov: Kotlin rozlišuje referenčné typy, ktoré môžu nadobúdať hodnotu null (označené s ? na konci názvu typu), a tie, ktoré nemôžu. Kompilátor vyžaduje explicitné kontroly na null alebo použitie bezpečných volaní (?.) a operátorov (?:, !!).

   // Referenčný typ, ktorý nemôže byť null
   val nonNullableString: String = "Hello"
   
   // Referenčný typ, ktorý môže byť null
   var nullableString: String? = "World"
   nullableString = null // Povolené
   
   // Chyba pri kompilácii: je potrebné ošetriť null
   // val length = nullableString.length
   
   // Bezpečné volanie
   val length: Int? = nullableString?.length
   
   // Elvis operátor
   val safeLength: Int = nullableString?.length ?: 0
   

2. Smart Casts: Kompilátor automaticky konvertuje typ premennej v blokoch if, when, while, for a ďalších výrazoch po kontrole typu alebo null.

   fun printLength(obj: Any) {
       if (obj is String) {
           // V tomto bloku, kompilátor vie, že obj je String
           println("Dĺžka Stringu je ${obj.length}")
       }
   }
   
   fun processNullableString(str: String?) {
       if (str != null) {
           // V tomto bloku, kompilátor vie, že str nie je null
           println("String nie je null, dĺžka je ${str.length}")
       }
   }
   

3. Generické typy: Kotlin podporuje generiká, ktoré umožňujú vytváranie tried, rozhraní a funkcií pracujúcich s rôznymi typmi, zabezpečujúcich typovú bezpečnosť počas kompilácie.

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

4. Kovariencia (out) a kontraviencia (in): Umožňujú upresniť, ako môžu byť podtypy používané v univerzálnych typoch, čím sa predchádza chybám nekompatibility typov počas kompilácie.

   interface Source<out T> {
       fun nextT(): T
       // fun consumeT(t: T) // Chyba pri kompilácii
   }
   
   interface Sink<in T> {
       // fun produceT(): T // Chyba pri kompilácii
       fun consumeT(t: T)
   }
   

5. Sealed triedy: Predstavujú obmedzenú hierarchiu tried, kde sú všetky podtriedy známe počas kompilácie. To umožňuje kompilátoru kontrolovať úplnosť výrazov when s podtriedami sealed triedy, zabezpečujúc spracovanie všetkých možných prípadov.

   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("Dáta: ${result.data}")
           is Result.Error -> println("Chyba: ${result.code}")
           // Bez 'else', kompilátor garantuje spracovanie všetkých podtried sealed
       }
   }
   

Tieto mechanizmy spolupracujú, umožňujúc odhalenie mnohých potenciálnych chýb súvisiacich s typmi v ranom štádiu vývoja, ešte pred spustením aplikácie.