როგორ მუშაობთ გენერიკულ ტიპებთან Kotlin-ში?

Kotlin-ෙහි පොදු වර්ග (generics) මගින් විවිධ වර්ග දත්ත සමඟ ක්‍රියාකාරීත්වය ඇති පන්තියන්, අතුරුමුහුණත් සහ ක්‍රියාවලි නිර්මාණය කළ හැකිය, එමෙන්ම සම්පාදක කාලයේ වර්ග ආරක්ෂාව රඳා පවතී.

ප්‍රධාන අදහස් සහ ක්‍රියාකාරකම්:

• පොදු පන්තියන් සහ අතුරුමුහුණත් ප්‍රකාශ කිරීම:

  class Box<T>(val item: T) // T වර්ග පරාමිතිය සමඟ පොදු පන්තිය
  interface MyList<E> { // E වර්ග පරාමිතිය සමඟ පොදු අතුරුමුහුණත
      fun add(element: E)
      fun get(index: Int): E
  }
  

• පොදු ක්‍රියාවලි ප්‍රකාශ කිරීම:

  fun <T> printAnything(value: T) { // T වර්ග පරාමිතිය සමඟ පොදු ක්‍රියාවලිය
      println(value)
  }
  

• පොදු වර්ග ආදර්ශන නිර්මාණය:

  val intBox: Box<Int> = Box(123) // නියමිත වර්ගය (Int)
  val stringBox = Box("hello") // සංඛ්‍යාතය (String) ලෙස ප්‍රකාශිත වේ
  

• විකල්පතා: වර්ග හා එහි උප වර්ග ක්‍රියාකාරකම් නිර්ණය කිරීමට ඉඩ සලසයි.
  • සහකාර (out): වර්ගය සහ එහි උප වර්ග භාවිතා කිරීමට ඉඩ සලසයි. out ලෙස සලකයි. උදාහරණයක් ලෙස: List<out Any> List<String> අඩංගු කළ හැකිය. මෙය වර්ග සඳහා භාවිතා වේ, එවැනි වර්ග, අගයන් නිෂ්පාදනය කරයි (උදා: එකතුවකින් කියවීම).

    interface Producer<out T> { // out T - සහකාර පරාමිතිය
         fun produce(): T
    }
    

  • විරුද්ධ (in): වර්ගය සහ එහි ඉහළ වර්ග භාවිතා කිරීමට ඉඩ සලසයි. in ලෙස සලකයි. උදාහරණයක් ලෙස: Comparator<in String> Comparator<Any> සමඟ වැඩ කළ හැකිය. මෙය වර්ග, අගයන් භාවිතා කරයි (උදා: එකතුවකට ලිවීම).

    interface Consumer<in T> { // in T - විරුද්ධ පරාමිතිය
        fun consume(value: T)
    }
    

  • අවිනිශ්චිත (invariance): වර්ගය, පොදු වර්ග පරාමිතිය තුළ, නිවැරදිව එකම විය යුතුය. මෙය පෙරනිමි හැසිරීමයි.
• වර්ග සීමා (where): වර්ග පරාමිතිය, නියමිත අතුරුමුහුණත් ක්‍රියාත්මක කළ යුතු හෝ නියමිත පන්තියකින් උරුම විය යුතු බව සීමා කරයි.

  fun <T : Comparable<T>> max(a: T, b: T): T { // T, Comparable ක්‍රියාත්මක කළ යුතු
      return if (a > b) a else b
  }
  
  fun <T> process(item: T) where T : Runnable, T : Comparable<T> {
      item.run()
      // ... සසඳීම භාවිතා කරයි
  }
  

• තාරකාව (star) ප්‍රතිරූපණය (*): විශේෂිත වර්ග අගයන් වැදගත් නොවන විට භාවිතා වේ. Java හි <?> සමඟ සමාන:

  fun printList(list: List<*>) { // ඕනෑම වර්ගයක ලැයිස්තුවක් ගන්න
       for (item in list) {
           println(item)
       }
  }
  

Kotlin හි පොදු වර්ග, වර්ග අහෝසි කිරීම (type erasure) භාවිතා කරයි, Java සමඟ සමානව. නියමිත වර්ග තොරතුරු, ක්‍රියාත්මක කාලයේ අහිමි වේ. ක්‍රියාත්මක කාලයේ වර්ග සමඟ වැඩ කිරීමට reified වර්ග භාවිතා වේ:

• Reified වර්ග (reified): inline ක්‍රියාවලි සඳහා පමණක් ලබා ගත හැකිය. ක්‍රියාත්මක කාලයේ වර්ග තොරතුරු රඳා පවතී:

  inline fun <reified T> checkType(value: Any) { // T - reified වර්ගය
      if (value is T) {
          println("Value is of type T")
      } else {
          println("Value is not of type T")
      }
  }