Kotlin Academy · บทเรียน

ข้อจำกัดของเจเนอริก

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

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

การจำกัดพารามิเตอร์ชนิดข้อมูล

บางครั้งชนิดข้อมูลทั่วไปต้องรับเฉพาะชนิดข้อมูลบางประเภท เช่น ชนิดข้อมูลที่เปรียบเทียบกันได้ หรือชนิดข้อมูลที่สืบทอดจากชนิดข้อมูลพื้นฐาน ข้อจำกัดของชนิดข้อมูลทั่วไปใช้กำหนดขอบเขตบนให้กับพารามิเตอร์ชนิดข้อมูล

ขอบเขตบนเริ่มต้น

หากไม่มีข้อจำกัด ขอบเขตบนของพารามิเตอร์ชนิดข้อมูลจะเป็น Any? ดังนั้นจึงรับชนิดข้อมูลใดก็ได้ รวมถึงชนิดข้อมูลที่เป็นค่าว่างได้ หากต้องการให้รับเฉพาะชนิดข้อมูลที่ไม่เป็นค่าว่าง ให้กำหนดขอบเขตเป็น Any

fun <T : Any> requireNonNull(value: T): T {
    return value
}

fun main() {
    println(requireNonNull(42))
}

ขอบเขตบนเดียว

ใช้ T : Bound เพื่อกำหนดให้ T เป็นชนิดข้อมูลย่อยของ Bound วิธีนี้ทำให้คุณเรียกสมาชิกของขอบเขตนั้นภายในฟังก์ชันได้

fun <T : Number> sumDoubled(a: T, b: T): Double {
    return a.toDouble() * 2 + b.toDouble() * 2
}

fun main() {
    println(sumDoubled(3, 4))
    println(sumDoubled(1.5, 2.5))
}

ขอบเขตแบบเปรียบเทียบได้

ขอบเขตที่ใช้บ่อยคือ Comparable<T> ซึ่งทำให้คุณเปรียบเทียบสมาชิกด้วย <, > หรือ compareTo ได้

fun <T : Comparable<T>> maxOf2(a: T, b: T): T {
    return if (a > b) a else b
}

fun main() {
    println(maxOf2(3, 9))
    println(maxOf2("apple", "banana"))
}

การเรียกสมาชิกของขอบเขต

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

fun <T : CharSequence> describe(value: T): String {
    return "Length is ${value.length}"
}

fun main() {
    println(describe("hello"))
    println(describe(StringBuilder("hi")))
}

หลายขอบเขตด้วยเงื่อนไขกำหนดขอบเขต

หากมีขอบเขตมากกว่าหนึ่งขอบเขต ให้ใช้ส่วนคำสั่ง where จากนั้น T จะต้องเป็นไปตามข้อจำกัดทั้งหมดที่ระบุไว้ใน ALL

fun <T> copyWhenValid(value: T): T
    where T : CharSequence, T : Comparable<T> {
    return value
}

fun main() {
    println(copyWhenValid("text"))
}

ขอบเขตของคลาส

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

class NumberBox<T : Number>(val value: T) {
    fun asDouble(): Double = value.toDouble()
}

fun main() {
    val box = NumberBox(10)
    println(box.asDouble())
}

ข้อจำกัดทำให้ใช้การดำเนินการได้

จุดประสงค์หลักของข้อจำกัดคือการเปิดให้ใช้การดำเนินการต่าง ๆ ได้ หากไม่มี T : Number คุณจะเรียก toDouble() ไม่ได้ เพราะขอบเขตนี้รับรองว่ามีเมธอดดังกล่าวอยู่

ขอบเขตที่ไม่เป็นค่าว่างในการใช้งานจริง

การกำหนดขอบเขตเป็น Any จะปฏิเสธอาร์กิวเมนต์ที่เป็นค่าว่างตั้งแต่เวลาคอมไพล์ ซึ่งเป็นวิธีที่สะดวกในการบังคับให้ชนิดข้อมูลทั่วไปไม่เป็นค่าว่าง

fun <T : Any> firstNonNull(a: T, b: T): T = a

fun main() {
    println(firstNonNull("x", "y"))
    // firstNonNull(null, "y") would not compile
}

การใช้ร่วมกับความแปรผัน

ข้อจำกัดและความแปรผันแก้ปัญหาคนละด้าน: ความแปรผัน (in/out) ควบคุมความสัมพันธ์ของชนิดข้อมูลย่อย ส่วนข้อจำกัด (ขอบเขตด้วย : และ where) จำกัดชนิดข้อมูลที่อนุญาต ทั้งสองอย่างใช้ร่วมกันได้

การออกแบบข้อจำกัดที่ดี

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

ตรวจสอบความเข้าใจ

คุณจะกำหนดให้พารามิเตอร์ชนิดข้อมูลเป็นไปตามขอบเขตมากกว่าหนึ่งขอบเขตได้อย่างไร

สรุป

ข้อจำกัดของชนิดข้อมูลทั่วไปกำหนดขอบเขตบนด้วย T : Bound (หรือใช้ where สำหรับหลายขอบเขต) ซึ่งเปิดให้ใช้การดำเนินการของขอบเขตและป้องกันชนิดข้อมูลที่เข้ากันไม่ได้ การกำหนดขอบเขตเป็น Any จะบังคับให้ไม่เป็นค่าว่าง เมื่อใช้ร่วมกับความแปรผัน ข้อจำกัดจะช่วยให้คุณออกแบบชนิดข้อมูลทั่วไปที่ปลอดภัยและสื่อความหมายได้ดี บทเรียนชนิดข้อมูลทั่วไปและความแปรผันจบลงเพียงเท่านี้

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

บทเรียน “ข้อจำกัดของเจเนอริก” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “ข้อจำกัดของเจเนอริก”

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

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

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

บทเรียน “ข้อจำกัดของเจเนอริก” ใช้เวลานานแค่ไหน

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

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

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

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

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