Kā strādāt ar ģeneriskiem tipiem Kotlin?

Kotlin vispārīgie tipi ļauj izveidot klases, interfeisus un funkcijas, kas darbojas ar dažādu tipu datiem, vienlaikus saglabājot tipa drošību kompilēšanas laikā.

Galvenās jēdzieni un darba veidi:

• Vispārīgo klases un interfeisu deklarēšana:

  class Box<T>(val item: T) // Vispārīga klase ar tipu T
  interface MyList<E> { // Vispārīgs interfeiss ar tipu E
      fun add(element: E)
      fun get(index: Int): E
  }
  

• Vispārīgo funkciju deklarēšana:

  fun <T> printAnything(value: T) { // Vispārīga funkcija ar tipu T
      println(value)
  }
  

• Vispārīgu tipu piemēru izveide:

  val intBox: Box<Int> = Box(123) // Konkrēta tipa norādīšana (Int)
  val stringBox = Box("hello") // Kompilators automātiski nosaka tipu (String)
  

• Daudzveidība: Atļauj noteikt, kā darbojas apakštipi ar vispārīgiem tipiem.
  • Kovariantība (out): Atļauj izmantot tipu un tā apakštipus. Norādīts ar out. Piemērs: List<out Any> var saturēt List<String>. Izmanto tipu, kas ražo vērtības (piemēram, lasīšana no kolekcijas).

    interface Producer<out T> { // out T - kovariants parametrs
         fun produce(): T
    }
    

  • Kontravariantība (in): Atļauj izmantot tipu un tā pārstāvjus. Norādīts ar in. Piemērs: Comparator<in String> var strādāt ar Comparator<Any>. Izmanto tipu, kas patērē vērtības (piemēram, ieraksts kolekcijā).

    interface Consumer<in T> { // in T - kontravariants parametrs
        fun consume(value: T)
    }
    

  • Invarianta: Tipam vispārīgajā parametrā jābūt tieši tādam pašam. Šis ir noklusējuma uzvedība.
• Tipa ierobežojumi (where): Atļauj ierobežot tipa parametru, lai tas realizētu noteiktus interfeisus vai mantojas no noteiktas klases.

  fun <T : Comparable<T>> max(a: T, b: T): T { // T jāīsteno Comparable
      return if (a > b) a else b
  }
  
  fun <T> process(item: T) where T : Runnable, T : Comparable<T> {
      item.run()
      // ... izmanto salīdzināmību
  }
  

• Zvaigznītes (star) projekcija (*): Izmanto, kad konkrēti tipu argumenti nav svarīgi. Līdzīgi kā <?> Java.

  fun printList(list: List<*>) { // Var pieņemt jebkura tipa sarakstu
       for (item in list) {
           println(item)
       }
  }
  

Vispārīgie tipi Kotlin izmanto tipu iznīcināšanu (type erasure), tāpat kā Java. Informācija par konkrētiem tipu parametru veidiem tiek zaudēta darbības laikā. Lai strādātu ar tipiem darbības laikā, izmanto reificētus (reified) tipus.

• Reificētie tipi (reified): Pieejami tikai inline funkcijām. Ļauj saglabāt informāciju par tipu parametru darbības laikā.

  inline fun <reified T> checkType(value: Any) { // T - reificēts tips
      if (value is T) {
          println("Vērtība ir T tipa")
      } else {
          println("Vērtība nav T tipa")
      }
  }