Time to sync up! Tune in for Google I/O on May 14, 2024. Register now.

หน้านี้ได้รับการแปลโดย Cloud Translation API

คลาสและอินสแตนซ์ออบเจ็กต์ใน Kotlin

สําหรับ Codelab ในเส้นทางนี้ คุณกําลังสร้างแอป Android สําหรับลูกเต๋า Android เมื่อผู้ใช้และทอยลูกเต๋า ระบบจะสร้างผลลัพธ์แบบสุ่ม ผลลัพธ์ที่ได้จะพิจารณาจํานวนลูกเต๋าหลายด้าน เช่น เฉพาะค่า 1-6 ที่ทอยได้จากลูกเต๋า 6 ด้าน

แอปขั้นสุดท้ายจะมีลักษณะดังนี้

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

ใน Codelab แรกนี้ คุณจะต้องสร้างโปรแกรม Kotlin ที่จําลองลูกเต๋าและมีหมายเลขแบบสุ่มให้เหมือนกับลูกเต๋า

สิ่งที่ต้องมีก่อน

วิธีเปิด แก้ไข และเรียกใช้โค้ดใน https://try.kotlinlang.org/
สร้างและเรียกใช้โปรแกรม Kotlin ที่ใช้ตัวแปรและฟังก์ชัน แล้วพิมพ์ผลลัพธ์ไปยังคอนโซล
จัดรูปแบบตัวเลขภายในข้อความโดยใช้เทมเพลตสตริงที่มีสัญลักษณ์ ${variable}

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

วิธีสร้างตัวเลขแบบสุ่มแบบเป็นโปรแกรมเพื่อจําลองลูกเต๋า
วิธีจัดโครงสร้างโค้ดด้วยการสร้างคลาส Dice ด้วยตัวแปรและวิธีการ
วิธีสร้างอินสแตนซ์ออบเจ็กต์ของชั้นเรียน แก้ไขตัวแปร และเรียกเมธอดของคลาสได้

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

โปรแกรม Kotlin ในเครื่องมือเขียนโปรแกรม Kotlin บนเบราว์เซอร์ที่สามารถทอยลูกเต๋าแบบสุ่มได้

สิ่งที่ต้องมี

คอมพิวเตอร์ที่มีการเชื่อมต่ออินเทอร์เน็ต

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

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

ตั้งค่าโค้ดเริ่มต้น

เปิดเว็บไซต์ https://try.kotlinlang.org/ ในเบราว์เซอร์
ลบโค้ดที่มีอยู่ทั้งหมดในตัวแก้ไขโค้ด แล้วแทนที่ด้วยโค้ดด้านล่าง นี่คือฟังก์ชัน main() ที่คุณทํางานกับ Codelab ก่อนหน้านี้ (ดูเขียนโปรแกรม Kotlin ครั้งแรก Codelab)

fun main() {

}

ใช้ฟังก์ชันแบบสุ่ม

หากต้องการทอยลูกเต๋า คุณต้องมีวิธีแสดงถึงค่าลูกเต๋าที่ถูกต้องทั้งหมด สําหรับลูกเต๋าแบบ 6 ด้านปกติ ลูกเต๋าที่ยอมรับได้ ได้แก่ 1, 2, 3, 4, 5 และ 6

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

ภายในฟังก์ชัน main() ให้กําหนดตัวแปรเป็น val ที่ชื่อ diceRange กําหนดให้กับ IntRange ตั้งแต่ 1 ถึง 6 โดยแทนช่วงจํานวนเต็มที่ลูกเต๋า 6 ด้านสามารถทอยได้

val diceRange = 1..6

คุณจะทราบได้ว่า 1..6 เป็นช่วง Kotlin เนื่องจากมีหมายเลขเริ่มต้น, 2 จุด ตามด้วยตัวเลขสิ้นสุด (ไม่ต้องเว้นวรรคระหว่างนี้) ตัวอย่างอื่นๆ ของช่วงจํานวนเต็มคือ 2..5 สําหรับตัวเลข 2 ถึง 5 และ 100..200 สําหรับตัวเลข 100 ถึง 200

คุณสามารถใช้ฟังก์ชันชื่อ random() เพื่อสร้างและส่งคืนหมายเลขสุ่มสําหรับคุณในช่วงหนึ่งๆ ได้ ซึ่งคล้ายกับวิธีที่ println() เรียกระบบให้พิมพ์ข้อความที่ระบุ และก่อนหน้านี้ คุณสามารถจัดเก็บผลลัพธ์ในตัวแปรได้

ภายใน main() ให้กําหนดตัวแปรเป็น val ชื่อ randomNumber
ทําให้ randomNumber มีค่าจากผลลัพธ์ของการเรียก random() ในช่วง diceRange ดังที่แสดงด้านล่าง

 val randomNumber = diceRange.random()

โปรดสังเกตว่าคุณกําลังเรียกใช้ random() บน diceRange โดยใช้เครื่องหมายจุดหรือจุดระหว่างตัวแปรกับการเรียกใช้ฟังก์ชัน อ่านข้อมูลนี้เป็น "การสร้างตัวเลขแบบสุ่มจากdiceRange" แล้วเก็บผลลัพธ์ไว้ในตัวแปรrandomNumber

หากต้องการดูหมายเลขสุ่มที่สร้างขึ้น ให้ใช้รูปแบบการจัดรูปแบบสตริง (หรือที่เรียกว่า ""string Template") ${randomNumber} เพื่อพิมพ์ตามที่แสดงด้านล่าง

println("Random number: ${randomNumber}")

โค้ดที่ทําเสร็จแล้วควรจะออกมาแบบนี้

fun main() {
    val diceRange = 1..6
    val randomNumber = diceRange.random()
    println("Random number: ${randomNumber}")
}

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

Random number: 4

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

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

จากคลาสนั้น คุณสามารถสร้างวัตถุลูกเต๋าจริงที่เรียกว่าอินสแตนซ์ของออบเจ็กต์ได้ เช่น ลูกเต๋า 12 ด้านหรือลูกเต๋า 4 ด้าน

กําหนดระดับลูกเต๋า

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

หากต้องการเริ่มต้นใหม่ ให้ล้างโค้ดในฟังก์ชัน main() เพื่อให้คุณได้โค้ดตามที่แสดงด้านล่าง

fun main() {

}

ใต้ฟังก์ชัน main() นี้ ให้เพิ่มบรรทัดว่างแล้วเพิ่มโค้ดเพื่อสร้างชั้นเรียน Dice ดังที่แสดงด้านล่าง ให้เริ่มต้นด้วยคีย์เวิร์ด class ตามด้วยชื่อคลาส ตามด้วยวงเล็บปีกกาเปิดและปิด เว้นช่องว่างระหว่างวงเล็บปีกกาเพื่อใส่รหัสสําหรับชั้นเรียน

class Dice {

}

หมายเหตุ

หากต้องการใช้คีย์เวิร์ด fun ใน Kotlin เพื่อสร้างฟังก์ชันใหม่ ให้ใช้คีย์เวิร์ด class เพื่อสร้างคลาสใหม่
คุณสามารถเลือกชื่อใดก็ได้สําหรับ class แต่จะมีประโยชน์หากชื่อนั้นแสดงถึงคลาส ตามปกติแล้ว ชื่อคลาสจะเป็นตัวพิมพ์เล็ก เช่น Car, ParkingMeter และ CustomerRecord เป็นชื่อคลาสที่ถูกต้องทั้งหมด และคุณเดาชื่อที่ใช้ได้

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

ภายในชั้นเรียน Dice ให้เพิ่ม var ที่ชื่อ sides ตามด้านที่ลูกเต๋าจะมีอยู่ ตั้งค่า sides เป็น 6

class Dice {
    var sides = 6
}

แค่เพียงเท่านั้น ตอนนี้คุณมีชั้นเรียนที่เรียบง่ายซึ่งจะแสดงลูกเต๋า

สร้างอินสแตนซ์ของลูกเต๋า

ด้วยคลาส Dice นี้ คุณจะได้พิมพ์เขียวของลูกเต๋า เพื่อที่จะมีลูกเต๋าจริงในโปรแกรมของคุณ คุณต้องสร้างอินสแตนซ์วัตถุ Dice (และหากคุณมีลูกเต๋า 3 ลูก คุณจะสร้างอินสแตนซ์วัตถุ 3 ลูก)

หากต้องการสร้างอินสแตนซ์ออบเจ็กต์ของ Dice ในฟังก์ชัน main() ให้สร้าง val ที่ชื่อ myFirstDice และเริ่มต้นเป็นอินสแตนซ์ของคลาส Dice ให้สังเกตวงเล็บหลังชื่อชั้นเรียน ซึ่งหมายความว่าคุณกําลังสร้างอินสแตนซ์วัตถุใหม่จากชั้นเรียน

fun main() {
    val myFirstDice = Dice()
}

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

ใต้การประกาศ myFirstDice ให้เพิ่มคําสั่ง println() เพื่อเอาต์พุตจํานวนของ sides จาก myFirstDice.

println(myFirstDice.sides)

โค้ดควรเป็นแบบนี้

fun main() {
    val myFirstDice = Dice()
    println(myFirstDice.sides)
}

class Dice {
    var sides = 6
}

เรียกใช้โปรแกรมและส่งออกจํานวน sides ที่กําหนดไว้ในคลาส Dice

ตอนนี้คุณมีชั้นเรียน Dice และลูกเต๋า myFirstDice ลูกจริงที่มี sides 6 ลูก

มาทอยลูกเต๋ากัน

ทอยลูกเต๋า

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

ในชั้นเรียน Dice ด้านล่างตัวแปร sides ให้แทรกบรรทัดว่างแล้วสร้างฟังก์ชันใหม่สําหรับทอยลูกเต๋า เริ่มต้นด้วยคีย์เวิร์ด Kotlin fun ตามด้วยชื่อของเมธอด ตามด้วยวงเล็บ () ตามด้วยวงเล็บปีกกาปิด {} คุณสามารถเว้นช่องว่างระหว่างวงเล็บปีกกาเพื่อให้มีที่ว่างสําหรับโค้ดเพิ่มเติมดังที่แสดงด้านล่าง ชั้นเรียนของคุณควรจะมีลักษณะดังนี้

class Dice {
    var sides = 6

    fun roll() {

    }
}

เมื่อทอยลูกเต๋า 6 ด้าน ระบบจะสร้างตัวเลขแบบสุ่มระหว่าง 1 ถึง 6

สร้าง val randomNumber ภายในเมธอด roll() กําหนดหมายเลขสุ่มในช่วง 1..6 ใช้สัญลักษณ์จุดเพื่อเรียก random() ในช่วง

val randomNumber = (1..6).random()

หลังจากสร้างหมายเลขแบบสุ่มแล้ว ให้พิมพ์ไปยังคอนโซล เมธอด roll() ที่สร้างเสร็จแล้วควรมีลักษณะเหมือนโค้ดด้านล่าง

fun roll() {
     val randomNumber = (1..6).random()
     println(randomNumber)
}

หากต้องการนับ myFirstDice จริงๆ ใน main() ให้เรียกใช้เมธอด roll() ใน myFirstDice คุณสามารถเรียกเมธอดโดยใช้ "dot &" ดังนั้น หากต้องการเรียกใช้วิธี roll() ของ myFirstDice คุณพิมพ์ myFirstDice.roll() ซึ่งออกเสียง "myFirstDice จุด roll()"

myFirstDice.roll()

รหัสที่สมบูรณ์ควรมีลักษณะดังนี้

fun main() {
    val myFirstDice = Dice()
    println(myFirstDice.sides)
    myFirstDice.roll()
}

class Dice {
    var sides = 6

    fun roll() {
        val randomNumber = (1..6).random()
        println(randomNumber)
    }
}

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

6
4

ยินดีด้วย คุณได้กําหนดคลาส Dice ด้วยตัวแปร sides และฟังก์ชัน roll() ในฟังก์ชัน main() คุณสร้างอินสแตนซ์ออบเจ็กต์ Dice ใหม่ แล้วเรียกใช้เมธอด roll() บนอินสแตนซ์เพื่อสร้างหมายเลขสุ่ม

คุณกําลังพิมพ์ค่าของ randomNumber ในฟังก์ชัน roll() ซึ่งมีประโยชน์มาก แต่ในบางครั้งการส่งคืนผลลัพธ์ของฟังก์ชันใดก็ตามกลับมาเรียกว่าฟังก์ชันจะมีประโยชน์มากกว่า เช่น คุณอาจกําหนดผลลัพธ์ของเมธอด roll() ให้กับตัวแปร แล้วย้ายผู้เล่นตามจํานวนนั้น มาดูการทํางานกัน

ใน main() ให้แก้ไขบรรทัดที่ระบุว่า myFirstDice.roll() สร้าง val ที่ชื่อ diceRoll ตั้งเท่ากับค่าที่ roll() แสดงผล

val diceRoll = myFirstDice.roll()

การดําเนินการนี้ยังไม่ได้ทําอะไรเนื่องจาก roll() ยังไม่ส่งคืนอะไร roll() ต้องส่งคืนบางอย่างเพื่อให้โค้ดนี้ทํางานตามที่ต้องการ

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

เปลี่ยนฟังก์ชัน roll() เพื่อระบุประเภทข้อมูลที่จะส่งคืน ในกรณีนี้ หมายเลขสุ่มคือ Int ดังนั้นประเภทการคืนสินค้าจะเป็น Int ไวยากรณ์สําหรับการระบุประเภทการคืนสินค้าคือหลังชื่อฟังก์ชัน หลังจากใส่เครื่องหมายวงเล็บแล้ว ให้ใส่เครื่องหมายโคลอน เว้นวรรค และคีย์เวิร์ด Int สําหรับประเภทการคืนสินค้าของฟังก์ชัน คําจํากัดความของฟังก์ชันควรมีลักษณะเหมือนโค้ดด้านล่าง

fun roll(): Int {

เรียกใช้โค้ดนี้ คุณจะเห็นข้อผิดพลาดในมุมมองปัญหา ข้อความคือ

A ‘return'  expression is required in a function with a block body.

คุณได้เปลี่ยนคําจํากัดความของฟังก์ชันให้แสดง Int แต่ระบบบ่นว่า

code ไม่ได้แสดงผล Int "Block body" หรือ "function body" หมายถึงโค้ดระหว่างวงเล็บปีกกาของฟังก์ชัน คุณแก้ไขข้อผิดพลาดนี้ได้โดยแสดงผลค่าจากฟังก์ชันโดยใช้คําสั่ง return ท้ายเนื้อความฟังก์ชัน

ใน roll() ให้นําคําสั่ง println() ออก แล้วแทนที่ด้วยคําสั่ง return สําหรับ randomNumber ฟังก์ชัน roll() ควรมีลักษณะเหมือนโค้ดด้านล่าง

fun roll(): Int {
     val randomNumber = (1..6).random()
     return randomNumber
}

ใน main() โปรดนําคําสั่งพิมพ์ด้านลูกเต๋าออก
เพิ่มคําแถลงเพื่อพิมพ์มูลค่าของ sides และ diceRoll ในประโยคที่ให้ข้อมูล ฟังก์ชัน main() ที่สร้างเสร็จแล้วควรมีลักษณะคล้ายกับโค้ดด้านล่าง

fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")
}

เรียกใช้โค้ดและเอาต์พุตของคุณควรมีลักษณะดังนี้

Your 6 sided dice rolled 4!

นี่คือรหัสทั้งหมดของคุณ

fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")
}


class Dice {
    var sides = 6

    fun roll(): Int {
        val randomNumber = (1..6).random()
        return randomNumber
    }
}

ลูกเต๋าบางลูกไม่ได้มี 6 ด้าน ลูกเต๋ารูปทรงต่างๆ ทั้งหมด: 4 ด้าน, 8 ด้าน, สูงสุด 120 ด้าน

ในคลาส Dice ในวิธี roll() ให้เปลี่ยนวิธี 1..6 ที่ฮาร์ดโค้ดไว้เพื่อใช้ sides แทน เพื่อให้ช่วงและหมายเลขสุ่มถูกม้วนจะเป็นจํานวนด้านเสมอ

val randomNumber = (1..sides).random()

ในฟังก์ชัน main() ด้านล่างและหลังจากพิมพ์ลูกเต๋า เปลี่ยน sides ของFirstDiceของฉันเป็น 20

myFirstDice.sides = 20

คัดลอกและวางคําสั่งพิมพ์ที่มีอยู่ด้านล่างหลังจากเปลี่ยนจํานวนด้านแล้ว
แทนที่การพิมพ์ diceRoll ด้วยการพิมพ์ผลลัพธ์ของการเรียกใช้เมธอด roll() ใน myFirstDice

println("Your ${myFirstDice.sides} sided dice has rolled a ${myFirstDice.roll()}!")

โปรแกรมควรมีลักษณะดังนี้

fun main() {
   
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")

    myFirstDice.sides = 20
    println("Your ${myFirstDice.sides} sided dice rolled ${myFirstDice.roll()}!")
}

class Dice {
    var sides = 6

    fun roll(): Int {
        val randomNumber = (1..sides).random()
        return randomNumber
    }
}

เรียกใช้โปรแกรม จากนั้นคุณควรเห็นข้อความของลูกเต๋า 6 ด้าน และอีกข้อความหนึ่งสําหรับลูกเต๋า 2 ด้าน

Your 6 sided dice rolled 3!
Your 20 sided dice rolled 15!

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

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

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

class Dice(val numSides: Int) {
   // Code inside does not change.
}

ลบตัวแปร sides ภายในคลาส Dice เพราะตอนนี้จะใช้ numSides ได้
และแก้ไขช่วงเพื่อใช้ numSides ด้วย

ชั้นเรียน Dice ควรมีลักษณะดังนี้

class Dice (val numSides: Int) {

    fun roll(): Int {
        val randomNumber = (1..numSides).random()
        return randomNumber
    }
}

หากคุณเรียกใช้โค้ดนี้ คุณจะเห็นข้อผิดพลาดจํานวนมากเนื่องจากคุณต้องอัปเดต main() เพื่อให้ทํางานกับการเปลี่ยนแปลงคลาส Dice

ใน main() หากต้องการสร้าง myFirstDice ที่มี 6 ด้าน คุณต้องส่งผ่านจํานวนด้านเป็นอาร์กิวเมนต์ไปยังคลาส Dice ดังที่แสดงด้านล่าง

    val myFirstDice = Dice(6)

เปลี่ยน sides เป็น numSides ในใบแจ้งยอดการพิมพ์
ด้านล่าง ให้ลบโค้ดที่เปลี่ยน sides เป็น 20 เนื่องจากไม่มีตัวแปรนั้นอีกต่อไป
ลบคําสั่ง println ใต้ข้อความนั้นด้วย

ฟังก์ชัน main() ควรมีลักษณะเหมือนโค้ดด้านล่าง และหากเรียกใช้ ก็ไม่ควรมีข้อผิดพลาด

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}

หลังจากพิมพ์ลูกเต๋าแรกแล้ว ให้เพิ่มโค้ดเพื่อสร้างและพิมพ์ออบเจ็กต์ Dice ชิ้นที่ 2 ชื่อ mySecondDice โดยให้ด้าน 20 ด้าน

    val mySecondDice = Dice(20)

เพิ่มคําสั่งรูปอัดที่ม้วนและพิมพ์ค่าที่แสดงผล

println("Your ${mySecondDice.numSides} sided dice rolled  ${mySecondDice.roll()}!")

ฟังก์ชัน main() ที่สร้างเสร็จแล้วควรมีลักษณะดังนี้

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
    
    val mySecondDice = Dice(20)
    println("Your ${mySecondDice.numSides} sided dice rolled ${mySecondDice.roll()}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        val randomNumber = (1..numSides).random()
        return randomNumber
    }
}

เรียกใช้โปรแกรมที่ทําเสร็จแล้ว เอาต์พุตของคุณควรมีลักษณะดังนี้

Your 6 sided dice rolled 5!
Your 20 sided dice rolled 7!

เมื่อเขียนโค้ด กระชับจะดีกว่า คุณจะกําจัดตัวแปร randomNumber และส่งตัวเลขแบบสุ่มกลับมาได้โดยตรง

เปลี่ยนคําสั่ง return เพื่อแสดงหมายเลขแบบสุ่มโดยตรง

    fun roll(): Int {
        return (1..numSides).random()
    }

ในคําสั่งที่ 2 ให้พิมพ์วิธีโทรหาหมายเลขแบบสุ่มลงในเทมเพลตสตริง คุณกําจัดตัวแปร diceRoll ได้ด้วยการดําเนินการเดียวกันนี้ในคําสั่งพิมพ์แรก

เรียก myFirstDice.roll() ในเทมเพลตสตริงและลบตัวแปร diceRoll 2 บรรทัดแรกของโค้ดหลัก() มีลักษณะดังนี้

    val myFirstDice = Dice(6)
    println("Your ${myFirstDice.numSides} sided dice rolled ${myFirstDice.roll()}!")

เรียกใช้โค้ดและผลลัพธ์ที่ได้ไม่มีความแตกต่าง

นี่คือโค้ดสุดท้ายหลังเปลี่ยนโครงสร้างใหม่แล้ว

fun main() {
    val myFirstDice = Dice(6)
    println("Your ${myFirstDice.numSides} sided dice rolled ${myFirstDice.roll()}!")
    
    val mySecondDice = Dice(20)
    println("Your ${mySecondDice.numSides} sided dice rolled ${mySecondDice.roll()}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
    
    val mySecondDice = Dice(20)
    println("Your ${mySecondDice.numSides} sided dice rolled ${mySecondDice.roll()}!")
}

class Dice (val numSides: Int) {

    fun roll(): Int {
        return (1..numSides).random()
    }
}

เรียกใช้ฟังก์ชัน random() ใน IntRange เพื่อสร้างหมายเลขสุ่ม: (1..6).random()
คลาสเป็นเหมือนพิมพ์เขียวของวัตถุ โดยอาจประกอบด้วยพร็อพเพอร์ตี้และลักษณะการทํางาน ซึ่งใช้เป็นตัวแปรและฟังก์ชัน
อินสแตนซ์ของคลาสแสดงถึงวัตถุ ซึ่งมักจะเป็นวัตถุจริง เช่น ลูกเต๋า คุณเรียกใช้การทํางานในออบเจ็กต์และเปลี่ยนแอตทริบิวต์ได้
คุณจะส่งอินพุตไปยังคลาสได้เมื่อสร้างอินสแตนซ์โดยระบุอาร์กิวเมนต์สําหรับการกําหนดคลาส เช่น class Dice(val numSides: Int) แล้วสร้างอินสแตนซ์ด้วย Dice(6)
ฟังก์ชันอาจส่งคืนบางสิ่งได้ ระบุประเภทข้อมูลที่จะแสดงในคําจํากัดความของฟังก์ชัน และใช้คําสั่ง return ในส่วนเนื้อหาของฟังก์ชันเพื่อส่งคืนบางสิ่ง ตัวอย่าง: fun example(): Int { return 5 }

สิ่งที่คุณทําได้มีดังนี้

ให้แอตทริบิวต์สีอีกคลาสหนึ่งของ Dice แล้วสร้างลูกเต๋าหลายๆ ลูกที่มีด้านและสีต่างๆ
สร้างชั้นเรียน Coin เพื่อให้พลิกบทบาท สร้างอินสแตนซ์ของชั้นเรียน และโยนหัวก้อยได้ คุณจะใช้ฟังก์ชันแบบสุ่ม() กับช่วงเพื่อทําการสลับเหรียญอย่างไร