کلاس ها و نمونه های شی در Kotlin

برای کدهای موجود در این مسیر، یک برنامه اندرویدی Dice Roller خواهید ساخت. هنگامی که کاربر تاس می اندازد، یک نتیجه تصادفی ایجاد می شود. نتیجه تعداد اضلاع تاس را در نظر می گیرد. به عنوان مثال، فقط مقادیر 1-6 را می توان از یک تاس 6 وجهی ریخت.

این چیزی است که برنامه نهایی شبیه به آن خواهد بود.

برای کمک به تمرکز بر مفاهیم برنامه نویسی جدید برای این برنامه، از ابزار برنامه نویسی Kotlin مبتنی بر مرورگر برای ایجاد عملکرد اصلی برنامه استفاده خواهید کرد. این برنامه نتایج شما را به کنسول ارسال می کند. بعداً رابط کاربری را در اندروید استودیو پیاده سازی خواهید کرد.

در این اولین کد لبه، شما یک برنامه Kotlin ایجاد خواهید کرد که ریختن تاس را شبیه سازی می کند و یک عدد تصادفی تولید می کند، درست مانند یک تاس.

پیش نیازها

• نحوه باز کردن، ویرایش و اجرای کد در https://try.kotlinlang.org/
• یک برنامه Kotlin ایجاد و اجرا کنید که از متغیرها و توابع استفاده می کند و نتیجه را در کنسول چاپ می کند.
• اعداد را در متن با استفاده از یک الگوی رشته ای با نماد ${variable} قالب بندی کنید.

چیزی که یاد خواهید گرفت

• نحوه تولید اعداد تصادفی برای شبیه سازی تاس به صورت برنامه ای
• چگونه کد خود را با ایجاد یک کلاس Dice با یک متغیر و یک متد ساختار دهید.
• نحوه ایجاد یک نمونه شی از یک کلاس، تغییر متغیرهای آن و فراخوانی متدهای آن.

چیزی که خواهی ساخت

• یک برنامه Kotlin در ابزار برنامه نویسی Kotlin مبتنی بر مرورگر که می تواند یک تاس تصادفی را انجام دهد.

آنچه شما نیاز دارید

• یک کامپیوتر با اتصال به اینترنت

بازی ها اغلب دارای یک عنصر تصادفی هستند. شما می توانید یک جایزه تصادفی کسب کنید یا تعدادی مرحله تصادفی را در صفحه بازی پیش ببرید. در زندگی روزمره خود، می توانید از اعداد و حروف تصادفی برای ایجاد رمزهای عبور امن تر استفاده کنید!

به جای انداختن تاس واقعی، می توانید برنامه ای بنویسید که ریختن تاس را برای شما شبیه سازی می کند. هر بار که تاس می اندازید، نتیجه می تواند هر عددی در محدوده مقادیر ممکن باشد. خوشبختانه، برای چنین برنامه ای نیازی به ساخت مولد اعداد تصادفی خود ندارید. اکثر زبان‌های برنامه‌نویسی، از جمله کاتلین، یک روش داخلی برای تولید اعداد تصادفی دارند. در این کار از کد Kotlin برای تولید یک عدد تصادفی استفاده خواهید کرد.

کد شروع خود را تنظیم کنید

1. در مرورگر خود، وب سایت https://try.kotlinlang.org/ را باز کنید.
2. تمام کدهای موجود در ویرایشگر کد را حذف کرده و کد زیر را جایگزین آن کنید. این تابع main() main است که در کد لبه‌های قبلی با آن کار می‌کردید (به نوشتن اولین کد برنامه 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 یک محدوده کاتلین است زیرا دارای یک عدد شروع، دو نقطه و به دنبال آن یک عدد پایانی است (بدون فاصله در بین). نمونه های دیگر محدوده اعداد صحیح 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. همانطور که در زیر نشان داده شده است، مقدار نتیجه فراخوانی random() را در محدوده randomNumber 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() .

وقتی تاس می اندازید، آنها اشیای واقعی در دستان شما هستند. در حالی که کدی که نوشتید کاملاً خوب کار می کند، تصور اینکه در مورد تاس واقعی باشد دشوار است. سازماندهی یک برنامه به گونه ای که بیشتر شبیه چیزهایی باشد که نشان می دهد، درک آن را آسان تر می کند. بنابراین، داشتن تاس های برنامه ای که می توانید آنها را بیاندازید، جالب است!

همه تاس ها اساسا یکسان کار می کنند. آنها خواص یکسانی دارند، مانند کناره ها، و رفتار یکسانی دارند، مانند اینکه می توان آنها را رول کرد. در کاتلین، می‌توانید یک طرح برنامه‌ای از یک تاس ایجاد کنید که می‌گوید تاس‌ها دو طرف دارند و می‌توانند یک عدد تصادفی بیاندازند. این طرح اولیه کلاس نامیده می شود.

از آن کلاس، سپس می توانید اشیاء تاس واقعی ایجاد کنید که به آنها نمونه های شیء می گویند. به عنوان مثال، می توانید یک تاس 12 وجهی یا یک تاس 4 وجهی ایجاد کنید.

نکته: یک کلاس شبیه به این است که چگونه نقشه های یک معمار خانه نیستند. آنها دستورالعمل چگونگی ساخت خانه هستند. خانه همان چیز یا شی واقعی است که بر اساس طرح اولیه ایجاد شده است.

توجه: سازماندهی همه چیز در مورد تاس در یک کلاس، کپسولاسیون نامیده می شود. کپسوله کردن یک کلمه فانتزی بزرگ است، اما تمام معنی آن این است که شما می توانید عملکردهایی را که به طور منطقی به یک مکان مرتبط هستند محصور کنید.

کلاس Dice را تعریف کنید

در مراحل زیر یک کلاس جدید به نام Dice برای نمایش یک تاس قابل ریختن تعریف خواهید کرد.

1. برای شروع مجدد، کد موجود در تابع main() را پاک کنید تا در نهایت به کدی مانند شکل زیر برسید.

fun main() {

}

2. زیر این تابع main() یک خط خالی اضافه کنید و سپس کدی را برای ایجاد کلاس Dice اضافه کنید. همانطور که در زیر نشان داده شده است، با کلمه کلیدی class شروع کنید، به دنبال آن نام کلاس و به دنبال آن یک بریس باز و بسته می شود. بین پرانتزهای فرفری فاصله بگذارید تا کد خود را برای کلاس قرار دهید.

class Dice {

}

توجه داشته باشید:

• مشابه استفاده از کلمه کلیدی fun در Kotlin برای ایجاد یک تابع جدید، از کلمه کلیدی class برای ایجاد یک کلاس جدید استفاده کنید.
• شما می توانید هر نامی را برای یک class انتخاب کنید، اما اگر نام نشان دهد که کلاس چه چیزی را نشان می دهد مفید است. طبق قرارداد، نام کلاس در مورد شتر است. به عنوان مثال: Car , ParkingMeter و CustomerRecord همگی نام کلاس معتبر هستند و شما می توانید حدس بزنید که آنها چه چیزی را نشان می دهند.

در تعریف کلاس، می‌توانید یک یا چند ویژگی برای کلاس با استفاده از متغیرها مشخص کنید. تاس واقعی می تواند تعدادی ضلع، رنگ یا وزن داشته باشد. در این کار، روی خاصیت تعداد اضلاع تاس تمرکز خواهید کرد.

3. در داخل کلاس Dice ، یک var به نام sides برای تعداد اضلاع تاس خود اضافه کنید. sides را روی 6 قرار دهید.

class Dice {
    var sides = 6
}

خودشه. شما اکنون یک کلاس بسیار ساده دارید که نشان دهنده تاس است.

یک نمونه از کلاس Dice ایجاد کنید

با استفاده از این کلاس Dice ، شما یک طرح اولیه از اینکه تاس چیست دارید. برای داشتن یک تاس واقعی در برنامه خود، باید یک نمونه شی Dice ایجاد کنید. (و اگر نیاز به داشتن سه تاس داشتید، سه نمونه شی ایجاد می کنید.)

1. برای ایجاد یک نمونه شی از Dice ، در تابع main() یک val به نام myFirstDice ایجاد کنید و آن را به عنوان نمونه ای از کلاس Dice مقداردهی کنید. به پرانتزهای بعد از نام کلاس توجه کنید که نشان می دهد شما در حال ایجاد یک نمونه شی جدید از کلاس هستید.

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

اکنون که یک شی myFirstDice ، چیزی که از طرح اولیه ساخته شده است، می توانید به ویژگی های آن دسترسی داشته باشید. تنها خاصیت Dice sides آن است. شما با استفاده از "نقطه" به یک ویژگی دسترسی پیدا می کنید. بنابراین، برای دسترسی به ویژگی sides myFirstDice ، myFirstDice.sides را فراخوانی می کنید که " myFirstDice dot sides " تلفظ می شود.

2. در زیر اعلان myFirstDice ، یک دستور println() اضافه کنید تا تعداد 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 استفاده کنید و در صورت امکان با یک فعل عمل شروع کنید.

وقتی یک تاس شش طرفه می اندازید، عددی تصادفی بین 1 تا 6 تولید می کند.

2. در داخل متد roll() یک val randomNumber ایجاد کنید. به آن یک عدد تصادفی در محدوده 1..6 اختصاص دهید. از نماد نقطه برای فراخوانی random() در محدوده استفاده کنید.

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

3. پس از تولید عدد تصادفی، آن را در کنسول چاپ کنید. متد roll() finished شما باید شبیه کد زیر باشد.

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

4. برای رول myFirstDice ، در main() ، متد roll() را در myFirstDice کنید. شما یک روش را با استفاده از "نقطه نقطه" فراخوانی می کنید. بنابراین، برای فراخوانی متد roll() myFirstDice ، باید myFirstDice.roll() را تایپ کنید که " myFirstDice dot 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. کد خود را اجرا کنید! شما باید نتیجه یک تاس تصادفی را زیر تعداد اضلاع ببینید. کد خود را چندین بار اجرا کنید و متوجه شوید که تعداد اضلاع ثابت می ماند و مقدار تاس roll تغییر می کند.

6
4

تبریک می گویم! شما یک کلاس Dice را با متغیر sides و تابع roll() تعریف کرده اید. در تابع main() یک نمونه شی Dice جدید ایجاد کردید و سپس متد roll() را روی آن فراخوانی کردید تا یک عدد تصادفی تولید کنید.

در حال حاضر شما در حال چاپ مقدار randomNumber در تابع roll() خود هستید و عالی کار می کند! اما گاهی اوقات مفیدتر است که نتیجه یک تابع را به هر تابعی که تابع نامیده می شود برگردانیم. به عنوان مثال، می توانید نتیجه متد roll() را به یک متغیر اختصاص دهید و سپس یک بازیکن را با آن مقدار حرکت دهید! بیایید ببینیم چگونه این کار انجام می شود.

1. در main() خطی که می گوید myFirstDice.roll() را تغییر دهید. یک val به نام diceRoll کنید. آن را برابر با مقدار بازگردانده شده توسط متد 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 را بر نمی گرداند. "بدنه بلوک" یا "بدنه عملکرد" ​​به کد بین پرانتزهای فرفری یک تابع اشاره دارد. شما می توانید این خطا را با برگرداندن مقداری از یک تابع با استفاده از عبارت return در انتهای بدنه تابع برطرف کنید.

4. در roll() عبارت println() را حذف کرده و با عبارت return برای randomNumber کنید. تابع roll() شما باید شبیه کد زیر باشد.

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

5. در main() دستور print را برای طرفین تاس حذف کنید.
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 FirstDice من را به 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 وجهی و یک پیام دوم برای تاس 20 وجهی ببینید.

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

ایده کلاس این است که یک چیز را نشان دهد، اغلب چیزی فیزیکی در دنیای واقعی. در این مورد، یک کلاس Dice یک تاس فیزیکی را نشان می دهد. در دنیای واقعی، تاس ها نمی توانند تعداد اضلاع خود را تغییر دهند. اگر تعداد اضلاع متفاوتی می خواهید، باید یک تاس متفاوت بگیرید. از نظر برنامه‌ریزی، این بدان معناست که به جای تغییر ویژگی sides یک نمونه شی 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
    }
}

اگر این کد را اجرا کنید، خطاهای زیادی خواهید دید، زیرا برای کار با تغییرات کلاس Dice باید main() را به روز کنید.

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 به نام 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()
    }

در دستور چاپ دوم، شما تماس را برای دریافت عدد تصادفی در قالب رشته قرار می دهید. می توانید با انجام همین کار در اولین دستور چاپ، از شر متغیر diceRoll خلاص شوید.

2. myFirstDice.roll() را در قالب رشته فراخوانی کنید و متغیر diceRoll را حذف کنید. دو خط اول کد ()main شما به این شکل است.

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

3. کد خود را اجرا کنید و هیچ تفاوتی در خروجی وجود ندارد.

توجه: تغییر کد به منظور کوتاه‌تر، کارآمدتر کردن یا آسان‌تر خواندن و درک کردن آن را Refactoring می‌گویند. این مانند نوشتن یک سند است که در آن ابتدا یک پیش نویس می نویسید که تمام اطلاعات را در خود دارد و سپس کلمات خود را ویرایش و اصلاح می کنید.

این کد نهایی شما پس از فاکتورسازی مجدد آن است.

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 طرفه
• کلاس ها در کاتلین
• اعلامیه های عملکرد در کاتلین
• برگرداندن یک مقدار از یک تابع

توجه: تمرینات اختیاری است. آنها فرصتی را برای شما فراهم می کنند تا آنچه را که در این نرم افزار یاد گرفته اید تمرین کنید.

موارد زیر را انجام دهید:

• به کلاس Dice خود ویژگی دیگری از رنگ بدهید و نمونه های متعددی از تاس با تعداد اضلاع و رنگ های مختلف ایجاد کنید!
• یک کلاس Coin ایجاد کنید، به آن توانایی تلنگر بدهید، یک نمونه از کلاس ایجاد کنید و چند سکه را برگردانید! چگونه از تابع تصادفی () با یک محدوده برای انجام چرخش سکه استفاده می کنید؟