কোটলিনে ক্লাস এবং অবজেক্ট ইনস্ট্যান্স

এই পথের কোডল্যাবগুলির জন্য, আপনি একটি ডাইস রোলার অ্যান্ড্রয়েড অ্যাপ তৈরি করবেন। যখন ব্যবহারকারী "পাশা রোল করে" তখন একটি এলোমেলো ফলাফল তৈরি হবে। ফলাফল একাউন্টে পাশা পক্ষের সংখ্যা লাগে. উদাহরণস্বরূপ, একটি 6-পার্শ্বযুক্ত পাশা থেকে শুধুমাত্র 1-6-এর মানগুলি রোল করা যেতে পারে।

এই চূড়ান্ত অ্যাপটি দেখতে কেমন হবে।

এই অ্যাপের জন্য নতুন প্রোগ্রামিং ধারণাগুলিতে ফোকাস করতে সাহায্য করার জন্য, আপনি মূল অ্যাপ কার্যকারিতা তৈরি করতে ব্রাউজার-ভিত্তিক কোটলিন প্রোগ্রামিং টুল ব্যবহার করবেন। প্রোগ্রামটি আপনার ফলাফল কনসোলে আউটপুট করবে। পরে আপনি অ্যান্ড্রয়েড স্টুডিওতে ইউজার ইন্টারফেস বাস্তবায়ন করবেন।

এই প্রথম কোডল্যাবে, আপনি একটি কোটলিন প্রোগ্রাম তৈরি করবেন যা রোলিং ডাইসকে অনুকরণ করে এবং একটি এলোমেলো সংখ্যা আউটপুট করে, ঠিক যেমন একটি ডাইস।

পূর্বশর্ত

  • https://try.kotlinlang.org/- এ কীভাবে কোড খুলবেন, সম্পাদনা করবেন এবং চালাবেন
  • একটি Kotlin প্রোগ্রাম তৈরি করুন এবং চালান যা ভেরিয়েবল এবং ফাংশন ব্যবহার করে এবং কনসোলে ফলাফল প্রিন্ট করে।
  • ${variable} স্বরলিপি সহ একটি স্ট্রিং টেমপ্লেট ব্যবহার করে পাঠ্যের মধ্যে নম্বর বিন্যাস করুন।

আপনি কি শিখবেন

  • ডাইস রোলগুলি অনুকরণ করার জন্য কীভাবে প্রোগ্রাম্যাটিকভাবে র্যান্ডম সংখ্যা তৈরি করবেন।
  • একটি পরিবর্তনশীল এবং একটি পদ্ধতি দিয়ে একটি Dice ক্লাস তৈরি করে কীভাবে আপনার কোড গঠন করবেন।
  • কিভাবে একটি ক্লাসের একটি অবজেক্ট ইনস্ট্যান্স তৈরি করতে হয়, এর ভেরিয়েবলগুলি পরিবর্তন করতে হয় এবং এর পদ্ধতিগুলিকে কল করতে হয়।

আপনি কি নির্মাণ করবেন

  • ব্রাউজার-ভিত্তিক কোটলিন প্রোগ্রামিং টুলের একটি কোটলিন প্রোগ্রাম যা একটি এলোমেলো ডাইস রোল সম্পাদন করতে পারে।

তুমি কি চাও

  • একটি ইন্টারনেট সংযোগ সহ একটি কম্পিউটার

গেমগুলির প্রায়ই একটি এলোমেলো উপাদান থাকে। আপনি একটি এলোমেলো পুরস্কার অর্জন করতে পারেন বা গেম বোর্ডে এলোমেলো সংখ্যক ধাপ এগিয়ে নিতে পারেন। আপনার দৈনন্দিন জীবনে, আপনি নিরাপদ পাসওয়ার্ড তৈরি করতে এলোমেলো সংখ্যা এবং অক্ষর ব্যবহার করতে পারেন!

প্রকৃত পাশা রোল করার পরিবর্তে, আপনি একটি প্রোগ্রাম লিখতে পারেন যা আপনার জন্য রোলিং ডাইসকে অনুকরণ করে। প্রতিবার যখন আপনি পাশা রোল করবেন, ফলাফল সম্ভাব্য মানের পরিসরের মধ্যে যেকোনো সংখ্যা হতে পারে। সৌভাগ্যবশত, এই ধরনের একটি প্রোগ্রামের জন্য আপনাকে আপনার নিজস্ব র্যান্ডম-নম্বর জেনারেটর তৈরি করতে হবে না। কোটলিন সহ বেশিরভাগ প্রোগ্রামিং ভাষাতে আপনার এলোমেলো সংখ্যা তৈরি করার জন্য একটি অন্তর্নির্মিত উপায় রয়েছে। এই টাস্কে, আপনি একটি এলোমেলো নম্বর তৈরি করতে কোটলিন কোড ব্যবহার করবেন।

আপনার স্টার্টার কোড সেট আপ করুন

  1. আপনার ব্রাউজারে, ওয়েবসাইটটি খুলুন https://try.kotlinlang.org/ ।
  2. কোড এডিটরে বিদ্যমান সমস্ত কোড মুছুন এবং নীচের কোড দিয়ে প্রতিস্থাপন করুন। এটি হল main() ফাংশন যার সাথে আপনি আগের কোডল্যাবগুলিতে কাজ করেছেন ( আপনার প্রথম কোটলিন প্রোগ্রাম কোডল্যাব লিখুন দেখুন)।
fun main() {

}

র্যান্ডম ফাংশন ব্যবহার করুন

একটি পাশা রোল করার জন্য, আপনার সমস্ত বৈধ ডাইস রোল মান উপস্থাপন করার একটি উপায় প্রয়োজন। একটি নিয়মিত 6-পার্শ্বযুক্ত পাশার জন্য, গ্রহণযোগ্য ডাইস রোলগুলি হল: 1, 2, 3, 4, 5 এবং 6৷

পূর্বে, আপনি শিখেছেন যে পূর্ণসংখ্যার জন্য Int এবং পাঠ্যের জন্য String এর মতো ডেটার ধরন রয়েছে। IntRange হল আরেকটি ডেটা টাইপ, এবং এটি একটি প্রারম্ভিক বিন্দু থেকে শেষ বিন্দু পর্যন্ত পূর্ণসংখ্যার একটি পরিসীমা উপস্থাপন করে। একটি ডাইস রোল যে সম্ভাব্য মানগুলি তৈরি করতে পারে তা উপস্থাপন করার জন্য IntRange একটি উপযুক্ত ডেটা টাইপ।

  1. আপনার main() ফাংশনের ভিতরে, diceRange নামক একটি val হিসাবে একটি ভেরিয়েবলকে সংজ্ঞায়িত করুন। এটিকে 1 থেকে 6 পর্যন্ত একটি IntRange এ বরাদ্দ করুন, পূর্ণসংখ্যার পরিসরের প্রতিনিধিত্ব করে যা একটি 6-পার্শ্বযুক্ত পাশা রোল করতে পারে।
val diceRange = 1..6

আপনি বলতে পারেন যে 1..6 হল একটি কোটলিন রেঞ্জ কারণ এটির একটি স্টার্ট নম্বর, দুটি ডট, তারপর একটি শেষ সংখ্যা (মাঝখানে কোনো ফাঁকা স্থান নেই) রয়েছে। পূর্ণসংখ্যা ব্যাপ্তির অন্যান্য উদাহরণ হল 2 থেকে 5 নম্বরের জন্য 2..5 এবং 100 থেকে 200 নম্বরগুলির জন্য 100..200 ৷

যেভাবে কলিং println() সিস্টেমকে প্রদত্ত টেক্সট প্রিন্ট করতে বলে, সেরকমই, আপনি random() নামক একটি ফাংশন ব্যবহার করে একটি নির্দিষ্ট পরিসরের জন্য আপনার জন্য একটি র্যান্ডম নম্বর তৈরি করতে এবং ফেরত দিতে পারেন। আগের মত, আপনি একটি পরিবর্তনশীল ফলাফল সংরক্ষণ করতে পারেন.

  1. main() এর ভিতরে, randomNumber নামক একটি val হিসাবে একটি ভেরিয়েবলকে সংজ্ঞায়িত করুন।
  2. নিচে দেখানো হিসাবে diceRange রেঞ্জে random() কল করার ফলাফলের মান randomNumber তৈরি করুন।
 val randomNumber = diceRange.random()

লক্ষ্য করুন যে আপনি ভেরিয়েবল এবং ফাংশন কলের মধ্যে একটি পিরিয়ড বা ডট ব্যবহার করে diceRange এ random() কল করছেন। আপনি এটিকে " diceRange থেকে একটি র্যান্ডম সংখ্যা তৈরি করা" হিসাবে পড়তে পারেন। ফলাফল তারপর randomNumber ভেরিয়েবলে সংরক্ষণ করা হয়।

  1. আপনার এলোমেলোভাবে জেনারেট করা নম্বর দেখতে, স্ট্রিং ফরম্যাটিং নোটেশন ব্যবহার করুন (এটিকে "স্ট্রিং টেমপ্লেট"ও বলা হয়) ${randomNumber} প্রিন্ট করতে, যেমন নীচে দেখানো হয়েছে।
println("Random number: ${randomNumber}")

আপনার সমাপ্ত কোড এই মত হওয়া উচিত.

fun main() {
    val diceRange = 1..6
    val randomNumber = diceRange.random()
    println("Random number: ${randomNumber}")
}
  1. আপনার কোড বেশ কয়েকবার চালান। প্রতিবার, আপনাকে বিভিন্ন র্যান্ডম সংখ্যা সহ নীচের মত আউটপুট দেখতে হবে।
Random number: 4

আপনি যখন পাশা রোল, তারা আপনার হাতে বাস্তব বস্তু. যদিও আপনি এইমাত্র যে কোডটি লিখেছেন তা পুরোপুরি সূক্ষ্ম কাজ করে, এটা কল্পনা করা কঠিন যে এটি প্রকৃত পাশা সম্পর্কে। একটি প্রোগ্রামকে এটির প্রতিনিধিত্ব করে এমন জিনিসগুলির মতো হতে এটিকে বোঝা সহজ করে তোলে৷ সুতরাং, আপনি রোল করতে পারেন যে প্রোগ্রাম্যাটিক পাশা আছে চমৎকার হবে!

সমস্ত পাশা মূলত একই কাজ করে। তারা একই বৈশিষ্ট্য আছে, যেমন পক্ষের, এবং তারা একই আচরণ আছে, যেমন তারা ঘূর্ণিত করা যেতে পারে। কোটলিনে, আপনি একটি ডাইসের একটি প্রোগ্রাম্যাটিক ব্লুপ্রিন্ট তৈরি করতে পারেন যা বলে যে পাশার পাশ রয়েছে এবং একটি এলোমেলো সংখ্যা রোল করতে পারে। এই ব্লুপ্রিন্টটিকে ক্লাস বলা হয়।

সেই ক্লাস থেকে, আপনি তখন প্রকৃত ডাইস অবজেক্ট তৈরি করতে পারেন, যাকে বলা হয় অবজেক্ট ইনস্ট্যান্স । উদাহরণস্বরূপ, আপনি একটি 12-পার্শ্বযুক্ত পাশা, বা একটি 4-পার্শ্বযুক্ত পাশা তৈরি করতে পারেন।

একটি ডাইস ক্লাস সংজ্ঞায়িত করুন

নিম্নলিখিত ধাপে, আপনি একটি রোলযোগ্য পাশা প্রতিনিধিত্ব করার জন্য Dice নামে একটি নতুন ক্লাস সংজ্ঞায়িত করবেন।

  1. নতুন করে শুরু করতে, main() ফাংশনে কোডটি সাফ করুন যাতে আপনি নীচের দেখানো কোডটি দিয়ে শেষ করেন।
fun main() {

}
  1. এই main() ফাংশনের নিচে, একটি ফাঁকা লাইন যোগ করুন, এবং তারপর Dice ক্লাস তৈরি করতে কোড যোগ করুন। নীচে দেখানো হিসাবে, কীওয়ার্ড class দিয়ে শুরু করুন, তারপরে ক্লাসের নাম, তারপরে একটি খোলা এবং বন্ধ কোঁকড়া বন্ধনী দ্বারা অনুসরণ করুন। ক্লাসের জন্য আপনার কোড রাখতে কোঁকড়া ধনুর্বন্ধনীর মধ্যে জায়গা ছেড়ে দিন।
class Dice {

}

একটি শ্রেণীর সংজ্ঞার ভিতরে, আপনি ভেরিয়েবল ব্যবহার করে ক্লাসের জন্য এক বা একাধিক বৈশিষ্ট্য নির্দিষ্ট করতে পারেন। বাস্তব ডাইসের বেশ কয়েকটি দিক, একটি রঙ বা ওজন থাকতে পারে। এই টাস্কে, আপনি ডাইসের পাশের সংখ্যার বৈশিষ্ট্যের উপর ফোকাস করবেন।

  1. Dice ক্লাসের ভিতরে, আপনার sides সংখ্যার জন্য সাইড নামক একটি var যোগ করুন। sides 6 এ সেট করুন।
class Dice {
    var sides = 6
}

এটাই. আপনি এখন পাশা প্রতিনিধিত্ব একটি খুব সাধারণ ক্লাস আছে.

ডাইস ক্লাসের একটি উদাহরণ তৈরি করুন

এই Dice ক্লাসের সাথে, আপনার কাছে ডাইস কী তার একটি নীলনকশা রয়েছে। আপনার প্রোগ্রামে একটি প্রকৃত ডাইস থাকতে, আপনাকে একটি Dice অবজেক্ট ইনস্ট্যান্স তৈরি করতে হবে। (এবং যদি আপনার তিনটি পাশা প্রয়োজন হয় তবে আপনি তিনটি বস্তুর উদাহরণ তৈরি করবেন।)

  1. Dice এর একটি অবজেক্ট ইন্সট্যান্স তৈরি করতে, main() ফাংশনে, myFirstDice নামে একটি val তৈরি করুন এবং এটিকে Dice ক্লাসের একটি উদাহরণ হিসাবে শুরু করুন। ক্লাসের নামের পরে বন্ধনীগুলি লক্ষ্য করুন, যা বোঝায় যে আপনি ক্লাস থেকে একটি নতুন অবজেক্ট ইনস্ট্যান্স তৈরি করছেন।
fun main() {
    val myFirstDice = Dice()
}

এখন আপনার কাছে একটি myFirstDice অবজেক্ট আছে, একটি জিনিস যা ব্লুপ্রিন্ট থেকে তৈরি, আপনি এর বৈশিষ্ট্যগুলি অ্যাক্সেস করতে পারেন। Dice একমাত্র সম্পত্তি হল এর sides । আপনি "ডট নোটেশন" ব্যবহার করে একটি সম্পত্তি অ্যাক্সেস করেন। সুতরাং, sides এর myFirstDice প্রপার্টি অ্যাক্সেস করতে, আপনি myFirstDice.sides কল করুন যা " myFirstDice ডট sides " উচ্চারিত হয়।

  1. myFirstDice-এর ঘোষণার নীচে, myFirstDice এর sides সংখ্যা বের করতে একটি println() স্টেটমেন্ট যোগ করুন myFirstDice.
println(myFirstDice.sides)

আপনার কোড এই মত দেখতে হবে.

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

class Dice {
    var sides = 6
}
  1. আপনার প্রোগ্রাম চালান এবং এটি Dice ক্লাসে সংজ্ঞায়িত sides সংখ্যা আউটপুট করা উচিত।
6

আপনার কাছে এখন একটি Dice ক্লাস এবং একটি আসল ডাইস myFirstDice রয়েছে যার 6 sides ।

এর পাশা রোল করা যাক!

ডাইস রোল তৈরি করুন

আপনি পূর্বে কেক স্তরগুলি মুদ্রণ করার জন্য একটি ফাংশন ব্যবহার করেছিলেন। ঘূর্ণায়মান পাশা এছাড়াও একটি কর্ম যা একটি ফাংশন হিসাবে প্রয়োগ করা যেতে পারে. এবং যেহেতু সমস্ত ডাইস রোল করা যায়, আপনি Dice ক্লাসের ভিতরে এটির জন্য একটি ফাংশন যোগ করতে পারেন। একটি ক্লাসের ভিতরে সংজ্ঞায়িত একটি ফাংশনকে একটি পদ্ধতিও বলা হয়।

  1. Dice ক্লাসে, sides ভেরিয়েবলের নীচে, একটি ফাঁকা লাইন সন্নিবেশ করুন এবং তারপরে পাশা রোল করার জন্য একটি নতুন ফাংশন তৈরি করুন। কোটলিন কীওয়ার্ড fun দিয়ে শুরু করুন, পদ্ধতির নাম অনুসরণ করুন, বন্ধনী () দ্বারা অনুসরণ করুন, তারপরে কোঁকড়া ধনুর্বন্ধনী খোলা এবং বন্ধ করুন {} । নীচে দেখানো হিসাবে আরও কোডের জন্য জায়গা তৈরি করতে আপনি কোঁকড়া ধনুর্বন্ধনীগুলির মধ্যে একটি ফাঁকা লাইন রেখে যেতে পারেন। আপনার ক্লাস এই মত হওয়া উচিত.
class Dice {
    var sides = 6

    fun roll() {

    }
}

যখন আপনি একটি ছয়-পার্শ্বযুক্ত পাশা রোল করেন, তখন এটি 1 থেকে 6 এর মধ্যে একটি এলোমেলো সংখ্যা তৈরি করে।

  1. roll() পদ্ধতির ভিতরে, একটি val randomNumber তৈরি করুন। এটিকে 1..6 পরিসরে একটি এলোমেলো সংখ্যা বরাদ্দ করুন। রেঞ্জে random() কল করতে ডট নোটেশন ব্যবহার করুন।
val randomNumber = (1..6).random()
  1. র্যান্ডম নম্বর তৈরি করার পরে, এটি কনসোলে প্রিন্ট করুন। আপনার সমাপ্ত roll() পদ্ধতিটি নীচের কোডের মতো হওয়া উচিত।
fun roll() {
     val randomNumber = (1..6).random()
     println(randomNumber)
}
  1. প্রকৃতপক্ষে myFirstDice রোল করতে, main() এ, myFirstDice এ roll() পদ্ধতিতে কল করুন। আপনি "ডট নোটেশন" ব্যবহার করে একটি পদ্ধতি কল করুন। সুতরাং, myFirstDice এর roll() পদ্ধতিতে কল করার জন্য, আপনি 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)
    }
}
  1. আপনার কোড চালান! আপনি পাশের সংখ্যার নীচে একটি এলোমেলো ডাইস রোলের ফলাফল দেখতে পাবেন। আপনার কোডটি বেশ কয়েকবার চালান, এবং লক্ষ্য করুন যে পাশের সংখ্যা একই থাকে এবং ডাইস রোলের মান পরিবর্তন হয়।
6
4

অভিনন্দন! আপনি একটি sides পরিবর্তনশীল এবং একটি roll() ফাংশন সহ একটি Dice ক্লাস সংজ্ঞায়িত করেছেন। main() ফাংশনে, আপনি একটি নতুন Dice অবজেক্ট ইনস্ট্যান্স তৈরি করেছেন এবং তারপরে আপনি একটি এলোমেলো নম্বর তৈরি করতে এটিতে roll() পদ্ধতিটি কল করেছেন।

বর্তমানে আপনি আপনার roll() ফাংশনে randomNumber এর মান প্রিন্ট করছেন এবং এটি দুর্দান্ত কাজ করে! কিন্তু কখনও কখনও এটি ফাংশন বলা যাই হোক না কেন একটি ফাংশন ফলাফল ফেরত আরো দরকারী. উদাহরণস্বরূপ, আপনি একটি ভেরিয়েবলে roll() পদ্ধতির ফলাফল বরাদ্দ করতে পারেন, এবং তারপর সেই পরিমাণে একজন খেলোয়াড়কে সরাতে পারেন! দেখা যাক কিভাবে করা হয়।

  1. main() -এ myFirstDice.roll() লেখা লাইনটি পরিবর্তন করুন। diceRoll নামে একটি val তৈরি করুন। roll() পদ্ধতি দ্বারা প্রত্যাবর্তিত মানের সমান এটি সেট করুন।
val diceRoll = myFirstDice.roll()

এটি এখনও কিছু করে না, কারণ roll() এখনও কিছু ফেরত দেয় না। এই কোডটি উদ্দেশ্য হিসাবে কাজ করার জন্য, roll() কে কিছু ফেরত দিতে হবে।

পূর্ববর্তী কোডল্যাবগুলিতে আপনি শিখেছেন যে ফাংশনে ইনপুট আর্গুমেন্টের জন্য আপনাকে একটি ডেটা টাইপ নির্দিষ্ট করতে হবে। একইভাবে, আপনাকে ডেটার জন্য একটি ডেটা টাইপ নির্দিষ্ট করতে হবে যা একটি ফাংশন প্রদান করে।

  1. কোন ধরনের ডেটা ফেরত দেওয়া হবে তা নির্দিষ্ট করতে roll() ফাংশন পরিবর্তন করুন। এই ক্ষেত্রে, র্যান্ডম সংখ্যা একটি Int , তাই রিটার্ন টাইপ হল Int । রিটার্ন টাইপ নির্দিষ্ট করার জন্য সিনট্যাক্স হল: ফাংশনের নামের পরে, বন্ধনীর পরে, ফাংশনের রিটার্ন টাইপের জন্য একটি কোলন, স্পেস এবং তারপরে Int কীওয়ার্ড যোগ করুন। ফাংশন সংজ্ঞা নীচের কোড মত হওয়া উচিত.
fun roll(): Int {
  1. এই কোড চালান. আপনি সমস্যা ভিউতে একটি ত্রুটি দেখতে পাবেন। এটা বলে:
A ‘return'  expression is required in a function with a block body.

আপনি একটি Int ফেরত দিতে ফাংশনের সংজ্ঞা পরিবর্তন করেছেন, কিন্তু সিস্টেমটি অভিযোগ করছে যে আপনার

কোড আসলে একটি Int ফেরত দেয় না। "ব্লক বডি" বা "ফাংশন বডি" একটি ফাংশনের কোঁকড়া ধনুর্বন্ধনীর মধ্যে থাকা কোডকে বোঝায়। আপনি ফাংশন বডির শেষে একটি return স্টেটমেন্ট ব্যবহার করে একটি ফাংশন থেকে একটি মান ফেরত দিয়ে এই ত্রুটিটি ঠিক করতে পারেন।

  1. roll() এ, println() স্টেটমেন্টটি সরিয়ে দিন এবং randomNumber জন্য return স্টেটমেন্ট দিয়ে প্রতিস্থাপন করুন। আপনার roll() ফাংশন নিচের কোডের মত দেখতে হবে।
fun roll(): Int {
     val randomNumber = (1..6).random()
     return randomNumber
}
  1. main() এ ডাইসের পাশের জন্য প্রিন্ট স্টেটমেন্টটি সরিয়ে দিন।
  2. একটি তথ্যপূর্ণ বাক্যে diceRoll sides প্রিন্ট করার জন্য একটি বিবৃতি যোগ করুন। আপনার সমাপ্ত main() ফাংশন নীচের কোড অনুরূপ দেখতে হবে.
fun main() {
    val myFirstDice = Dice()
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.sides} sided dice rolled ${diceRoll}!")
}
  1. আপনার কোড চালান এবং আপনার আউটপুট এই মত হওয়া উচিত।
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() পদ্ধতিতে, পরিবর্তে sides ব্যবহার করতে হার্ড-কোডেড 1..6 পরিবর্তন করুন, যাতে পরিসীমা এবং এইভাবে র্যান্ডম নম্বর রোল করা হয়, সর্বদা পক্ষের সংখ্যার জন্য সঠিক হবে।
val randomNumber = (1..sides).random()
  1. main() ফাংশনে, ডাইস রোলটি প্রিন্ট করার নিচে এবং পরে, আমার FirstDice sides পরিবর্তন করে 20 এ সেট করুন।
myFirstDice.sides = 20
  1. যেখানে আপনি পাশের সংখ্যা পরিবর্তন করেছেন তার পরে নীচে বিদ্যমান প্রিন্ট স্টেটমেন্টটি অনুলিপি করুন এবং আটকান।
  2. 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
    }
}
  1. আপনার প্রোগ্রামটি চালান এবং আপনি 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.
}
  1. Dice ক্লাসের ভিতরে, numSides sides করতে পারেন।
  2. এছাড়াও, numSides ব্যবহার করার জন্য পরিসীমা ঠিক করুন।

আপনার Dice ক্লাস এই মত হওয়া উচিত.

class Dice (val numSides: Int) {

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

আপনি যদি এই কোডটি চালান তবে আপনি অনেক ত্রুটি দেখতে পাবেন, কারণ আপনাকে Dice ক্লাসের পরিবর্তনগুলির সাথে কাজ করার জন্য main() আপডেট করতে হবে।

  1. main() তে, 6টি দিক দিয়ে myFirstDice তৈরি করতে, আপনাকে এখন Dice ক্লাসের আর্গুমেন্ট হিসাবে পাশের সংখ্যাটি পাস করতে হবে, যেমনটি নীচে দেখানো হয়েছে।
    val myFirstDice = Dice(6)
  1. প্রিন্ট স্টেটমেন্টে, sides পরিবর্তন করে numSides ।
  2. এর নীচে, কোডটি মুছুন যা 20-এ sides পরিবর্তন করে, কারণ সেই ভেরিয়েবলটি আর বিদ্যমান নেই।
  3. এটির নীচে println স্টেটমেন্টটিও মুছুন।

আপনার main() ফাংশনটি নীচের কোডের মতো হওয়া উচিত এবং আপনি যদি এটি চালান তবে কোনও ত্রুটি থাকা উচিত নয়।

fun main() {
    val myFirstDice = Dice(6)
    val diceRoll = myFirstDice.roll()
    println("Your ${myFirstDice.numSides} sided dice rolled ${diceRoll}!")
}
  1. প্রথম ডাইস রোলটি প্রিন্ট করার পর, mySecondDice নামে একটি দ্বিতীয় Dice অবজেক্ট তৈরি করতে এবং 20 দিক দিয়ে প্রিন্ট করতে কোড যোগ করুন।
    val mySecondDice = Dice(20)
  1. একটি মুদ্রণ বিবৃতি যোগ করুন যা প্রত্যাবর্তিত মানটি রোল এবং প্রিন্ট করে।
println("Your ${mySecondDice.numSides} sided dice rolled  ${mySecondDice.roll()}!")
  1. আপনার সমাপ্ত 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
    }
}
  1. আপনার সমাপ্ত প্রোগ্রাম চালান, এবং আপনার আউটপুট এই মত হওয়া উচিত.
Your 6 sided dice rolled 5!
Your 20 sided dice rolled 7!

কোড লেখার সময়, সংক্ষিপ্ত করা ভাল। আপনি randomNumber ভেরিয়েবল থেকে পরিত্রাণ পেতে পারেন এবং সরাসরি র্যান্ডম নম্বর ফেরত দিতে পারেন।

  1. এলোমেলো নম্বর সরাসরি ফেরত দিতে return স্টেটমেন্ট পরিবর্তন করুন।
    fun roll(): Int {
        return (1..numSides).random()
    }

দ্বিতীয় মুদ্রণ বিবৃতিতে, আপনি স্ট্রিং টেমপ্লেটে র্যান্ডম নম্বর পেতে কল করেছেন। আপনি প্রথম মুদ্রণ বিবৃতিতে একই জিনিস করে diceRoll ভেরিয়েবল থেকে পরিত্রাণ পেতে পারেন।

  1. স্ট্রিং টেমপ্লেটে myFirstDice.roll() কল করুন এবং diceRoll ভেরিয়েবল মুছে দিন। আপনার main() কোডের প্রথম দুটি লাইন এখন এই রকম দেখাচ্ছে।
    val myFirstDice = Dice(6)
    println("Your ${myFirstDice.numSides} sided dice rolled ${myFirstDice.roll()}!")
  1. আপনার কোড চালান এবং আউটপুটে কোন পার্থক্য থাকা উচিত নয়।

এটি রিফ্যাক্টর করার পরে এটি আপনার চূড়ান্ত কোড।

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 ক্লাস তৈরি করুন, এটি ফ্লিপ করার ক্ষমতা দিন, ক্লাসের একটি উদাহরণ তৈরি করুন এবং কিছু কয়েন ফ্লিপ করুন! কয়েন ফ্লিপ করার জন্য আপনি কীভাবে একটি পরিসরের সাথে র্যান্ডম() ফাংশন ব্যবহার করবেন?