Ինչպես աշխատել ընդհանուր տիպերի հետ Kotlin-ում…

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

Հիմնական հասկացությունները և աշխատանքային մեթոդները՝

Կոնկրետ դասեր և ինտերֆեյսներ հայտարարելը:

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)
}
```
- Ինվարիանտություն: Տիպը պետք է լինի նույնը։ Սա նախնական վարքագիծն է։

Տիպային սահմանափակումներ (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")
    }
}
```

Ինչպես աշխատել ընդհանուր տիպերի հետ Kotlin-ում?