Kotlin Bootcamp สําหรับโปรแกรมเมอร์ 5.1: ส่วนขยาย

Codelab นี้เป็นส่วนหนึ่งของหลักสูตร Kotlin Bootcamp สําหรับโปรแกรมเมอร์ คุณจะได้รับประโยชน์สูงสุดจากหลักสูตรนี้ หากทํางานผ่าน Codelab ตามลําดับ คุณอาจอ่านผ่านบางหัวข้อได้ ทั้งนี้ขึ้นอยู่กับความรู้ของคุณ หลักสูตรนี้มุ่งเน้นที่โปรแกรมเมอร์ที่มีความรู้เกี่ยวกับภาษาเชิงวัตถุและต้องการเรียนรู้ Kotlin

บทนำ

Codelab นี้จะแนะนําฟีเจอร์ที่เป็นประโยชน์มากมายใน Kotlin รวมทั้งฟังก์ชันคู่ คอลเล็กชัน และส่วนขยาย

แทนที่หลักสูตรนี้จะสร้างแอปตัวอย่างเดียว บทเรียนในหลักสูตรนี้ออกแบบมาเพื่อสร้างเสริมความรู้ แต่นักเรียนไม่ต้องพึ่งพากันและกันเพื่อให้คุณเข้าใจส่วนต่างๆ ที่คุณคุ้นเคย ตัวอย่างจํานวนมากใช้ธีมสัตว์น้ําร่วมกัน และอยากดูเรื่องราวเกี่ยวกับสัตว์น้ําทั้งหมด โปรดดูหลักสูตร Kotlin Bootcamp for Programmers Udacity

สิ่งที่ควรทราบอยู่แล้ว

  • ไวยากรณ์ของฟังก์ชัน คลาส และวิธีการของ Kotlin
  • วิธีทํางานกับ Kotlin' REPL (Read-Eval-Print Loop) ใน IntelliJ IDEA
  • วิธีสร้างชั้นเรียนใหม่ใน IntelliJ IDEA และเรียกใช้โปรแกรม

สิ่งที่คุณจะได้เรียนรู้

  • วิธีทํางานกับคู่รักและทริปเปิล
  • ข้อมูลเพิ่มเติมเกี่ยวกับคอลเล็กชัน
  • การกําหนดและการใช้ค่าคงที่
  • การเขียนฟังก์ชันส่วนขยาย

สิ่งที่คุณจะทํา

  • ดูข้อมูลเกี่ยวกับคู่ 3 รายการ และแฮชของแฮชใน REPL
  • ดูวิธีต่างๆ ในการจัดระเบียบค่าคงที่
  • เขียนฟังก์ชันส่วนขยายและพร็อพเพอร์ตี้ส่วนขยาย

ในงานนี้ คุณจะได้เรียนรู้เกี่ยวกับคู่รัก 3 คู่และการทําลายโครงสร้าง คู่และสามคนคือคลาสข้อมูลที่สร้างไว้ล่วงหน้าสําหรับรายการทั่วไป 2 หรือ 3 รายการ เช่น อาจเป็นประโยชน์ต่อการทําให้ฟังก์ชันส่งคืนค่ามากกว่า 1 ค่า

สมมติว่าคุณมีปลา List ตัว และใช้ฟังก์ชัน isFreshWater() เพื่อตรวจสอบว่าปลานั้นเป็นปลาน้ําจืดหรือปลาเค็ม List.partition() แสดงผล 2 รายการ โดยรายการหนึ่งมีเงื่อนไขเป็น true และอีกรายการมีสภาพสินค้าเป็น false

val twoLists = fish.partition { isFreshWater(it) }
println("freshwater: ${twoLists.first}")
println("saltwater: ${twoLists.second}")

ขั้นตอนที่ 1: สร้างบางคู่และสามส่วน

  1. เปิด REPL (เครื่องมือ > Kotlin > Kotlin REPL)
  2. สร้างคู่ชื่อการเชื่อมโยงอุปกรณ์กับอุปกรณ์ที่ใช้ แล้วพิมพ์ค่า คุณสามารถสร้างการจับคู่ด้วยการสร้างนิพจน์ที่เชื่อมโยง 2 ค่า เช่น สตริง 2 คีย์เวิร์ดด้วยคีย์เวิร์ด to แล้วใช้ .first หรือ .second เพื่ออ้างถึงแต่ละค่า
val equipment = "fish net" to "catching fish"
println("${equipment.first} used for ${equipment.second}")
⇒ fish net used for catching fish
  1. สร้าง Triple และพิมพ์ด้วย toString() และแปลงเป็นรายการที่มี toList() คุณสร้างสามครั้งโดยใช้ Triple() โดยมี 3 ค่า ใช้ .first, .second และ .third เพื่ออ้างถึงแต่ละค่า
val numbers = Triple(6, 9, 42)
println(numbers.toString())
println(numbers.toList())
⇒ (6, 9, 42)
[6, 9, 42]

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

  1. สร้างคู่โดยส่วนแรกของคู่คือคู่
val equipment2 = ("fish net" to "catching fish") to "equipment"
println("${equipment2.first} is ${equipment2.second}\n")
println("${equipment2.first.second}")
⇒ (fish net, catching fish) is equipment
⇒ catching fish

ขั้นตอนที่ 2: ทําลายบางคู่และสามครั้ง

การแยกคู่และสามส่วนออกเป็นหลายส่วนเรียกว่าการทําลาย กําหนดคู่หรือสามเท่าของจํานวนตัวแปรที่เหมาะสม และ Kotlin จะกําหนดค่าของแต่ละส่วนตามลําดับ

  1. ทําลายคู่และพิมพ์ค่า
val equipment = "fish net" to "catching fish"
val (tool, use) = equipment
println("$tool is used for $use")
⇒ fish net is used for catching fish
  1. การทําลายสามครั้งและพิมพ์ค่า
val numbers = Triple(6, 9, 42)
val (n1, n2, n3) = numbers
println("$n1 $n2 $n3")
⇒ 6 9 42

โปรดทราบว่าการทําลายคู่และทริปเปิลจะทํางานเหมือนกับคลาสข้อมูล ซึ่งจะกล่าวถึงใน Codelab ก่อนหน้า

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

ขั้นตอนที่ 1: ดูข้อมูลเพิ่มเติมเกี่ยวกับรายการ

  1. เราได้เปิดตัวรายการและรายการที่เปลี่ยนแปลงได้ในบทเรียนก่อนหน้านี้ และเป็นโครงสร้างข้อมูลที่มีประโยชน์มาก Kotlin มีฟังก์ชันในตัวมากมายสําหรับรายการ ตรวจสอบรายการฟังก์ชันบางส่วนสําหรับรายการ โปรดดูข้อมูลทั้งหมดในเอกสารประกอบของ Kotlin สําหรับ List และ MutableList

ฟังก์ชัน

วัตถุประสงค์

add(element: E)

เพิ่มสิ่งของลงในรายการที่แก้ไขได้

remove(element: E)

นํารายการออกจากรายการที่เปลี่ยนแปลงได้

reversed()

แสดงสําเนาของรายการที่มีองค์ประกอบในลําดับที่ย้อนกลับ

contains(element: E)

แสดงผล true หากรายการมีรายการดังกล่าว

subList(fromIndex: Int, toIndex: Int)

แสดงผลส่วนของรายการ ตั้งแต่ดัชนีแรกไปจนถึงแต่ไม่รวมดัชนีที่ 2

  1. หากยังทํางานใน REPL อยู่ ให้สร้างรายการหมายเลขโทรศัพท์และโทรหา sum() หมายเลขนั้น การดําเนินการนี้จะสรุปองค์ประกอบทั้งหมด
val list = listOf(1, 5, 3, 4)
println(list.sum())
⇒ 13
  1. สร้างรายการสตริงและรวมรายการ
val list2 = listOf("a", "bbb", "cc")
println(list2.sum())
⇒ error: none of the following functions can be called with the arguments supplied:
  1. หากองค์ประกอบไม่ใช่อย่างที่ List รู้เกี่ยวกับวิธีผลรวมโดยตรง เช่น สตริง คุณสามารถระบุวิธีรวมค่านั้นด้วย .sumBy() ด้วยฟังก์ชันแลมบ์ดา เช่น เพื่อคูณความยาวของแต่ละสตริง ชื่อเริ่มต้นสําหรับอาร์กิวเมนต์แลมบ์ดาคือ it และ it จะหมายถึงแต่ละองค์ประกอบของรายการเมื่อติดตามผ่านรายการ
val list2 = listOf("a", "bbb", "cc")
println(list2.sumBy { it.length })
⇒ 6
  1. ยังมีขั้นตอนอื่นๆ อีกมากมายที่คุณทําได้ด้วยรายการ วิธีหนึ่งในการดูฟังก์ชันที่ใช้ได้คือ สร้างรายการใน IntelliJ IDEA เพิ่มจุด จากนั้นดูรายการการเติมข้อมูลอัตโนมัติในเคล็ดลับเครื่องมือ โดยใช้ได้กับทุกออบเจ็กต์ ลองใช้งานดู

  1. ให้เลือก listIterator() จากรายการ แล้วดูรายการด้วยคําสั่ง for แล้วพิมพ์องค์ประกอบทั้งหมดโดยคั่นด้วยเว้นวรรค
val list2 = listOf("a", "bbb", "cc")
for (s in list2.listIterator()) {
    println("$s ")
}

⇒ a bbb cc

ขั้นตอนที่ 2: ลองทําแผนที่แฮช

ใน Kotlin คุณสามารถแมปอะไรก็ได้กับอย่างอื่นโดยใช้ hashMapOf() แผนที่แฮชเป็นเหมือนรายการคู่ ซึ่งค่าแรกทําหน้าที่เป็นคีย์

  1. สร้างแผนที่แฮชที่ตรงกับลักษณะปัญหา คีย์ และโรคของปลา
val cures = hashMapOf("white spots" to "Ich", "red sores" to "hole disease")
  1. จากนั้นดึงค่าโรคโดยอิงตามคีย์ลักษณะปัญหา โดยใช้ get() หรือแม้กระทั่งวงเล็บเหลี่ยมขนาดสั้น []
println(cures.get("white spots"))
⇒ Ich
println(cures["red sores"])
⇒ hole disease
  1. ลองระบุลักษณะปัญหาที่ไม่ได้อยู่ในแผนที่
println(cures["scale loss"])

⇒ null

หากคีย์ไม่ได้อยู่ในแผนที่ พยายามส่งคืนโรคที่ตรงกันกลับมา null โดยทั่วไปแล้ว อาจไม่มีข้อมูลที่ตรงกันสําหรับคีย์ที่เป็นไปได้ ทั้งนี้ขึ้นอยู่กับข้อมูลแผนที่ สําหรับกรณีดังกล่าว Kotlin มีฟังก์ชัน getOrDefault()

  1. ลองค้นหาคีย์ที่ไม่มีรายการตรงกันโดยใช้ getOrDefault()
println(cures.getOrDefault("bloating", "sorry, I don't know"))
⇒ sorry, I don't know

หากต้องการทําอะไรมากกว่าการแสดงค่า Kotlin มีฟังก์ชัน getOrElse()

  1. เปลี่ยนโค้ดไปใช้ getOrElse() แทน getOrDefault()
println(cures.getOrElse("bloating") {"No cure for this"})
⇒ No cure for this

แทนที่จะแสดงผลค่าเริ่มต้นแบบง่าย โค้ดใดๆ ที่อยู่ระหว่างวงเล็บปีกกา {} จะทํางาน ในตัวอย่าง else จะแสดงสตริงเพียง แต่ดีกว่าถ้าหาหน้าเว็บที่มีการรักษาและแสดงผล

เช่นเดียวกับ mutableListOf คุณยังสามารถสร้าง mutableMapOf ได้อีกด้วย แผนที่ซึ่งปิดเสียงได้ช่วยให้คุณวางและลบรายการต่างๆ ได้ รูปแบบเปลี่ยนแปลงได้หมายถึง เปลี่ยนแปลงได้ จะเปลี่ยนแปลงไม่ได้ ซึ่งหมายความว่าจะเปลี่ยนแปลงไม่ได้

  1. สร้างแผนที่สินค้าคงคลังที่แก้ไขได้ โดยแมปสตริงอุปกรณ์กับจํานวนรายการ สร้างบ่อโดยใช้อ่างเลี้ยงปลา แล้วนําไปถางตู้ปลา 3 ตัวลงในคลังพร้อมกับ put() และนําบ่อปลาออกด้วย remove()
val inventory = mutableMapOf("fish net" to 1)
inventory.put("tank scrubber", 3)
println(inventory.toString())
inventory.remove("fish net")
println(inventory.toString())
⇒ {fish net=1, tank scrubber=3}{tank scrubber=3}

ในงานนี้ คุณจะได้เรียนรู้เกี่ยวกับค่าคงที่ใน Kotlin และวิธีจัดระเบียบรูปแบบต่างๆ

ขั้นตอนที่ 1: ดูข้อมูลเกี่ยวกับ const กับ val

  1. ใน REPL ให้ลองสร้างค่าคงที่ที่เป็นตัวเลข ใน Kotlin คุณสามารถทําค่าคงที่ระดับบนสุดและกําหนดมูลค่าให้เวลาที่รวบรวมข้อมูลได้โดยใช้ const val
const val rocks = 3

มีการกําหนดค่านี้และเปลี่ยนแปลงไม่ได้ ซึ่งคล้ายกับการประกาศ val ปกติ แล้ว const val กับ val ต่างกันอย่างไร ค่าของ const val จะกําหนด ณ เวลาที่รวบรวมข้อมูล โดยที่เมื่อค่า val เป็นค่าที่กําหนดไว้ระหว่างการเรียกใช้โปรแกรม ซึ่งหมายความว่า val จะกําหนดค่าโดยฟังก์ชันหนึ่งๆ ขณะทํางาน

ซึ่งหมายความว่า val จะสามารถกําหนดค่าจากฟังก์ชันได้ แต่ const val กําหนดค่าไม่ได้

val value1 = complexFunctionCall() // OK
const val CONSTANT1 = complexFunctionCall() // NOT ok

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

object Constants {
    const val CONSTANT2 = "object constant"
}
val foo = Constants.CONSTANT2

ขั้นตอนที่ 2: สร้างออบเจ็กต์ที่ใช้ร่วมกัน

Kotlin ไม่มีแนวคิดค่าคงที่ระดับชั้นเรียน

หากต้องการกําหนดค่าคงที่ภายในชั้นเรียน คุณจะต้องรวมค่าเหล่านี้ลงในออบเจ็กต์ที่ใช้ร่วมกันซึ่งประกาศด้วยคีย์เวิร์ด companion โดยปกติวัตถุที่ใช้ร่วมกันจะเป็นวัตถุเดี่ยวภายในชั้นเรียน

  1. สร้างคลาสที่มีออบเจ็กต์ที่ใช้ร่วมกันซึ่งมีค่าคงที่สตริง
class MyClass {
    companion object {
        const val CONSTANT3 = "constant in companion"
    }
}

ความแตกต่างพื้นฐานระหว่างออบเจ็กต์ที่แสดงร่วมและออบเจ็กต์ปกติมีดังนี้

  • ออบเจ็กต์ที่ใช้ร่วมกันจะเริ่มต้นจากตัวสร้างแบบคงที่ของคลาสที่มีการสร้าง ซึ่งก็คือออบเจ็กต์จะสร้างขึ้นเมื่อมีการสร้างออบเจ็กต์
  • ออบเจ็กต์ปกติจะเริ่มต้นแบบ Lazy Loading และการเข้าถึงออบเจ็กต์นั้นเป็นครั้งแรก

ยังมีสิ่งต่างๆ เพิ่มเติม แต่สิ่งที่คุณต้องรู้ตอนนี้ก็คือการรวมค่าคงที่ในชั้นเรียนของออบเจ็กต์ที่ใช้ร่วมกัน

ในงานนี้ คุณจะได้เรียนรู้เกี่ยวกับการขยายขอบเขตของชั้นเรียน การเขียนฟังก์ชันยูทิลิตีเพื่อขยายพฤติกรรมของชั้นเรียนเป็นเรื่องปกติ Kotlin มีไวยากรณ์ที่สะดวกสําหรับการประกาศฟังก์ชันยูทิลิตีเหล่านี้: ฟังก์ชันส่วนขยาย

ฟังก์ชันส่วนขยายช่วยให้คุณเพิ่มฟังก์ชันในชั้นเรียนที่มีอยู่ได้โดยไม่ต้องเข้าถึงซอร์สโค้ด เช่น ประกาศในไฟล์ Extensions.kt ที่เป็นส่วนหนึ่งของแพ็กเกจ สิ่งนี้ไม่ได้แก้ไขชั้นเรียนจริง แต่จะอนุญาตให้คุณใช้สัญลักษณ์จุดเมื่อเรียกใช้ฟังก์ชันในวัตถุของชั้นเรียน

ขั้นตอนที่ 1: เขียนฟังก์ชันส่วนขยาย

  1. หากยังทํางานใน REPL อยู่ ให้เขียนฟังก์ชันส่วนขยายพื้นฐาน hasSpaces() เพื่อตรวจสอบว่าสตริงมีเว้นวรรคหรือไม่ ชื่อฟังก์ชันจะมีคํานําหน้ากับคลาสที่ใช้งาน ในฟังก์ชัน this หมายถึงออบเจ็กต์ที่เรียกใช้ และ it หมายถึงตัวเรียกในการเรียกใช้ find()
fun String.hasSpaces(): Boolean {
    val found = this.find { it == ' ' }
    return found != null
}
println("Does it have spaces?".hasSpaces())
⇒ true
  1. คุณสามารถลดความซับซ้อนของฟังก์ชัน hasSpaces() ไม่จําเป็นต้องใช้ this อย่างชัดเจน และลดฟังก์ชันลงเป็นนิพจน์เดียวและแสดงผลได้ วงเล็บปีกกา {} จึงไม่จําเป็นต้องใช้เช่นกัน ##99 
fun String.hasSpaces() = find { it == ' ' } != null

ขั้นตอนที่ 2: เรียนรู้ข้อจํากัดของส่วนขยาย

ฟังก์ชันส่วนขยายจะเข้าถึง API สาธารณะของชั้นเรียนที่มีการขยายได้เท่านั้น เข้าถึงตัวแปรที่ private ไม่ได้

  1. ลองเพิ่มฟังก์ชันส่วนขยายลงในพร็อพเพอร์ตี้ที่มีเครื่องหมาย private
class AquariumPlant(val color: String, private val size: Int)

fun AquariumPlant.isRed() = color == "red"    // OK
fun AquariumPlant.isBig() = size > 50         // gives error
⇒ error: cannot access 'size': it is private in 'AquariumPlant'
  1. ตรวจสอบโค้ดด้านล่างและพิจารณาว่าจะพิมพ์อะไร
open class AquariumPlant(val color: String, private val size: Int)

class GreenLeafyPlant(size: Int) : AquariumPlant("green", size)

fun AquariumPlant.print() = println("AquariumPlant")
fun GreenLeafyPlant.print() = println("GreenLeafyPlant")

val plant = GreenLeafyPlant(size = 10)
plant.print()
println("\n")
val aquariumPlant: AquariumPlant = plant
aquariumPlant.print()  // what will it print?
⇒ GreenLeafyPlant
AquariumPlant

รูปอัด plant.print() ใบGreenLeafyPlant คุณอาจคาดว่า aquariumPlant.print() จะพิมพ์ GreenLeafyPlant ด้วย เพราะระบบกําหนดมูลค่าเป็น plant แต่ประเภทดังกล่าวจะได้รับการแก้ไข ณ เวลาที่คอมไพล์ AquariumPlant จึงจะพิมพ์ออกมา

ขั้นตอนที่ 3: เพิ่มพร็อพเพอร์ตี้ส่วนขยาย

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

  1. ขณะใช้งาน REPL ในขณะที่เพิ่มพร็อพเพอร์ตี้ส่วนขยาย isGreen ลงใน AquariumPlant ซึ่งเป็น true หากสีเป็นสีเขียว
val AquariumPlant.isGreen: Boolean
   get() = color == "green"

พร็อพเพอร์ตี้ isGreen เข้าถึงได้เช่นเดียวกับพร็อพเพอร์ตี้ปกติ เมื่อเข้าถึงแล้ว จะเรียกใช้ Getter สําหรับ isGreen เพื่อรับค่า

  1. พิมพ์พร็อพเพอร์ตี้ isGreen สําหรับตัวแปร aquariumPlant และสังเกตผลลัพธ์
aquariumPlant.isGreen
⇒ res4: kotlin.Boolean = true

ขั้นตอนที่ 4: เรียนรู้เกี่ยวกับผู้รับที่เป็นโมฆะ

คลาสที่คุณเพิ่มจะเรียกว่าตัวรับ และจะทําให้คลาสเป็น Null ได้ หากทําเช่นนั้น ตัวแปร this ที่ใช้ในร่างกายอาจเป็น null ได้ ดังนั้นคุณต้องทดสอบด้วย คุณอาจต้องการใช้ผู้รับที่เป็น null ได้ หากคาดว่าผู้โทรต้องการเรียกใช้เมธอดส่วนขยายบนตัวแปรที่เป็นค่าว่างได้ หรือหากคุณต้องการระบุลักษณะการทํางานเริ่มต้นเมื่อใช้ฟังก์ชันกับ null

  1. ขณะยังใช้ REPL อยู่ ให้กําหนดเมธอด pull() ที่ใช้ตัวรับที่ยกเลิกได้ ซึ่งจะมีเครื่องหมายคําถาม ? หลังประเภทก่อนจุด ภายในร่างกาย คุณสามารถทดสอบได้ว่า this ไม่ใช่ null หรือไม่ โดยใช้เครื่องหมายคําถาม ?.apply.
fun AquariumPlant?.pull() {
   this?.apply {
       println("removing $this")
   }
}

val plant: AquariumPlant? = null
plant.pull()
  1. ในกรณีนี้ ไม่มีเอาต์พุตเมื่อคุณเรียกใช้โปรแกรม เนื่องจาก plant คือ null ระบบจะไม่เรียก println() ภายใน

ฟังก์ชันส่วนขยายมีประสิทธิภาพมากและไลบรารีมาตรฐานของ Kotlin ส่วนใหญ่มีการใช้งานเป็นฟังก์ชันส่วนขยาย

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

  • คุณใช้คู่คีย์และสามค่าเพื่อแสดงผลมากกว่า 1 ค่าจากฟังก์ชันได้ ดังตัวอย่างต่อไปนี้
    val twoLists = fish.partition { isFreshWater(it) }
  • Kotlin มีฟังก์ชันที่เป็นประโยชน์มากมายสําหรับ List เช่น reversed(), contains() และ subList()
  • คุณใช้ HashMap เพื่อแมปคีย์กับค่าได้ ดังตัวอย่างต่อไปนี้
    val cures = hashMapOf("white spots" to "Ich", "red sores" to "hole disease")
  • ประกาศค่าคงที่เวลาคอมไพล์โดยใช้คีย์เวิร์ด const คุณสามารถเก็บคีย์ไว้ที่ระดับบนสุด จัดระเบียบรายการเหล่านั้นไว้ในออบเจ็กต์เดี่ยว หรือวางในออบเจ็กต์ที่ใช้ร่วมกันก็ได้
  • ออบเจ็กต์ที่ใช้ร่วมกันเป็นออบเจ็กต์เดี่ยวภายในการกําหนดคลาส ซึ่งแสดงด้วยคีย์เวิร์ด companion
  • ฟังก์ชันและคุณสมบัติของส่วนขยายสามารถเพิ่มฟังก์ชันให้กับชั้นเรียนได้ ดังตัวอย่างต่อไปนี้
    fun String.hasSpaces() = find { it == ' ' } != null
  • รีซีฟเวอร์แบบรับไม่ได้ช่วยให้คุณสร้างส่วนขยายในชั้นเรียนซึ่งอาจเป็น null โอเปอเรเตอร์ ?. จับคู่กับ apply เพื่อตรวจสอบ null ก่อนเรียกใช้โค้ดได้ ดังตัวอย่างต่อไปนี้
    this?.apply { println("removing $this") }

เอกสารประกอบเกี่ยวกับ Kotlin

หากต้องการข้อมูลเพิ่มเติมเกี่ยวกับหัวข้อใดก็ตามในหลักสูตรนี้หรือคุณติดค้าง https://kotlinlang.org คือจุดเริ่มต้นที่ดีที่สุด

บทแนะนําเกี่ยวกับ Kotlin

เว็บไซต์ https://try.kotlinlang.org มีบทแนะนําที่ครอบคลุมชื่อ Kotlin Koans ซึ่งเป็นล่ามบนเว็บ และชุดเอกสารอ้างอิงที่สมบูรณ์พร้อมตัวอย่าง

หลักสูตร Udacity

ดูหลักสูตร Udacity เกี่ยวกับหัวข้อนี้ที่หัวข้อ Kotlin Bootcamp สําหรับโปรแกรมเมอร์

IntelliJ IDEA

ดูเอกสารสําหรับ IntelliJ IDEA ได้ในเว็บไซต์ JetBrains

ส่วนนี้จะอธิบายการบ้านและรายงานสําหรับนักเรียนที่ทํางานผ่าน Codelab นี้ซึ่งเป็นส่วนหนึ่งของหลักสูตรที่นําโดยผู้สอน สิ่งที่ผู้สอนต้องทํามีดังนี้

  • มอบหมายการบ้านหากจําเป็น
  • สื่อสารกับนักเรียนเกี่ยวกับวิธีส่งงานทําการบ้าน
  • ตัดเกรดการบ้าน

ผู้สอนจะใช้คําแนะนําเหล่านี้เท่าใดก็ได้หรือตามที่ต้องการก็ได้ และสามารถกําหนดให้การบ้านอื่นๆ ที่ตนคิดว่าเหมาะสมได้

หากคุณใช้ Codelab ด้วยตัวเอง ก็ให้ใช้การบ้านเพื่อทดสอบความรู้ของคุณได้

ตอบคําถามเหล่านี้

คำถามที่ 1

ข้อใดต่อไปนี้ตรงกับสําเนาของรายการ

▢ add()

▢ remove()

▢ reversed()

▢ contains()

คำถามที่ 2

ฟังก์ชันส่วนขยายข้อใดต่อไปนี้ใน class AquariumPlant(val color: String, val size: Int, private val cost: Double, val leafy: Boolean) จะทําให้คอมไพเลอร์เกิดข้อผิดพลาด

▢ fun AquariumPlant.isRed() = color == "red"

▢ fun AquariumPlant.isBig() = size > 45

▢ fun AquariumPlant.isExpensive() = cost > 10.00

▢ fun AquariumPlant.isNotLeafy() = leafy == false

คำถามที่ 3

ข้อใดต่อไปนี้ไม่ใช่สถานที่ที่คุณกําหนดค่าคงที่ด้วย const val

▢ ที่ระดับบนสุดของไฟล์

▢ ในชั้นเรียนปกติ

▢ ในออบเจ็กต์เดี่ยว

▢ ในออบเจ็กต์ที่ใช้ร่วมกัน

ไปยังบทเรียนถัดไป ได้แก่ 5.2 ทั่วไป

ดูภาพรวมของหลักสูตร รวมถึงลิงก์ไปยัง Codelab อื่นๆ ได้ที่ "Kotlin Bootcamp สําหรับโปรแกรมเมอร์: ยินดีต้อนรับสู่หลักสูตร"