Hoe zorg je voor typeveiligheid in Kotlin?

Typeveiligheid in Kotlin wordt tijdens de compilatie verzekerd door verschillende kernmechanismen:

1. Niet-null type systeem: Kotlin onderscheidt referentietypen die de waarde null kunnen aannemen (aangeduid met ? aan het einde van de type naam) en die dat niet kunnen. De compiler vereist expliciete null-controles of het gebruik van veilige oproepen (?.) en operatoren (?:, !!).

   // Referentie die niet null kan zijn
   val nonNullableString: String = "Hello"
   
   // Referentie die null kan zijn
   var nullableString: String? = "World"
   nullableString = null // Toegestaan
   
   // Compileerfout: null-afhandeling vereist
   // val length = nullableString.length
   
   // Veilige oproep
   val length: Int? = nullableString?.length
   
   // Elvis-operator
   val safeLength: Int = nullableString?.length ?: 0
   

2. Slimme casts (Smart Casts): De compiler converteert automatisch het type van een variabele binnen if, when, while, for en andere expressies na controle op type of null.

   fun printLength(obj: Any) {
       if (obj is String) {
           // Binnen dit blok weet de compiler dat obj een String is
           println("String lengte is ${obj.length}")
       }
   }
   
   fun processNullableString(str: String?) {
       if (str != null) {
           // Binnen dit blok weet de compiler dat str niet null is
           println("String is niet null, lengte is ${str.length}")
       }
   }
   

3. Generieke types (Generics): Kotlin ondersteunt generics, waarmee je klassen, interfaces en functies kunt maken die met verschillende types werken en die typeveiligheid tijdens de compilatie garanderen.

   class Box<T>(val item: T)
   
   fun printItem(box: Box<String>) {
       // De compiler weet dat item van type String is
       println(box.item.uppercase())
   }
   

4. Covariantie (out) en contravariantie (in): Hiermee kan worden gespecificeerd hoe subtypes kunnen worden gebruikt in generieke types, waardoor incompatibiliteitsfouten tijdens de compilatie worden voorkomen.

   interface Source<out T> {
       fun nextT(): T
       // fun consumeT(t: T) // Compileerfout
   }
   
   interface Sink<in T> {
       // fun produceT(): T // Compileerfout
       fun consumeT(t: T)
   }
   

5. Sealed klassen: Vertegenwoordigen een beperkte hiërarchie van klassen, waarbij alle subklassen bekend zijn tijdens de compilatie. Dit stelt de compiler in staat om de volledigheid van when-uitdrukkingen met subklassen van sealed klassen te controleren, waardoor alle mogelijke gevallen worden afgehandeld.

   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("Fout: ${result.code}")
           // Zonder 'else' garandeert de compiler dat alle subklassen worden afgehandeld
       }
   }
   

Deze mechanismen werken samen, waardoor veel potentiële fouten gerelateerd aan types vroegtijdig kunnen worden opgespoord, nog voordat de applicatie wordt uitgevoerd.