इस पेज का अनुवाद Cloud Translation API से किया गया है.

Kotlin में क्लास और ऑब्जेक्ट इंस्टेंस

इस पाथवे में दिए गए कोडलैब के लिए, आपको डाइस रोलर Android ऐप्लिकेशन बनाना होगा. जब उपयोगकर्ता "डाइस रोल करेगा", तब एक रैंडम नतीजा जनरेट होगा. नतीजे में डाइस के साइड की संख्या को ध्यान में रखा जाता है. उदाहरण के लिए, छह साइड वाले पासे से सिर्फ़ 1 से 6 तक की वैल्यू मिल सकती हैं.

फ़ाइनल ऐप्लिकेशन ऐसा दिखेगा.

इस ऐप्लिकेशन के लिए, प्रोग्रामिंग के नए कॉन्सेप्ट पर ध्यान देने में आपकी मदद करने के लिए, ब्राउज़र पर आधारित Kotlin प्रोग्रामिंग टूल का इस्तेमाल किया जाएगा. इससे ऐप्लिकेशन की मुख्य सुविधाएं बनाई जा सकेंगी. प्रोग्राम, आपके नतीजों को कंसोल पर दिखाएगा. बाद में, Android Studio में यूज़र इंटरफ़ेस लागू किया जाएगा.

इस पहले कोडलैब में, आपको एक Kotlin प्रोग्राम बनाना होगा. यह प्रोग्राम, डाइस को रोल करने की प्रोसेस को सिम्युलेट करता है और डाइस की तरह ही कोई रैंडम नंबर आउटपुट करता है.

ज़रूरी शर्तें

https://try.kotlinlang.org/ में कोड खोलने, उसमें बदलाव करने, और उसे चलाने का तरीका
वैरिएबल और फ़ंक्शन का इस्तेमाल करके, एक Kotlin प्रोग्राम बनाएं और उसे चलाएं. साथ ही, कंसोल पर नतीजे प्रिंट करें.
${variable} नोटेशन के साथ स्ट्रिंग टेंप्लेट का इस्तेमाल करके, टेक्स्ट में मौजूद संख्याओं को फ़ॉर्मैट करें.

आपको क्या सीखने को मिलेगा

डाइस रोल को सिम्युलेट करने के लिए, प्रोग्राम के हिसाब से रैंडम नंबर जनरेट करने का तरीका.
वैरिएबल और तरीके के साथ Dice क्लास बनाकर, अपने कोड को स्ट्रक्चर करने का तरीका.
किसी क्लास का ऑब्जेक्ट इंस्टेंस बनाने, उसके वैरिएबल में बदलाव करने, और उसके तरीकों को कॉल करने का तरीका.

आपको क्या बनाना है

ब्राउज़र पर आधारित Kotlin प्रोग्रामिंग टूल में एक Kotlin प्रोग्राम, जो डाइस को रैंडम तरीके से रोल कर सकता है.

आपको इन चीज़ों की ज़रूरत पड़ेगी

इंटरनेट कनेक्शन वाला कंप्यूटर

गेम में अक्सर कोई न कोई रैंडम एलिमेंट होता है. आपको कोई इनाम मिल सकता है या गेम बोर्ड पर कुछ कदम आगे बढ़ने का मौका मिल सकता है. रोज़मर्रा की ज़िंदगी में, सुरक्षित पासवर्ड जनरेट करने के लिए रैंडम नंबर और अक्षरों का इस्तेमाल किया जा सकता है!

डाइस को असल में रोल करने के बजाय, एक ऐसा प्रोग्राम लिखा जा सकता है जो आपके लिए डाइस को रोल करने का काम करे. हर बार डाइस घुमाने पर, नतीजा संभावित वैल्यू की रेंज में कोई भी संख्या हो सकती है. हालांकि, इस तरह के प्रोग्राम के लिए आपको अपना रैंडम नंबर जनरेटर बनाने की ज़रूरत नहीं है. Kotlin जैसी ज़्यादातर प्रोग्रामिंग लैंग्वेज में, रैंडम नंबर जनरेट करने का तरीका पहले से मौजूद होता है. इस टास्क में, आपको Kotlin कोड का इस्तेमाल करके कोई रैंडम नंबर जनरेट करना होगा.

स्टार्टर कोड सेट अप करना

अपने ब्राउज़र में, https://try.kotlinlang.org/ वेबसाइट खोलें.
कोड एडिटर में मौजूद सभी कोड मिटाएं और उसे यहां दिए गए कोड से बदलें. यह वही main() फ़ंक्शन है जिसका इस्तेमाल आपने पिछले कोडलैब में किया था. (अपना पहला Kotlin प्रोग्राम लिखें कोडलैब देखें).

fun main() {

}

रैंडम फ़ंक्शन का इस्तेमाल करना

डाइस रोल करने के लिए, आपको डाइस रोल की सभी मान्य वैल्यू दिखाने का तरीका चाहिए. छह साइड वाले डाइस के लिए, ये डाइस रोल स्वीकार किए जाते हैं: 1, 2, 3, 4, 5, और 6.

आपको पहले बताया गया था कि पूर्णांक संख्याओं के लिए Int और टेक्स्ट के लिए String जैसे डेटा टाइप होते हैं. IntRange एक और डेटा टाइप है. यह किसी शुरुआती पॉइंट से लेकर आखिरी पॉइंट तक की पूर्णांक संख्याओं की रेंज को दिखाता है. IntRange, डाइस रोल से मिलने वाली संभावित वैल्यू को दिखाने के लिए सही डेटा टाइप है.

अपने main() फ़ंक्शन में, val को diceRange के तौर पर वैरिएबल के तौर पर तय करें. इसे 1 से 6 तक की किसी IntRange को असाइन करें. इससे पूर्णांक संख्याओं की उस रेंज के बारे में पता चलता है जिसे छह साइड वाला डाइस रोल कर सकता है.

val diceRange = 1..6

1..6 एक Kotlin रेंज है, क्योंकि इसमें एक शुरुआती संख्या, दो बिंदु, और उसके बाद एक आखिरी संख्या है. इनके बीच कोई स्पेस नहीं है. पूर्णांकों की रेंज के अन्य उदाहरणों में, 2 से 5 तक की संख्याओं के लिए 2..5 और 100 से 200 तक की संख्याओं के लिए 100..200 शामिल हैं.

जिस तरह println() को कॉल करने पर सिस्टम को दिए गए टेक्स्ट को प्रिंट करने का निर्देश मिलता है उसी तरह, random() नाम के फ़ंक्शन का इस्तेमाल करके, दी गई सीमा के लिए कोई रैंडम नंबर जनरेट किया जा सकता है और उसे वापस लाया जा सकता है. पहले की तरह, नतीजे को किसी वैरिएबल में सेव किया जा सकता है.

main() के अंदर, randomNumber नाम के वैरिएबल को val के तौर पर तय करें.
नीचे दिए गए उदाहरण में दिखाए गए तरीके से, randomNumber को diceRange रेंज पर random() को कॉल करने के नतीजे की वैल्यू के तौर पर सेट करें.

 val randomNumber = diceRange.random()

ध्यान दें कि वैरिएबल और फ़ंक्शन कॉल के बीच अवधि या डॉट का इस्तेमाल करके, random() पर random() को कॉल किया जा रहा है.diceRange इसे "diceRange से रैंडम नंबर जनरेट करना" के तौर पर पढ़ा जा सकता है. इसके बाद, नतीजे को randomNumber वैरिएबल में सेव किया जाता है.

रैंडम तरीके से जनरेट किया गया नंबर देखने के लिए, स्ट्रिंग फ़ॉर्मैटिंग नोटेशन (इसे "स्ट्रिंग टेंप्लेट" भी कहा जाता है) ${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 क्लास को परिभाषित करना

यहां दिए गए चरणों में, Dice नाम की एक नई क्लास तय की जाएगी. यह क्लास, रोल किए जा सकने वाले डाइस को दिखाएगी.

शुरुआत से शुरू करने के लिए, main() फ़ंक्शन में मौजूद कोड को मिटा दें, ताकि आपको नीचे दिखाया गया कोड मिल सके.

fun main() {

}

इस main() फ़ंक्शन के नीचे एक खाली लाइन जोड़ें. इसके बाद, Dice क्लास बनाने के लिए कोड जोड़ें. नीचे दिए गए उदाहरण में दिखाया गया है कि class कीवर्ड से शुरुआत करें. इसके बाद, क्लास का नाम लिखें. इसके बाद, ओपनिंग और क्लोज़िंग कर्ली ब्रेस लगाएं. क्लास के लिए कोड डालने के लिए, कर्ली ब्रेसिज़ के बीच में जगह छोड़ें.

class Dice {

}

ध्यान दें:

Kotlin में नया फ़ंक्शन बनाने के लिए, fun कीवर्ड का इस्तेमाल किया जाता है. इसी तरह, नई क्लास बनाने के लिए class कीवर्ड का इस्तेमाल करें.
class के लिए कोई भी नाम चुना जा सकता है. हालांकि, अगर नाम से यह पता चलता है कि क्लास किस बारे में है, तो यह मददगार होता है. परंपरा के मुताबिक, क्लास का नाम कैमल केस में होता है. उदाहरण के लिए: Car, ParkingMeter, और CustomerRecord, सभी मान्य क्लास नेम हैं. साथ ही, इनसे यह अंदाज़ा लगाया जा सकता है कि ये क्या दिखाते हैं.

क्लास की परिभाषा में, वैरिएबल का इस्तेमाल करके क्लास के लिए एक या एक से ज़्यादा प्रॉपर्टी तय की जा सकती हैं. असली डाइस में कई साइड, रंग या वज़न हो सकता है. इस टास्क में, आपको डाइस की साइड की संख्या पर फ़ोकस करना होगा.

Dice क्लास में, var नाम का एक sides जोड़ें. इससे पता चलेगा कि आपके डाइस में कितनी साइड होंगी. sides को 6 पर सेट करें.

class Dice {
    var sides = 6
}

हो गया. अब आपके पास डाइस को दिखाने वाली एक बहुत ही आसान क्लास है.

Dice क्लास का इंस्टेंस बनाना

इस Dice क्लास की मदद से, आपको डाइस का ब्लूप्रिंट मिलता है. अपने प्रोग्राम में डाइस का इस्तेमाल करने के लिए, आपको Dice ऑब्जेक्ट इंस्टेंस बनाना होगा. (अगर आपको तीन डाइस की ज़रूरत है, तो आपको तीन ऑब्जेक्ट इंस्टेंस बनाने होंगे.)

Dice का ऑब्जेक्ट इंस्टेंस बनाने के लिए, main() फ़ंक्शन में val नाम का एक ऑब्जेक्ट बनाएं और उसे Dice क्लास के इंस्टेंस के तौर पर शुरू करें.myFirstDice क्लास के नाम के बाद मौजूद ब्रैकेट पर ध्यान दें. इनसे पता चलता है कि क्लास से नया ऑब्जेक्ट इंस्टेंस बनाया जा रहा है.

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

अब आपके पास myFirstDice ऑब्जेक्ट है, जो ब्लूप्रिंट से बनाया गया है. इसलिए, इसकी प्रॉपर्टी ऐक्सेस की जा सकती हैं. Dice की सिर्फ़ एक प्रॉपर्टी होती है, जो कि sides है. किसी प्रॉपर्टी को ऐक्सेस करने के लिए, "डॉट नोटेशन" का इस्तेमाल किया जाता है. इसलिए, myFirstDice की sides प्रॉपर्टी को ऐक्सेस करने के लिए, myFirstDice.sides को कॉल किया जाता है. इसे "myFirstDice डॉट sides" पढ़ा जाता है.

myFirstDice के एलान के नीचे, println() स्टेटमेंट जोड़कर myFirstDice. के sides की संख्या आउटपुट करें

println(myFirstDice.sides)

आपका कोड ऐसा दिखना चाहिए.

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

class Dice {
    var sides = 6
}

अपने प्रोग्राम को चलाएं. इससे Dice क्लास में तय किए गए sides की संख्या का आउटपुट मिलना चाहिए.

अब आपके पास Dice क्लास और 6 sides वाला एक डाइस myFirstDice है.

चलो, पासा फेंकते हैं!

पासा फेंकना

आपने पहले केक की लेयर प्रिंट करने के लिए किसी फ़ंक्शन का इस्तेमाल किया था. डाइस को घुमाना भी एक ऐसी कार्रवाई है जिसे फ़ंक्शन के तौर पर लागू किया जा सकता है. सभी डाइस को रोल किया जा सकता है. इसलिए, Dice क्लास में इसके लिए एक फ़ंक्शन जोड़ा जा सकता है. किसी क्लास में तय किए गए फ़ंक्शन को तरीका भी कहा जाता है.

Dice क्लास में, sides वैरिएबल के नीचे एक खाली लाइन डालें. इसके बाद, डाइस को रोल करने के लिए एक नया फ़ंक्शन बनाएं. Kotlin कीवर्ड fun से शुरू करें. इसके बाद, तरीके का नाम लिखें. इसके बाद, ब्रैकेट () लगाएं. इसके बाद, कर्ली ब्रेसिज़ {} लगाएं. नीचे दिए गए उदाहरण में दिखाया गया है कि कर्ली ब्रेसिज़ के बीच में एक खाली लाइन छोड़ी जा सकती है, ताकि ज़्यादा कोड जोड़ा जा सके. आपकी क्लास ऐसी दिखनी चाहिए.

class Dice {
    var sides = 6

    fun roll() {

    }
}

ध्यान दें: इस तरीके का नाम अपनी पसंद के मुताबिक रखा जा सकता है. हालांकि, इसका नाम ऐसा रखना फ़ायदेमंद होता है जिससे पता चले कि यह कौनसी कार्रवाई करता है. फ़ंक्शन और तरीकों के नाम रखने के लिए, इन नियमों का पालन किया जाता है: नाम की शुरुआत छोटे अक्षर से करें, कैमल केस का इस्तेमाल करें, और अगर हो सके, तो ऐक्शन वर्ब से शुरुआत करें.

छह साइड वाले डाइस को रोल करने पर, 1 से 6 के बीच कोई भी नंबर मिलता है.

roll() तरीके के अंदर, val randomNumber बनाएं. इसे 1..6 रेंज में कोई भी नंबर असाइन करें. रेंज पर random() को कॉल करने के लिए, डॉट नोटेशन का इस्तेमाल करें.

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

बिना किसी क्रम के नंबर जनरेट करने के बाद, उसे कंसोल पर प्रिंट करें. आपका पूरा किया गया roll() तरीका, नीचे दिए गए कोड की तरह दिखना चाहिए.

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

myFirstDice को रोल करने के लिए, main() में myFirstDice पर roll() वाले तरीके को कॉल करें. "डॉट नोटेशन" का इस्तेमाल करके, किसी तरीके को कॉल किया जाता है. इसलिए, myFirstDice के roll() तरीके को कॉल करने के लिए, 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 फ़ंक्शन में randomNumber की वैल्यू प्रिंट की है. यह बहुत अच्छा काम कर रहा है!roll() हालांकि, कभी-कभी किसी फ़ंक्शन के नतीजे को उस फ़ंक्शन को कॉल करने वाले कोड में वापस भेजना ज़्यादा फ़ायदेमंद होता है. उदाहरण के लिए, roll() तरीके के नतीजे को किसी वैरिएबल को असाइन किया जा सकता है. इसके बाद, उस वैरिएबल की वैल्यू के हिसाब से किसी प्लेयर को आगे बढ़ाया जा सकता है! आइए, देखते हैं कि ऐसा कैसे किया जाता है.

main() में जाकर, myFirstDice.roll() वाली लाइन में बदलाव करें. diceRoll नाम का val बनाएं. इसे roll() तरीके से मिली वैल्यू के बराबर सेट करें.

val diceRoll = myFirstDice.roll()

roll() फ़ंक्शन अभी कुछ भी रिटर्न नहीं करता है. इसलिए, इस कोड से अभी कुछ भी नहीं होगा. इस कोड के सही तरीके से काम करने के लिए, roll() को कुछ वैल्यू दिखानी होगी.

पिछले कोडलैब में आपने सीखा था कि फ़ंक्शन के इनपुट आर्ग्युमेंट के लिए, डेटा टाइप तय करना ज़रूरी होता है. इसी तरह, आपको उस डेटा के लिए डेटा टाइप तय करना होगा जो कोई फ़ंक्शन दिखाता है.

roll() फ़ंक्शन को बदलकर यह तय करें कि किस तरह का डेटा दिखाया जाएगा. इस मामले में, रैंडम नंबर एक Int है. इसलिए, रिटर्न टाइप Int है. रिटर्न टाइप तय करने का सिंटैक्स यह है: फ़ंक्शन के नाम के बाद, ब्रैकेट के बाद, कोलन, स्पेस, और फिर फ़ंक्शन के रिटर्न टाइप के लिए Int कीवर्ड जोड़ें. फ़ंक्शन की परिभाषा, यहां दिए गए कोड की तरह दिखनी चाहिए.

fun roll(): Int {

इस कोड को चलाएं. आपको समस्याएं देखने की सुविधा में गड़बड़ी दिखेगी. इसमें लिखा है:

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

आपने फ़ंक्शन की डेफ़िनिशन को बदलकर Int कर दिया है, लेकिन सिस्टम को शिकायत है कि आपके

कोड से असल में Int नहीं मिलता है. "ब्लॉक बॉडी" या "फ़ंक्शन बॉडी" का मतलब, किसी फ़ंक्शन के कर्ली ब्रैकेट के बीच मौजूद कोड से है. इस गड़बड़ी को ठीक करने के लिए, फ़ंक्शन के मुख्य हिस्से के आखिर में return स्टेटमेंट का इस्तेमाल करके, फ़ंक्शन से वैल्यू दिखाई जा सकती है.

roll() में, println() स्टेटमेंट को हटाएं और उसकी जगह randomNumber के लिए return स्टेटमेंट जोड़ें. आपका 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
    }
}

सभी डाइस में छह साइड नहीं होती हैं! डाइस कई तरह के होते हैं: चार साइड वाले, आठ साइड वाले, और 120 साइड वाले डाइस भी होते हैं!

अपनी Dice क्लास में, अपनी roll() विधि में, हार्ड-कोड किए गए 1..6 को बदलकर sides का इस्तेमाल करें. इससे रेंज और इस तरह से रोल किया गया रैंडम नंबर, हमेशा साइड की संख्या के हिसाब से सही होगा.

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

main() फ़ंक्शन में, डाइस रोल प्रिंट करने के बाद और नीचे, myFirstDice के sides को बदलकर 20 पर सेट करें.

myFirstDice.sides = 20

नीचे दिए गए मौजूदा प्रिंट स्टेटमेंट को कॉपी करें और उसे उस जगह पर चिपकाएं जहां आपने साइड की संख्या में बदलाव किया है.
diceRoll को प्रिंट करने के बजाय, myFirstDice पर roll() वाले तरीके को कॉल करने के नतीजे को प्रिंट करें.

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

अपना प्रोग्राम चलाएं. आपको छह साइड वाले डाइस के लिए एक मैसेज और 20 साइड वाले डाइस के लिए दूसरा मैसेज दिखेगा.

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

क्लास का मकसद किसी चीज़ को दिखाना होता है. अक्सर, यह असल दुनिया में मौजूद कोई चीज़ होती है. इस मामले में, Dice क्लास, डाइस को दिखाती है. असल दुनिया में, पासे की साइड की संख्या नहीं बदली जा सकती. अगर आपको अलग-अलग संख्या वाली साइड चाहिए, तो आपको अलग डाइस लेना होगा. प्रोग्राम के हिसाब से इसका मतलब है कि आपको मौजूदा Dice ऑब्जेक्ट इंस्टेंस की sides प्रॉपर्टी बदलने के बजाय, अपनी ज़रूरत के हिसाब से साइड की संख्या वाला नया डाइस ऑब्जेक्ट इंस्टेंस बनाना चाहिए.

इस टास्क में, आपको Dice क्लास में बदलाव करना है, ताकि नया इंस्टेंस बनाते समय, साइड की संख्या तय की जा सके. Dice क्लास की परिभाषा में बदलाव करें, ताकि वह भुजाओं की संख्या के लिए आर्ग्युमेंट स्वीकार कर सके. यह ठीक उसी तरह काम करता है जिस तरह कोई फ़ंक्शन, इनपुट के लिए आर्ग्युमेंट स्वीकार करता है.

Dice क्लास की परिभाषा में बदलाव करके, numSides नाम के पूर्णांक आर्ग्युमेंट को स्वीकार करें. आपकी क्लास में मौजूद कोड नहीं बदलता.

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

Dice क्लास में, sides वैरिएबल को मिटा दें, क्योंकि अब numSides का इस्तेमाल किया जा सकता है.
साथ ही, numSides का इस्तेमाल करने के लिए रेंज ठीक करें.

आपकी Dice क्लास ऐसी दिखनी चाहिए.

class Dice (val numSides: Int) {

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

इस कोड को चलाने पर, आपको कई गड़बड़ियां दिखेंगी. ऐसा इसलिए, क्योंकि Dice क्लास में हुए बदलावों के साथ काम करने के लिए, आपको main() को अपडेट करना होगा.

main() में, छह साइड वाला myFirstDice बनाने के लिए, अब आपको 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}!")
}

डाइस रोल का पहला नतीजा प्रिंट करने के बाद, 20 साइड वाले mySecondDice नाम के दूसरे Dice ऑब्जेक्ट को बनाने और प्रिंट करने के लिए कोड जोड़ें.

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

दूसरे प्रिंट स्टेटमेंट में, आपने कॉल करके रैंडम नंबर को स्ट्रिंग टेंप्लेट में डाला है. पहले प्रिंट स्टेटमेंट में भी यही काम करके, diceRoll वैरिएबल से छुटकारा पाया जा सकता है.

स्ट्रिंग टेंप्लेट में myFirstDice.roll() को कॉल करें और diceRoll वैरिएबल को मिटाएं. आपके main() कोड की पहली दो लाइनें अब ऐसी दिखेंगी.

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

रैंडम नंबर जनरेट करने के लिए, IntRange पर random() फ़ंक्शन को कॉल करें: (1..6).random()
क्लास, किसी ऑब्जेक्ट के ब्लूप्रिंट की तरह होती हैं. इनमें प्रॉपर्टी और व्यवहार हो सकते हैं, जिन्हें वैरिएबल और फ़ंक्शन के तौर पर लागू किया जाता है.
क्लास का इंस्टेंस, किसी ऑब्जेक्ट को दिखाता है. यह अक्सर कोई फ़िज़िकल ऑब्जेक्ट होता है, जैसे कि डाइस. ऑब्जेक्ट पर कार्रवाइयां की जा सकती हैं और उसके एट्रिब्यूट बदले जा सकते हैं.
क्लास का इंस्टेंस बनाते समय, क्लास की परिभाषा के लिए कोई आर्ग्युमेंट तय करके, क्लास को इनपुट दिया जा सकता है. उदाहरण के लिए: class Dice(val numSides: Int) और फिर Dice(6) की मदद से एक इंस्टेंस बनाएं.
फ़ंक्शन कुछ वैल्यू रिटर्न कर सकते हैं. फ़ंक्शन की परिभाषा में, दिखाए जाने वाले डेटा टाइप के बारे में बताएं. साथ ही, फ़ंक्शन के मुख्य हिस्से में return स्टेटमेंट का इस्तेमाल करके कोई वैल्यू दिखाएं. उदाहरण के लिए: fun example(): Int { return 5 }

यह तरीका अपनाएं:

अपनी Dice क्लास को रंग का एक और एट्रिब्यूट दें. साथ ही, अलग-अलग रंगों और साइड वाले डाइस के कई इंस्टेंस बनाएं!
एक Coin क्लास बनाएं. इसमें टॉस करने की सुविधा जोड़ें. क्लास का एक इंस्टेंस बनाएं और कुछ सिक्कों को टॉस करें! सिक्का उछालने के लिए, किसी रेंज के साथ random() फ़ंक्शन का इस्तेमाल कैसे किया जाएगा?