Kako osigurati sigurnost tipova u Kotlinu?

Bezbednost tipova u Kotlinu obezbeđuje se na fazi kompajliranja pomoću nekoliko ključnih mehanizama:

1. Sistem ne-null tipova: Kotlin razlikuje referentne tipove koji mogu prihvatiti vrednost null (označene sa ? na kraju imena tipa) i one koji ne mogu. Kompajler zahteva eksplicitne provere na null ili korišćenje sigurnih poziva (?.) i operatora (?:, !!).

   // Referentni tip koji ne može biti null
   val nonNullableString: String = "Hello"
   
   // Referentni tip koji može biti null
   var nullableString: String? = "World"
   nullableString = null // Dozvoljeno
   
   // Greška pri kompajliranju: potrebna obrada null
   // val length = nullableString.length
   
   // Siguran poziv
   val length: Int? = nullableString?.length
   
   // Elvis operator
   val safeLength: Int = nullableString?.length ?: 0
   

2. Pametne kastovanje (Smart Casts): Kompajler automatski prebacuje tip promenljive unutar blokova if, when, while, for i drugih izraza nakon provere tipa ili null.

   fun printLength(obj: Any) {
       if (obj is String) {
           // Unutar ovog bloka, kompajler zna da je obj String
           println("Dužina Stringa je ${obj.length}")
       }
   }
   
   fun processNullableString(str: String?) {
       if (str != null) {
           // Unutar ovog bloka, kompajler zna da str nije null
           println("String nije null, dužina je ${str.length}")
       }
   }
   

3. Generički tipovi: Kotlin podržava generičke tipove, koji omogućavaju kreiranje klasa, interfejsa i funkcija koje rade sa različitim tipovima, obezbeđujući sigurnost tipova tokom kompajliranja.

   class Box<T>(val item: T)
   
   fun printItem(box: Box<String>) {
       // Kompajler zna da je item String
       println(box.item.uppercase())
   }
   

4. Kovarijantnost (out) i kontravariantnost (in): Omogućavaju preciziranje kako podtipovi mogu biti korišćeni u univerzalnim tipovima, sprečavajući greške u neusklađenosti tipova tokom kompajliranja.

   interface Source<out T> {
       fun nextT(): T
       // fun consumeT(t: T) // Greška pri kompajliranju
   }
   
   interface Sink<in T> {
       // fun produceT(): T // Greška pri kompajliranju
       fun consumeT(t: T)
   }
   

5. Sealed klase: Predstavljaju ograničenu hijerarhiju klasa, gde su sve podklase poznate tokom kompajliranja. Ovo omogućava kompajleru da proveri potpunost izraza when sa podklasama sealed klase, obezbeđujući obradu svih mogućih slučajeva.

   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("Podaci: ${result.data}")
           is Result.Error -> println("Greška: ${result.code}")
           // Bez 'else', kompajler garantuje obradu svih podklasa Sealed
       }
   }
   

Ovi mehanizmi rade zajedno, omogućavajući otkrivanje mnogih potencijalnih grešaka povezanih sa tipovima u ranoj fazi razvoja, pre pokretanja aplikacije.