Kotlin Academy · Lekcja

Funkcje i klasy generyczne

Parametryzuj typy

Funkcje i klasy generyczne to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Czym są typy generyczne?

Typy generyczne pozwalają pisać kod działający z wieloma typami przy zachowaniu pełnego bezpieczeństwa typów. Zamiast ustalać konkretny typ używa się parametru typu, często T, jako symbolu zastępczego.

Funkcja generyczna

Funkcja generyczna deklaruje parametr typu w nawiasach ostrych przed nazwą funkcji. W tym przypadku T może być dowolnym typem.

fun <T> identity(value: T): T {
    return value
}

fun main() {
    println(identity(42))
    println(identity("hello"))
}

Wnioskowanie typu

Zazwyczaj nie trzeba jawnie określać typu — kompilator wnioskuje T na podstawie argumentów. W razie potrzeby można jednak zapisać typ jawnie, na przykład jako identity<Int>(42).

fun <T> firstOf(a: T, b: T): T = a

fun main() {
    val x = firstOf(10, 20)
    val y = firstOf("a", "b")
    println("$x $y")
}

Wiele parametrów typu

Funkcja może mieć kilka parametrów typu, co jest przydatne podczas pracy z parami niezależnych typów.

fun <A, B> makePair(first: A, second: B): Pair<A, B> {
    return Pair(first, second)
}

fun main() {
    val p = makePair("age", 30)
    println(p)
}

Klasa generyczna

Klasy również mogą być generyczne. Parametr typu deklaruje się za nazwą klasy, a następnie można go używać we właściwościach i funkcjach.

class Box<T>(val value: T) {
    fun get(): T = value
}

fun main() {
    val intBox = Box(123)
    val strBox = Box("Kotlin")
    println(intBox.get())
    println(strBox.get())
}

Klasa generyczna z zachowaniem

Klasy generyczne mogą przechowywać zmienny stan i wykonywać operacje na parametrze typu, podobnie jak prosty kontener.

class Stack<T> {
    private val items = mutableListOf<T>()
    fun push(item: T) { items.add(item) }
    fun pop(): T = items.removeAt(items.size - 1)
    fun isEmpty() = items.isEmpty()
}

fun main() {
    val stack = Stack<Int>()
    stack.push(1)
    stack.push(2)
    println(stack.pop())
}

Interfejsy generyczne

Interfejsy również mogą deklarować parametry typu, pozwalając implementacjom wybrać konkretny typ.

interface Container<T> {
    fun item(): T
}

class StringContainer : Container<String> {
    override fun item(): String = "fixed"
}

fun main() {
    println(StringContainer().item())
}

Dlaczego nie użyć po prostu Any?

Wartości można przechowywać jako Any, ale wtedy traci się informacje o typie i trzeba używać rzutowań. Typy generyczne zachowują dokładny typ, dzięki czemu kompilator wykrywa błędy i nie są potrzebne rzutowania.

fun main() {
    val box: Box<String> = Box("text")
    val s: String = box.get()
    println(s.uppercase())
}

class Box<T>(val value: T) { fun get(): T = value }

Generyczne funkcje rozszerzające

Funkcje rozszerzające mogą być generyczne, co pozwala tworzyć narzędzia wielokrotnego użytku dla wszystkich typów.

fun <T> T.printAndReturn(): T {
    println("Value: $this")
    return this
}

fun main() {
    val x = 5.printAndReturn()
    "hi".printAndReturn()
    println(x)
}

Konwencje nazewnictwa

Zgodnie z konwencją parametry typu nazywa się pojedynczymi wielkimi literami: T oznacza typ generyczny, E element, K i V klucze oraz wartości mapy, a R wynik.

Typy generyczne są wszędzie

Biblioteka standardowa Kotlin opiera się na typach generycznych: List<T>, Map<K, V>, Pair<A, B>. Zrozumienie typów generycznych pomaga swobodnie czytać te typy i z nich korzystać.

Szybkie sprawdzenie

Jaka jest główna korzyść z używania typów generycznych w porównaniu z użyciem Any?

Podsumowanie

Typy generyczne wykorzystują parametry typu, takie jak T, aby umożliwiać tworzenie wielokrotnego użytku, bezpiecznych typowo funkcji, klas i interfejsów. Kompilator wnioskuje typy i wymusza bezpieczeństwo, eliminując potrzebę rzutowań. Następnie zostanie omówione kontrolowanie relacji między typami generycznymi za pomocą wariancji w miejscu deklaracji z użyciem in i out.

Często zadawane pytania

Czy lekcja „Funkcje i klasy generyczne” jest bezpłatna?

Tak — pełny tekst „Funkcje i klasy generyczne” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Funkcje i klasy generyczne”?

Parametryzuj typy Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Funkcje i klasy generyczne”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Kotlin Academy