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

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

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

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

पहले कोडलैब (कोड बनाना सीखना) में, आप Kotlin का ऐसा प्रोग्राम बना सकते हैं जो रोलिंग डाइस की तरह काम करता है. साथ ही, यह कोई भी रैंडम पासा बना सकता है, जैसे कि कोई पासा.

ज़रूरी बातें

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

आप इन चीज़ों के बारे में जानेंगे

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

आप क्या बनाएंगे #39;

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

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

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

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

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

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

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

fun main() {

}

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

कोई पासा फेंकने के लिए, आपको सभी मान्य पासे के मानों का प्रतिनिधित्व करने का एक तरीका चाहिए. 6-तरफ़ा पासे के सामान्य पासा के लिए मान्य पासे: 1, 2, 3, 4, 5, और 6.

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

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

val diceRange = 1..6

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

सलाह: ध्यान दें कि इस डेफ़िनिशन में IntRange नहीं बताया गया है, इसी तरह आपको किसी इंटेजर या स्ट्रिंग के लिए वैरिएबल बनाते समय, Int या String की जानकारी नहीं देनी पड़ती थी. ज़्यादातर मामलों में, सिस्टम यह पता लगा सकता है कि आपको किस तरह का डेटा चाहिए.

उदाहरण के लिए, सिस्टम इसे समझता है:

val diceRange = 1..6

इस तरह:

val diceRange: IntRange = 1..6

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

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

 val randomNumber = diceRange.random()

ध्यान दें कि आप वैरिएबल और फ़ंक्शन कॉल के बीच में एक विराम या बिंदु का इस्तेमाल करके diceRange को random() कॉल कर रहे हैं. आप इसे 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 साइड वाला पासा या चार तरफ़ वाला पासा बना सकते हैं.

सलाह: क्लास की तरह ही यह भी होता है कि आर्किटेक्ट और #39; ब्लूप्रिंट के प्लान घर नहीं होते. यह घर बनाने के निर्देश होते हैं. घर असल में या ऑब्जेक्ट इंस्टेंस है जो ब्लूप्रिंट के मुताबिक बनाया गया है.

ध्यान दें: किसी क्लास में पासे को व्यवस्थित करने को एनकैप्सुलेशन कहते हैं. एनकैप्सुलेशन एक बहुत बड़ा काल्पनिक शब्द है. हालांकि, इसका मतलब यह है कि आप एक ही जगह से जुड़े, फ़ंक्शन के हिसाब से डेटा को इकट्ठा कर सकते हैं.

पासा क्लास परिभाषित करें

नीचे दिए गए तरीके में, आप रोल करने लायक पासा दिखाने के लिए Dice नाम की नई क्लास तय करेंगे.

1. नए सिरे से शुरुआत करने के लिए, main() फ़ंक्शन से कोड को हटाएं, ताकि आप नीचे दिखाए गए कोड के हिसाब से कोड हासिल कर सकें.

fun main() {

}

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

class Dice {

}

ध्यान दें:

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

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

3. पासे की संख्या के लिए Dice क्लास के अंदर var नाम का sides जोड़ें. sides को 6 पर सेट करें.

class Dice {
    var sides = 6
}

बस इतना ही. अब आपके पास एक बहुत ही सरल क्लास है, जो पासा दिखा रही है.

पासे वाली क्लास का इंस्टेंस बनाना

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

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

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

अब आपके पास myFirstDice ऑब्जेक्ट है, जो ब्लूप्रिंट से बनाई गई है, इसलिए आप इसकी प्रॉपर्टी ऐक्सेस कर सकते हैं. Dice की अकेली प्रॉपर्टी sides है. आप & "बिंदु नोटेशन" का इस्तेमाल करके प्रॉपर्टी ऐक्सेस करते हैं. इसलिए, myFirstDice की sides प्रॉपर्टी को ऐक्सेस करने के लिए, आप myFirstDice.sides को कॉल करते हैं. इसे उच्चारण और कोटेशन कहा जाता है;myFirstDice बिंदु sides&कोट करें.

2. myFirstDice के एलान के नीचे, myFirstDice. के sides की संख्या दिखाने के लिए println() जोड़ें

println(myFirstDice.sides)

ध्यान दें: diceRange.random() को कॉल करने से पहले, आपने डॉट नोटेशन का इस्तेमाल किया था. सामान्य तौर पर, आप डॉट नोटेशन को इस तरह बोल सकते हैं कि किसी बिंदु पर "कोई कार्रवाई करने के लिए कोट" कहें. जैसे, myFirstDice.sides के साथ &इस कोटेशन पर, sides प्रॉपर्टी पाएं&कोटेशन.

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

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

class Dice {
    var sides = 6
}

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

6

अब आपके पास Dice क्लास है और असल में पासा है myFirstDice जिसमें 6 sides हैं.

पासा फेंकने दें!

पासा फेंकें

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

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

class Dice {
    var sides = 6

    fun roll() {

    }
}

ध्यान दें: आप इस तरीके को अपनी पसंद का कोई भी नाम दे सकते हैं, लेकिन इस नाम से यह पता चलता है कि यह क्या कार्रवाई करता है. फ़ंक्शन और मेथड के लिए नाम रखने की परंपरा एक लोअरकेस अक्षर से शुरू करना, ऊंट के केस का इस्तेमाल करना, और अगर हो सके, तो कार्रवाई की क्रिया के साथ शुरू करना है.

जब आप छह-तरफ़ा पासा फेंकते हैं, तो यह 1 से 6 के बीच की कोई संख्या बनाता है.

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

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

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

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

4. main() को myFirstDice पर चलाने के लिए, 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)
    }
}

5. अपना कोड चलाएं! आपको किनारों की संख्या के नीचे किसी भी क्रम में पासे के नतीजे दिखेंगे. अपना कोड कई बार चलाएं और ध्यान दें कि पक्षों की संख्या एक जैसी रहती है और पासा फेंकने का मान बदल जाता है.

6
4

बधाई हो! आपने Dice वैरिएबल को, sides वैरिएबल और roll() फ़ंक्शन के साथ तय किया है. main() फ़ंक्शन में, आपने एक नया Dice ऑब्जेक्ट इंस्टेंस बनाया और फिर रैंडम नंबर बनाने के लिए, आपने उस पर roll() तरीका अपनाया.

फ़िलहाल, आप अपने roll() फ़ंक्शन में randomNumber की वैल्यू प्रिंट कर रहे हैं और यह बहुत अच्छी तरह काम कर रही है! हालांकि, कभी-कभी यह फ़ंक्शन के नतीजे को फ़ंक्शन नाम देने के लिए, ज़्यादा काम का होता है. उदाहरण के लिए, roll() वैरिएबल का नतीजा, वैरिएबल में असाइन किया जा सकता है. इसके बाद, खिलाड़ी को उस रकम तक ले जाया जा सकता है! आइए, देखें कि यह कैसे किया जाता है.

1. main() में myFirstDice.roll() बताने वाली लाइन में बदलाव करें. diceRoll नाम का val बनाएं. इसे roll() तरीके से लौटाए गए मान के बराबर सेट करें.

val diceRoll = myFirstDice.roll()

यह अभी तक कुछ नहीं करता, क्योंकि roll() अभी तक कुछ नहीं रिटर्न करता है. यह कोड ठीक से काम कर सके, इसके लिए roll() को कुछ रिटर्न करना होगा.

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

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

fun roll(): Int {

3. यह कोड चलाएं. आपको समस्याएं व्यू में, गड़बड़ी का एक मैसेज दिखेगा. नोट में यह जानकारी दी गई है:

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

आपने फ़ंक्शन रिटर्न के लिए Int सेट किया है, लेकिन सिस्टम शिकायत कर रहा है कि

कोड असल में Int नहीं दिखाता. & कोटेशन</body> या शरीर का &कोटेशन करें; या फ़ंक्शन की बॉडी कर्ली ब्रैकेट को कोड में बदलें. आप फ़ंक्शन के मुख्य हिस्से के आखिर में return स्टेटमेंट का इस्तेमाल करके, किसी फ़ंक्शन से मान डालकर यह गड़बड़ी ठीक कर सकते हैं.

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

सभी पासे के छह हिस्से नहीं होते! पासे सभी आकार और साइज़ में उपलब्ध होते हैं: चार साइड, 8 साइड, ज़्यादा से ज़्यादा 120 साइड!

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

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

2. main() फ़ंक्शन में, नीचे से पासे के प्रिंट प्रिंट करने के बाद, sides के FirstDice को 20 पर सेट करें.

myFirstDice.sides = 20

3. नीचे दिए गए प्रिंट स्टेटमेंट को कॉपी करके वहां चिपकाएं, जहां आपने नतीजों की संख्या बदली थी.
4. myFirstDice पर roll() वाले तरीके को कॉल करने के नतीजे का प्रिंट लेने के लिए, diceRoll की प्रिंटिंग को बदलें.

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-तरफ़ा पासे के लिए एक मैसेज और 20-तरफ़ा पासे के लिए दूसरा मैसेज दिखेगा.

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

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

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

1. numSides नाम के पूर्णांक तर्क को स्वीकार करने के लिए Dice क्लास डेफ़िनिशन को बदलें. आपकी कक्षा के कोड में कोई बदलाव नहीं होता.

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

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

4. main() में, myFirstDice को छह साइड के साथ बनाने के लिए, अब आपको 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. पहला पासा रोल प्रिंट करने के बाद, mySecondDice नाम का दूसरा Dice ऑब्जेक्ट बनाने और प्रिंट करने के लिए कोड जोड़ें. इस ऑब्जेक्ट के 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()
    }

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

2. स्ट्रिंग टेंप्लेट में myFirstDice.roll() को कॉल करें और diceRoll वैरिएबल मिटाएं. आपके 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()
    }
}

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

• रैंडम नंबर जनरेशन (Wikipedia)
• द 120 साइड वाले डाइस को डिज़ाइन करने का माइंड-बुलिंग चैलेंज
• Kotlin में क्लास
• Kotlin में फ़ंक्शन के बारे में एलान
• फ़ंक्शन से वैल्यू देना

ध्यान दें: प्रैक्टिस वैकल्पिक हैं. इनसे आपको उस कोड का अभ्यास करने में मदद मिलती है जो आपने इस कोडलैब में सीखा है.

ये करें:

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