الفئات ومثيلات العناصر بلغة Kotlin

بالنسبة إلى الدروس التطبيقية حول الترميز في هذا المسار، ستنشئ تطبيق Dice Roller المتوافق مع Android. وعندما يحرك المستخدم هذه &النرد، سيتم إنشاء نتيجة عشوائية. وتأخذ النتيجة في الاعتبار عدد جوانب النرد. على سبيل المثال، لا يمكن تدوير سوى القيم من 1 إلى 6 من نرد ذي 6 أوجه.

هذا هو الشكل الذي سيظهر به التطبيق النهائي.

لمساعدتك في التركيز على مفاهيم البرمجة الجديدة لهذا التطبيق، ستستخدم أداة برمجة Kotlin المستندة إلى المتصفح لإنشاء وظائف التطبيق الأساسية. سيخرج البرنامج النتائج إلى وحدة التحكم. ويمكنك لاحقًا تنفيذ واجهة المستخدم في "استوديو Android".

في هذا الدرس التطبيقي حول الترميز، ستنشئ برنامجًا بلغة Kotlin يحاكي رقم نرد الزهر ويُخرج رقمًا عشوائيًا مثلما يفعل النرد.

المتطلّبات الأساسية

• كيفية فتح الرمز وتعديله وتشغيله في https://try.kotlinlang.org/
• إنشاء وتشغيل برنامج Kotlin الذي يستخدم المتغيرات والوظائف، ويطبع نتيجة لوحدة التحكم.
• يمكنك تنسيق الأرقام داخل نص باستخدام نموذج سلسلة يتضمن علامة ${variable}.

ما ستتعرَّف عليه

• كيفية إنشاء أرقام عشوائية آليًا لمحاكاة دفاتر نرد
• كيفية تنظيم بنية الرمز الخاص بك عن طريق إنشاء صف Dice مع متغير وطريقة.
• كيفية إنشاء مثيل الكائن من صف، وتعديل المتغيرات، واستدعاء أساليبه.

العناصر التي سيتم إنشاؤها

• برنامج Kotlin في أداة البرمجة Kotlin المستندة إلى المتصفّح والتي يمكنها تنفيذ لفة النرد العشوائية.

ما تحتاج إليه

• جهاز كمبيوتر متصل بالإنترنت

وتحتوي الألعاب عادةً على عنصر عشوائي. ويمكنك الحصول على جائزة عشوائية أو التقدّم لعدد عشوائي من الخطوات على لوحة اللعبة. في حياتك اليومية، يمكنك استخدام أرقام وأحرف عشوائية لإنشاء كلمات مرور أكثر أمانًا.

بدلاً من إرسال حجر نرد، يمكنك كتابة برنامج يحاكي نرد الزهر. في كل مرة تطرح فيها النرد، يمكن أن تكون النتيجة أي رقم ضمن نطاق القيم المحتملة. لحسن الحظ، لا تحتاج إلى إنشاء مُنشئ أرقام عشوائي لهذا البرنامج. معظم لغات البرمجة، بما في ذلك لغة Kotlin، تتضمن طريقة مضمّنة لإنشاء أرقام عشوائية. في هذه المَهمّة، ستستخدم رمز Kotlin لإنشاء رقم عشوائي.

إعداد رمز التفعيل

1. في المتصفِّح، افتح الموقع الإلكتروني https://try.kotlinlang.org/.
2. حذف جميع الرموز الحالية في محرِّر الرموز واستبدالها بالرمز التالي. هذه هي دالة main() التي عملت معها في درس تطبيقي سابق حول الترميز (يُرجى الاطّلاع على كتابة برنامج Kotlin الأول).

fun main() {

}

استخدام الدالة العشوائية

لرمي حجر نرد، تحتاج إلى طريقة لتمثيل جميع قيم نرد النرد الصالحة. بالنسبة إلى النرد العادي ذي الجوانب الست، تكون لفات النرد المقبولة هي: 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..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، ولكن من المفيد أن يشير الاسم إلى ما تمثّله الفئة. ووفقًا للاصطلاح، يتمّ استخدام اسم الفئة في حالة الجمال. على سبيل المثال: Car وParkingMeter وCustomerRecord جميعها أسماء فئات صالحة، ويمكنك تخمين ما تمثله.

داخل تعريف الفئة، يمكنك تحديد خاصية واحدة أو أكثر للصف باستخدام المتغيرات. يمكن أن يكون للنرد الحقيقي عدد من الجوانب أو اللون أو الوزن. في هذه المهمة، عليك التركيز على ملكية عدد من جوانب النرد.

3. داخل صف Dice، أضِف var تسمى sides لعدد جوانب زهرك. ضبط sides على 6

class Dice {
    var sides = 6
}

وهذا كل ما في الأمر. لديك الآن صف بسيط جدًا يمثّل النرد.

إنشاء مثيل لفئة النرد

تتضمّن صف Dice هذا مخططًا لنرد النرد. للحصول على نرد فعلي في برنامجك، عليك إنشاء مثيل كائن Dice. (وإذا كنت بحاجة إلى ثلاثة أحجار نرد، عليك إنشاء ثلاثة أمثلة للنرد).

1. لإنشاء مثيل كائن Dice، في دالة main()، يمكنك إنشاء val باسم myFirstDice وإعداده كمثيل للفئة Dice. لاحِظ الأقواس بعد اسم الفئة، ما يشير إلى أنك تنشئ مثيل كائن جديدًا من الفئة.

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

الآن وبعد أن أصبح لديك كائن myFirstDice، وهو عنصر من المخطط، يمكنك الوصول إلى خصائصه. وتكون خاصية Dice الوحيدة هي sides. يمكنك الوصول إلى أحد المواقع باستخدام "تدوين النقاط&;;.. لذلك، للدخول إلى خاصية sides في myFirstDice، عليك استدعاء myFirstDice.sides الذي يتم نطقه &quot؛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() {

    }
}

ملاحظة: يمكنك تسمية هذه الطريقة بأي طريقة تريدها، ولكن من المفيد تسميتها الذي يشير إلى الإجراء الذي ينفذه. إنّ تسمية التسمية للدوال والأساليب هي البدء بحرف صغير، واستخدام حالة الجمل، والبدء بحرف إجراء، إن أمكن.

عند رمي حجر نرد ذي 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() الذي يتم نطقه &quot؛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() عرض شيء ما.

في الدروس التطبيقية السابقة حول الترميز، تعلّمت أنّ عليك تحديد نوع بيانات لوسيطات إدخال الدوال. بالطريقة نفسها، يجب تحديد نوع بيانات للبيانات التي تعرضها دالة.

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

لَيْسَ لَدَيْكَ كُلُّ نَرْدِ السِّلْعَة. يتم تشكيل النرد بمختلف الأشكال والأحجام: 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. أَرْجُو دَرْجِةِ الْبَرْنَامَجْ فِي رَمْيِ النَّرْدْ وِفِيهْ رِسَالَة ثَانِيَة مَعْ أَحْدَثِ النَّرْدْ.

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 بستة أوجه، يجب الآن تمرير عدد الجوانب كوسيطة إلى فئة 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. يبدو السطران الأولان من الرمز الرئيسي() على النحو التالي.

    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 وامنحه القدرة على قلب التعليم وإنشاء مثيل للصف الدراسي وقلب بعض العملات المعدنية. كيف يمكنك استخدام دالة عشوائية() مع نطاق لتنفيذ تقليب العملة؟