Kotlin Academy · บทเรียน

ฟังก์ชันและคลาสแบบเจเนอริก

กำหนดชนิดข้อมูลด้วยพารามิเตอร์

ฟังก์ชันและคลาสแบบเจเนอริก เป็นบทเรียน Kotlin Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Kotlin Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

เจเนอริกส์คืออะไร

เจเนอริกส์ช่วยให้คุณเขียนโค้ดที่ทำงานกับชนิดข้อมูลได้หลายแบบพร้อมคงความปลอดภัยของชนิดข้อมูลไว้อย่างครบถ้วน แทนที่จะกำหนดชนิดข้อมูลเฉพาะตายตัว คุณจะใช้ พารามิเตอร์ชนิดข้อมูล ซึ่งมักเป็น T เป็นตัวแทน

ฟังก์ชันเจเนอริก

ฟังก์ชันเจเนอริกจะประกาศพารามิเตอร์ชนิดข้อมูลไว้ในวงเล็บแหลมก่อนชื่อฟังก์ชัน ในที่นี้ T สามารถเป็นชนิดข้อมูลใดก็ได้

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

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

การอนุมานชนิดข้อมูล

โดยทั่วไปคุณแทบไม่ต้องระบุชนิดข้อมูลอย่างชัดเจน เพราะคอมไพเลอร์จะอนุมาน T จากอาร์กิวเมนต์ อย่างไรก็ตาม หากจำเป็น คุณยังสามารถเขียนเป็น 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")
}

พารามิเตอร์ชนิดข้อมูลหลายตัว

ฟังก์ชันหนึ่งสามารถมีพารามิเตอร์ชนิดข้อมูลได้หลายตัว ซึ่งมีประโยชน์เมื่อต้องทำงานกับคู่ของชนิดข้อมูลที่ไม่เกี่ยวข้องกัน

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

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

คลาสเจเนอริก

คลาสก็สามารถเป็นเจเนอริกได้เช่นกัน พารามิเตอร์ชนิดข้อมูลจะประกาศไว้หลังชื่อคลาส และสามารถนำไปใช้กับคุณสมบัติและฟังก์ชันได้

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())
}

คลาสเจเนอริกที่มีพฤติกรรม

คลาสเจเนอริกสามารถเก็บสถานะที่เปลี่ยนแปลงได้และทำงานกับพารามิเตอร์ชนิดข้อมูล เช่น ตัวเก็บข้อมูลอย่างง่าย

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())
}

ส่วนติดต่อเจเนอริก

ส่วนติดต่อก็สามารถประกาศพารามิเตอร์ชนิดข้อมูลได้เช่นกัน ทำให้การนำไปใช้งานสามารถเลือกชนิดข้อมูลเฉพาะได้

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

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

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

ทำไมไม่ใช้ Any ไปเลย

คุณสามารถเก็บค่าเป็น Any ได้ แต่จะสูญเสียข้อมูลชนิดข้อมูลและต้องแปลงชนิดเอง เจเนอริกส์จะรักษาชนิดข้อมูลที่แน่นอนไว้ ทำให้คอมไพเลอร์ตรวจจับข้อผิดพลาดได้และไม่ต้องแปลงชนิด

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 }

ฟังก์ชันส่วนขยายเจเนอริก

ฟังก์ชันส่วนขยายสามารถเป็นเจเนอริกได้ ทำให้สร้างเครื่องมือที่นำกลับมาใช้ซ้ำกับชนิดข้อมูลทุกแบบได้

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

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

หลักการตั้งชื่อ

ตามธรรมเนียม ตัวอักษรพิมพ์ใหญ่เพียงตัวเดียวจะใช้ตั้งชื่อพารามิเตอร์ชนิดข้อมูล: T สำหรับชนิดข้อมูลเจเนอริก, E สำหรับองค์ประกอบ, K และ V สำหรับคีย์และค่าของแผนผัง และ R สำหรับผลลัพธ์

เจเนอริกส์อยู่ทุกที่

ไลบรารีมาตรฐานของ Kotlin สร้างขึ้นบนเจเนอริกส์: List<T>, Map<K, V>, Pair<A, B> การเข้าใจเจเนอริกส์จะช่วยให้คุณอ่านและใช้ชนิดข้อมูลเหล่านี้ได้อย่างมั่นใจ

ตรวจสอบอย่างรวดเร็ว

ประโยชน์หลักของเจเนอริกส์เมื่อเทียบกับการใช้ Any คืออะไร

ทบทวน

เจเนอริกส์ใช้พารามิเตอร์ชนิดข้อมูลอย่าง T เพื่อเขียนฟังก์ชัน คลาส และส่วนติดต่อที่นำกลับมาใช้ซ้ำได้และปลอดภัยด้านชนิดข้อมูล คอมไพเลอร์จะอนุมานชนิดข้อมูลและบังคับใช้ความปลอดภัย จึงไม่ต้องแปลงชนิด ต่อไปคุณจะควบคุมความสัมพันธ์ระหว่างชนิดข้อมูลเจเนอริกด้วยความแปรผัน ณ จุดประกาศ โดยใช้ in และ out

คำถามที่พบบ่อย

บทเรียน “ฟังก์ชันและคลาสแบบเจเนอริก” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “ฟังก์ชันและคลาสแบบเจเนอริก” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Kotlin Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Kotlin Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “ฟังก์ชันและคลาสแบบเจเนอริก”

กำหนดชนิดข้อมูลด้วยพารามิเตอร์ คุณปฏิบัติ Kotlin Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Kotlin Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Kotlin Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “ฟังก์ชันและคลาสแบบเจเนอริก” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Kotlin Academy นี้ได้ไหม

ได้ บทเรียน Kotlin Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Kotlin Academy