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

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

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

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

في هذا الدرس العملي الأول، ستنشئ برنامج Kotlin يحاكي رمي النرد ويعرض رقمًا عشوائيًا، تمامًا كما يفعل النرد.

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

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

أهداف الدورة التعليمية

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

ما ستنشئه

• برنامج 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()، عرِّف متغيّرًا على أنّه val باسم diceRange. عيِّنها إلى IntRange من 1 إلى 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

في الخطوات التالية، ستحدّد فئة جديدة باسم 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 نقطة 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() {

    }
}

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

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

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

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 أوجه، ورسالة ثانية خاصة بالنرد ذي 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 بستة جوانب، يجب الآن تمرير عدد الجوانب كمعلَمة إلى فئة 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. نفِّذ الرمز البرمجي، ولن يكون هناك أي اختلاف في الناتج.

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

هذا هو الرمز النهائي بعد إعادة هيكلته .

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 }

• إنشاء الأرقام العشوائية (Wikipedia)
• التحدي المحيّر المتمثل في تصميم نرد ذي 120 وجهًا
• الفئات في Kotlin
• تعريفات الدوال في Kotlin
• إرجاع قيمة من دالة

ملاحظة: الممارسات اختيارية. وهي تتيح لك فرصة التدرب على ما تعلمته في هذا الدرس البرمجي.

يُرجى اتّباع الخطوات التالية:

• امنح فئة Dice سمة لون أخرى وأنشئ عدة مثيلات من النرد بأعداد مختلفة من الجوانب والألوان.
• أنشئ Coin فئة، وامنحها القدرة على قلب العملات المعدنية، وأنشئ مثيلاً للفئة واقلب بعض العملات المعدنية. كيف يمكنك استخدام الدالة random() مع نطاق لإجراء عملية قلب العملة؟