Ինչպես ապահովել տիպերի անվտանգությունը Kotlin-ում?

Տիպերի անվտանգությունը Kotlin-ում ապահովվում է մի քանի հիմնական մեխանիզմների միջոցով՝

1. Տիպերի ոչ-null համակարգ: Kotlin-ը տարբերակում է ռեֆերենցիոն տիպերը, որոնք կարող են ընդունել null արժեք (նշված ? վերջում տիպի անվան), և այն տիպերը, որոնք չեն կարող։ Կոմպիլատորը պահանջում է բացահայտ null ստուգումներ կամ անվտանգ կանչեր (?.) և օպերատորներ (?:, !!)։

   // Տիպ, որը չի կարող լինել null
   val nonNullableString: String = "Hello"
   
   // Տիպ, որը կարող է լինել null
   var nullableString: String? = "World"
   nullableString = null // թույլատրվում է
   
   // Կոմպիլատորային սխալ՝ null-ի մշակումը պահանջվում է
   // val length = nullableString.length
   
   // Անվտանգ կանչ
   val length: Int? = nullableString?.length
   
   // Elvis օպերատոր
   val safeLength: Int = nullableString?.length ?: 0
   

2. Խելացի կասթինգներ (Smart Casts): Կոմպիլատորը ավտոմատ կերպով փոխում է փոփոխականի տիպը if, when, while, for և այլ արտահայտություններում՝ տիպի կամ null ստուգումից հետո։

   fun printLength(obj: Any) {
       if (obj is String) {
           // Այս բլոկում, կոմպիլատորը գիտի, որ obj-ը String է
           println("String-ի երկարությունը ${obj.length}")
       }
   }
   
   fun processNullableString(str: String?) {
       if (str != null) {
           // Այս բլոկում, կոմպիլատորը գիտի, որ str-ը null չէ
           println("String-ը ոչ null է, երկարությունը ${str.length}")
       }
   }
   

3. Գեներիկ տիպեր: Kotlin-ը աջակցում է գեներիկներին, որոնք թույլ են տալիս ստեղծել դասեր, ինտերֆեյսներ և ֆունկցիաներ՝ աշխատելու տարբեր տիպերի հետ՝ ապահովելով տիպային անվտանգություն՝ կոմպիլյացիայի ժամանակ։

   class Box<T>(val item: T)
   
   fun printItem(box: Box<String>) {
       // Կոմպիլատորը գիտի, որ item-ը String է
       println(box.item.uppercase())
   }
   

4. Կովարիանտություն (out) և հակակովարիանտություն (in): Դրանք թույլ են տալիս հստակեցնել, թե ինչպես կարող են ենթատիպերը օգտագործվել ընդհանուր տիպերում՝ կանխելով տիպային անհամատեղելիության սխալները՝ կոմպիլյացիայի ժամանակ։

   interface Source<out T> {
       fun nextT(): T
       // fun consumeT(t: T) // Կոմպիլյացիայի սխալ
   }
   
   interface Sink<in T> {
       // fun produceT(): T // Կոմպիլյացիայի սխալ
       fun consumeT(t: T)
   }
   

5. Sealed դասեր: Ներկայացնում են սահմանափակ հիերարխիա, որտեղ բոլոր ենթակլասները հայտնի են կոմպիլյացիայի ժամանակ։ Սա թույլ է տալիս կոմպիլյատորին ստուգել when արտահայտությունների ամբողջականությունը՝ sealed դասի ենթակլասների հետ՝ ապահովելով բոլոր հնարավոր դեպքերի մշակումը։

   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("Տվյալներ: ${result.data}")
           is Result.Error -> println("Սխալ: ${result.code}")
           // Բացակայում է `else`, կոմպիլյատորը երաշխավորում է բոլոր ենթակլասների մշակումը
       }
   }
   

Այս մեխանիզմները միասին թույլ են տալիս վաղ փուլում հայտնաբերել բազմաթիվ հնարավոր սխալներ՝ կապված տիպերի հետ՝ նախքան հավելվածի գործարկումը։