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

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

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

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

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

ข้อกำหนดเบื้องต้น

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

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

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

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

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

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

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

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

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

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

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

fun main() {

}

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

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

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

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

val diceRange = 1..6

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

เคล็ดลับ: โปรดสังเกตว่าคำจำกัดความนี้ไม่ได้ระบุ IntRange ในลักษณะเดียวกับที่คุณไม่จำเป็นต้องระบุ Int หรือ String เมื่อสร้างตัวแปรสำหรับจำนวนเต็มหรือสตริง โดยส่วนใหญ่แล้ว ระบบจะระบุประเภทข้อมูลที่คุณต้องการได้

เช่น ระบบจะตีความข้อความต่อไปนี้

val diceRange = 1..6

ดังนี้

val diceRange: IntRange = 1..6

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

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

 val randomNumber = diceRange.random()

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

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

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

โค้ดที่เสร็จสมบูรณ์แล้วควรมีลักษณะดังนี้

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

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

Random number: 4

เคล็ดลับเกี่ยวกับช่วง

• ช่วงอาจเป็นจำนวนเต็มใดก็ได้ ช่วงที่ถูกต้องคือ 3..46, 0..270, -6..+6, -10..-4
• คุณสามารถเรียกใช้ฟังก์ชันโดยตรงในช่วงได้ เช่น (1..6).random()

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

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

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

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

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

กำหนดคลาสลูกเต๋า

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

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

fun main() {

}

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

class Dice {

}

หมายเหตุ:

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

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

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

class Dice {
    var sides = 6
}

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

สร้างอินสแตนซ์ของคลาส Dice

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

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

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

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

2. เพิ่มคำสั่ง println() ใต้ประกาศของ myFirstDice เพื่อแสดงจำนวน sides ของ myFirstDice.

println(myFirstDice.sides)

หมายเหตุ: คุณใช้รูปแบบจุดไปแล้วก่อนหน้านี้เมื่อเรียกใช้ diceRange.random() โดยทั่วไปแล้ว คุณสามารถคิดว่ารูปแบบจุดเป็นการพูดว่า "ในออบเจ็กต์หนึ่ง ให้ดำเนินการบางอย่าง" เช่น ในที่นี้ด้วย myFirstDice.sides "ในอินสแตนซ์นี้ ให้รับพร็อพเพอร์ตี้ sides"

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

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

class Dice {
    var sides = 6
}

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

6

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

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

ทอยลูกเต๋า

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

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

class Dice {
    var sides = 6

    fun roll() {

    }
}

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

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

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

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

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

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

4. หากต้องการย้อนกลับจริง myFirstDice ใน main() ให้เรียกใช้เมธอด roll() ใน myFirstDice คุณเรียกใช้เมธอดโดยใช้ "รูปแบบจุด" ดังนั้น หากต้องการเรียกใช้เมธอด 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)
    }
}

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

6
4

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

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

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

val diceRoll = myFirstDice.roll()

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

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

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

fun roll(): Int {

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

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

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

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

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

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

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

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

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

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 ด้าน

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

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

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

myFirstDice.sides = 20

3. คัดลอกและวางคำสั่งการพิมพ์ที่มีอยู่ด้านล่างหลังจากที่คุณเปลี่ยนจำนวนด้าน
4. แทนที่การพิมพ์ 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
    }
}

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

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

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

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

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

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

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

Dice คลาสควรมีลักษณะดังนี้

class Dice (val numSides: Int) {

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

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

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

    val myFirstDice = Dice(6)

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

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

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

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

    val mySecondDice = Dice(20)

9. เพิ่มคำสั่งพิมพ์ที่หมุนและพิมพ์ค่าที่ส่งคืน

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

10. ฟังก์ชัน 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
    }
}

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

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

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

1. เปลี่ยนคำสั่ง return เพื่อส่งคืนตัวเลขสุ่มโดยตรง

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

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

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

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

3. เรียกใช้โค้ดและเอาต์พุตควรจะไม่มีความแตกต่าง

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

นี่คือรหัสสุดท้ายหลังจากปรับโครงสร้าง

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 }

• การสร้างตัวเลขสุ่ม (วิกิพีเดีย)
• ความท้าทายที่น่าทึ่งในการออกแบบลูกเต๋า 120 ด้าน
• คลาสใน Kotlin
• การประกาศฟังก์ชันใน Kotlin
• การแสดงค่าจากฟังก์ชัน

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

ทำดังนี้

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