তামিম আহমেদ
তামিম আহমেদ
10 Aug 2023 (8 months ago)
আড়াইহাজার, নারায়ণগঞ্জ, ঢাকা, বাংলাদেশ

কোটলিন


Listen to this article

Contents

এখানে নতুনদের জন্য একটি সাধারণ কোটলিন টিউটোরিয়াল রয়েছে যা সামগ্রী H2 শিরোনাম, কোড উদাহরণ এবং তাদের নিজ নিজ আউটপুট ব্যবহার করে মৌলিক ধারণাগুলি কভার করে।

হ্যালো ওয়ার্ল্ড প্রোগ্রাম

fun main() {
    println("Hello, World!")
}

আউটপুট:

Hello, World!

ভেরিয়েবল এবং ডেটা টাইপ

fun main() {
    // Integer variable
    val age: Int = 25

    // Double variable
    val height: Double = 5.9

    // String variable
    val name: String = "John Doe"

    // Boolean variable
    val isStudent: Boolean = true

    println("Name: $name, Age: $age, Height: $height, Is Student: $isStudent")
}

আউটপুট:

Name: John Doe, Age: 25, Height: 5.9, Is Student: true

শর্তাবলী এবং লুপ

fun main() {
    val num = 7

    // If-else statement
    if (num % 2 == 0) {
        println("$num is even.")
    } else {
        println("$num is odd.")
    }

    // For loop
    for (i in 1..5) {
        println("Iteration $i")
    }

    // While loop
    var counter = 0
    while (counter < 3) {
        println("Counter: $counter")
        counter++
    }
}

আউটপুট:

7 is odd.
Iteration 1
Iteration 2
Iteration 3
Iteration 4
Iteration 5
Counter: 0
Counter: 1
Counter: 2

ফাংশন

fun main() {
    val sum = add(5, 10)
    println("Sum: $sum")

    val result = calculate(3, 4, 2)
    println("Result: $result")
}

fun add(a: Int, b: Int): Int {
    return a + b
}

fun calculate(x: Int, y: Int, z: Int): Int {
    return (x * y) + z
}

আউটপুট:

Sum: 15
Result: 14

তালিকা এবং পুনরাবৃত্তি

এই উদাহরণে, আমরা শিখব কীভাবে তালিকাগুলির সাথে কাজ করতে হয় এবং তাদের উপর বিভিন্ন ক্রিয়াকলাপ সম্পাদন করতে পুনরাবৃত্তি ব্যবহার করতে হয়।

fun main() {
    // Creating a list of numbers
    val numbers = listOf(1, 2, 3, 4, 5)

    // Printing the elements of the list
    println("List of numbers: $numbers")

    // Summing all elements in the list
    val sum = numbers.sum()
    println("Sum of the numbers: $sum")

    // Finding the maximum value in the list
    val maxNum = numbers.maxOrNull()
    println("Maximum number: $maxNum")

    // Checking if a number exists in the list
    val searchNumber = 3
    val containsNumber = numbers.contains(searchNumber)
    println("List contains $searchNumber: $containsNumber")

    // Using map to create a new list with squared values
    val squaredNumbers = numbers.map { it * it }
    println("Squared numbers: $squaredNumbers")
}

আউটপুট:

List of numbers: [1, 2, 3, 4, 5]
Sum of the numbers: 15
Maximum number: 5
List contains 3: true
Squared numbers: [1, 4, 9, 16, 25]

বাতিলযোগ্য প্রকার এবং নিরাপদ কল

কোটলিনে, ভেরিয়েবলগুলি বাতিলযোগ্য বা অ-শূন্য হতে পারে। আমরা বাতিলযোগ্য প্রকারগুলি পরিচালনা করতে নিরাপদ কলগুলি অন্বেষণ করব৷

fun main() {
    var nullableName: String? = "John Doe"
    nullableName = null

    // Safe call with the ?. operator
    val nameLength = nullableName?.length
    println("Name Length: $nameLength")

    // Elvis operator ?: to provide a default value
    val finalName = nullableName ?: "Unknown"
    println("Final Name: $finalName")
}

আউটপুট:

Name Length: null
Final Name: Unknown

ক্লাস এবং অবজেক্ট

আসুন Personএকজন ব্যক্তির তথ্য উপস্থাপন করার জন্য একটি সাধারণ শ্রেণী এবং একটি বস্তুর উদাহরণ তৈরি করি।

class Person(val name: String, val age: Int) {
    fun introduce() {
        println("Hello, my name is $name and I am $age years old.")
    }
}

fun main() {
    val person = Person("Alice", 30)
    person.introduce()
}

আউটপুট:

Hello, my name is Alice and I am 30 years old.

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

এক্সটেনশন ফাংশন

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

// Extension function to capitalize the first letter of a string
fun String.capitalizeFirstLetter(): String {
    return if (isNotEmpty()) {
        this.substring(0, 1).toUpperCase() + this.substring(1)
    } else {
        this
    }
}

fun main() {
    val text = "hello, world!"
    val capitalizedText = text.capitalizeFirstLetter()
    println("Original text: $text")
    println("Capitalized text: $capitalizedText")
}

আউটপুট:

Original text: hello, world!
Capitalized text: Hello, world!

ডেটা ক্লাস

ডেটা ক্লাসগুলি কোটলিনে ডেটা রাখার জন্য ডিজাইন করা বিশেষ ক্লাস। তারা স্বয়ংক্রিয়ভাবে equals()hashCode(), এবং এর মত সাধারণ পদ্ধতির জন্য বাস্তবায়ন প্রদান করে toString()। আসুন একটি বইকে উপস্থাপন করে একটি সাধারণ ডেটা ক্লাস তৈরি করি।

data class Book(val title: String, val author: String, val year: Int)

fun main() {
    val book = Book("The Alchemist", "Paulo Coelho", 1988)
    println("Book Details: $book")
}

আউটপুট:

Book Details: Book(title=The Alchemist, author=Paulo Coelho, year=1988)

Lambdas এবং উচ্চ ক্রম ফাংশন

Lambdas হল বেনামী ফাংশন যা অন্য ফাংশনে আর্গুমেন্ট হিসাবে পাস করা যেতে পারে। আমরা একটি শর্তের উপর ভিত্তি করে একটি তালিকা ফিল্টার করতে উচ্চ-ক্রম ফাংশন ব্যবহার করব।

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)

    // Filtering even numbers using a lambda
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even numbers: $evenNumbers")

    // Using a higher-order function to perform custom filtering
    val filteredNumbers = filterNumbers(numbers) { num -> num > 3 }
    println("Filtered numbers: $filteredNumbers")
}

// Higher-order function to filter numbers based on a condition
fun filterNumbers(numbers: List, condition: (Int) -> Boolean): List {
    return numbers.filter { condition(it) }
}

আউটপুট:

Even numbers: [2, 4, 6]
Filtered numbers: [4, 5, 6]

আমি আশা করি আপনি এই উদাহরণগুলি আরও Kotlin বৈশিষ্ট্যগুলি অন্বেষণে সহায়ক বলে মনে করেন৷ আপনার কোন নির্দিষ্ট বিষয় বা প্রশ্ন থাকলে, নির্দ্বিধায় জিজ্ঞাসা করুন! শুভ কোডিং!

ব্যতিক্রম হ্যান্ডলিং

ব্যতিক্রম হ্যান্ডলিং আপনাকে ত্রুটিগুলি সুন্দরভাবে পরিচালনা করার অনুমতি দেয় যখন সেগুলি আপনার প্রোগ্রামের সম্পাদনের সময় ঘটে। কোটলিনে ব্যতিক্রমগুলি কীভাবে ধরবেন এবং পরিচালনা করবেন তার একটি উদাহরণ এখানে রয়েছে।

fun main() {
    try {
        val result = divideNumbers(10, 0)
        println("Result: $result")
    } catch (e: ArithmeticException) {
        println("Error: Cannot divide by zero.")
    }
}

fun divideNumbers(a: Int, b: Int): Int {
    if (b == 0) {
        throw ArithmeticException("Division by zero is not allowed.")
    }
    return a / b
}

আউটপুট:

Error: Cannot divide by zero.

উত্তরাধিকার এবং পলিমরফিজম

উত্তরাধিকার একটি শ্রেণীকে অন্য শ্রেণীর থেকে বৈশিষ্ট্য এবং পদ্ধতির উত্তরাধিকারী হতে দেয়। পলিমরফিজম বিভিন্ন শ্রেণীর বস্তুকে একটি সাধারণ সুপারক্লাসের বস্তু হিসাবে বিবেচনা করার অনুমতি দেয়। চলুন দেখি কিভাবে এটি কাজ করে:

// Base class
open class Shape {
    open fun draw() {
        println("Drawing a shape.")
    }
}

// Derived class
class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle.")
    }
}

// Function to draw any shape
fun drawShape(shape: Shape) {
    shape.draw()
}

fun main() {
    val shape: Shape = Circle()
    drawShape(shape)
}

আউটপুট:

Drawing a circle.

সহচর বস্তু

সঙ্গী বস্তুগুলি একটি ক্লাসের মধ্যে স্ট্যাটিক-সদৃশ সদস্য তৈরি করতে ব্যবহৃত হয়। ক্লাসের একটি উদাহরণ তৈরি না করেই এই সদস্যদের অ্যাক্সেস করা যেতে পারে।

class Logger {
    companion object {
        fun logMessage(message: String) {
            println("LOG: $message")
        }
    }
}

fun main() {
    Logger.logMessage("This is a log message.")
}

আউটপুট:

LOG: This is a log message.

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

সিল করা ক্লাস

সীলমোহরযুক্ত ক্লাসগুলি সীমাবদ্ধ শ্রেণির শ্রেণিবিন্যাসের প্রতিনিধিত্ব করতে ব্যবহৃত হয়। তাদের একই ফাইলের মধ্যে সংজ্ঞায়িত সাবক্লাসের একটি নির্দিষ্ট সেট থাকতে পারে। এখানে সিল করা ক্লাসগুলি প্রদর্শন করার জন্য একটি উদাহরণ রয়েছে:

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Success: ${result.data}")
        is Error -> println("Error: ${result.message}")
    }
}

fun main() {
    val result1 = Success("Data successfully processed.")
    val result2 = Error("Something went wrong!")

    processResult(result1)
    processResult(result2)
}

আউটপুট:

Success: Data successfully processed.
Error: Something went wrong!

করুটিন

কোটলিনে অ্যাসিঙ্ক্রোনাস প্রোগ্রামিংয়ের জন্য Coroutines ব্যবহার করা হয়। তারা আপনাকে আরও অনুক্রমিক এবং পঠনযোগ্য পদ্ধতিতে অ্যাসিঙ্ক্রোনাস কোড লেখার অনুমতি দেয়। এখানে একটি সাধারণ কোরোটিন উদাহরণ:

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        delay(1000)
        println("Coroutines are awesome!")
    }

    println("Waiting for coroutine to finish...")
    job.join()
}

আউটপুট:

Waiting for coroutine to finish...
Coroutines are awesome!

স্ট্যান্ডার্ড লাইব্রেরি ফাংশনের জন্য এক্সটেনশন

কোটলিনের স্ট্যান্ডার্ড লাইব্রেরি অনেক দরকারী ফাংশন প্রদান করে। আপনি কাস্টম কার্যকারিতা যোগ করতে তাদের প্রসারিত করতে পারেন। Stringএখানে একটি অক্ষরের শেষ ঘটনার পরে একটি সাবস্ট্রিং পেতে ক্লাস প্রসারিত করার একটি উদাহরণ রয়েছে :

fun String.afterLast(char: Char): String? {
    val lastIndex = lastIndexOf(char)
    return if (lastIndex != -1 && lastIndex < length - 1) {
        substring(lastIndex + 1)
    } else {
        null
    }
}

fun main() {
    val text = "example.com/test"
    val afterLastSlash = text.afterLast('/')
    println("Substring after last slash: $afterLastSlash")
}

আউটপুট:

Substring after last slash: test

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

সংগ্রহ: MutableMap

MutableMap একটি সংগ্রহ যা পরিবর্তনযোগ্য এন্ট্রি সহ একটি মানচিত্র উপস্থাপন করে। আপনি একটি MutableMap-এ কী-মানের জোড়া যোগ করতে, আপডেট করতে এবং সরাতে পারেন। এখানে একটি উদাহরণ:

fun main() {
    // Creating a MutableMap of names and ages
    val ages = mutableMapOf(
        "John" to 30,
        "Alice" to 25,
        "Bob" to 28
    )

    // Adding a new entry to the map
    ages["Michael"] = 35

    // Updating the age of an existing entry
    ages["Alice"] = 26

    // Removing an entry from the map
    ages.remove("Bob")

    // Iterating through the map
    for ((name, age) in ages) {
        println("$name is $age years old.")
    }
}

আউটপুট:

John is 30 years old.
Alice is 26 years old.
Michael is 35 years old.

রেগুলার এক্সপ্রেশন সহ ডেটা যাচাইকরণ

রেগুলার এক্সপ্রেশন আপনাকে নির্দিষ্ট প্যাটার্নের উপর ভিত্তি করে স্ট্রিংগুলিকে যাচাই এবং ম্যানিপুলেট করার অনুমতি দেয়। এখানে একটি ইমেল ঠিকানা যাচাই করার জন্য একটি নিয়মিত অভিব্যক্তি ব্যবহার করার একটি উদাহরণ:

fun isValidEmail(email: String): Boolean {
    val emailPattern = Regex("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")
    return email.matches(emailPattern)
}

fun main() {
    val email = "john.doe@example.com"
    val isValid = isValidEmail(email)
    if (isValid) {
        println("Valid email address.")
    } else {
        println("Invalid email address.")
    }
}

আউটপুট:

Valid email address.

ফাইল হ্যান্ডলিং

Kotlin ফাইল পরিচালনার জন্য সহজে ব্যবহারযোগ্য API প্রদান করে। এখানে একটি ফাইল পড়া এবং লেখার একটি উদাহরণ:

import java.io.File

fun main() {
    // Writing to a file
    val content = "Hello, this is the content to be written to the file."
    val outputFile = File("output.txt")
    outputFile.writeText(content)

    // Reading from a file
    val inputFile = File("output.txt")
    val readContent = inputFile.readText()
    println("File Content: $readContent")
}

আউটপুট:

File Content: Hello, this is the content to be written to the file.

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

স্কোপ ফাংশন: ‘প্রয়োগ করুন’ এবং ‘লেট’

কোটলিনের স্কোপ ফাংশনগুলি সীমিত সুযোগের মধ্যে বস্তুর সাথে কাজ করার একটি সংক্ষিপ্ত উপায় প্রদান করে। ‘প্রয়োগ করুন’ এবং ‘লেট’ ফাংশনগুলি সাধারণত ব্যবহৃত হয়। এখানে একটি উদাহরণ:

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 30)

    // 'apply' sets properties and returns the receiver object
    val updatedPerson = person.apply {
        name = "Bob"
        age = 28
    }

    println("Original Person: $person")
    println("Updated Person: $updatedPerson")

    // 'let' performs an operation and returns a result
    val fullName = person.let { "${it.name} Doe" }
    println("Full Name: $fullName")
}

আউটপুট:

Original Person: Person(name=Alice, age=30)
Updated Person: Person(name=Bob, age=28)
Full Name: Alice Doe

অর্পিত সম্পত্তি

অর্পিত বৈশিষ্ট্যগুলি আপনাকে সম্পত্তি অ্যাক্সেস এবং পরিবর্তন অন্য বস্তুতে অর্পণ করতে দেয়। Kotlin ‘অলস’ এবং ‘পর্যবেক্ষণযোগ্য’ এর মতো বেশ কয়েকটি মানক প্রতিনিধি প্রদান করে। এখানে ‘অলস’ প্রতিনিধি ব্যবহার করার একটি উদাহরণ:

class Example {
    val lazyValue: String by lazy {
        println("Initializing lazyValue")
        "Hello Lazy"
    }
}

fun main() {
    val example = Example()
    println("Before accessing lazyValue")
    println(example.lazyValue)
    println("After accessing lazyValue")
}

আউটপুট:

Before accessing lazyValue
Initializing lazyValue
Hello Lazy
After accessing lazyValue

অবজেক্ট এক্সপ্রেশন

অবজেক্ট এক্সপ্রেশন আপনাকে তাদের নিজস্ব কাস্টম আচরণের সাথে বেনামী বস্তু তৈরি করতে দেয়। এখানে একটি উদাহরণ:

interface Shape {
    fun draw()
}

fun main() {
    val customShape = object : Shape {
        override fun draw() {
            println("Drawing a custom shape.")
        }
    }

    customShape.draw()
}

আউটপুট:

Drawing a custom shape.

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

ধ্বংসাত্মক ঘোষণা

ডিস্ট্রাকচারিং ডিক্লেয়ারেশন আপনাকে একটি বস্তু থেকে একযোগে একাধিক উপাদান বের করতে এবং পৃথক ভেরিয়েবলে বরাদ্দ করতে দেয়। এখানে একটি উদাহরণ:

data class Point(val x: Int, val y: Int)

fun main() {
    val point = Point(10, 20)

    // Destructuring declaration
    val (x, y) = point

    println("x: $x, y: $y")
}

আউটপুট:

x: 10, y: 20

এনাম ক্লাস

এনাম ক্লাসগুলি একটি নির্দিষ্ট সংখ্যক ধ্রুবক মান উপস্থাপন করতে ব্যবহৃত হয়। তাদের বৈশিষ্ট্য, পদ্ধতি এবং কনস্ট্রাক্টর থাকতে পারে। এখানে একটি উদাহরণ:

enum class Direction {
    NORTH,
    SOUTH,
    EAST,
    WEST
}

fun main() {
    val currentDirection = Direction.NORTH
    println("Current Direction: $currentDirection")
}

আউটপুট:

Current Direction: NORTH

25. টেইল রিকারসিভ ফাংশন

টেইল রিকারশন হল রিকারসিভ ফাংশন অপ্টিমাইজ করার জন্য ব্যবহৃত একটি কৌশল। এটি কম্পাইলারকে প্রতিটি পুনরাবৃত্ত কলের জন্য নতুন তৈরি করার পরিবর্তে বর্তমান স্ট্যাক ফ্রেমটি পুনরায় ব্যবহার করার অনুমতি দেয়। এখানে একটি উদাহরণ:

tailrec fun factorial(n: Int, result: Int = 1): Int {
    return if (n == 0) {
        result
    } else {
        factorial(n - 1, result * n)
    }
}

fun main() {
    val n = 5
    val factorialResult = factorial(n)
    println("Factorial of $n is $factorialResult")
}

আউটপুট:

Factorial of 5 is 120

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

এক্সটেনশন বৈশিষ্ট্য

এক্সটেনশন বৈশিষ্ট্যগুলি আপনাকে তাদের সোর্স কোড পরিবর্তন না করে বিদ্যমান ক্লাসগুলিতে নতুন বৈশিষ্ট্য যুক্ত করার অনুমতি দেয়। এখানে একটি উদাহরণ:

class Rectangle(var width: Int, var height: Int)

val Rectangle.area: Int
    get() = width * height

fun main() {
    val rectangle = Rectangle(5, 10)
    println("Rectangle Area: ${rectangle.area}")
}

আউটপুট:

Rectangle Area: 50

স্থানীয় ফাংশন

কোটলিনে, আপনি অন্যান্য ফাংশনের মধ্যে ফাংশন সংজ্ঞায়িত করতে পারেন। এগুলিকে স্থানীয় ফাংশন বলা হয় এবং শুধুমাত্র এনক্লোজিং ফাংশনের মধ্যেই অ্যাক্সেস করা যেতে পারে। এখানে একটি উদাহরণ:

fun main() {
    fun greet(name: String) {
        fun formatName(name: String): String {
            return name.trim().capitalize()
        }

        val formattedName = formatName(name)
        println("Hello, $formattedName!")
    }

    greet("  Alice  ")
}

আউটপুট:

Hello, Alice!

কাস্টম গেটার এবং সেটার্স

আপনি Kotlin এ বৈশিষ্ট্যের জন্য কাস্টম গেটার এবং সেটার্স সংজ্ঞায়িত করতে পারেন। এটি আপনাকে কীভাবে সম্পত্তি অ্যাক্সেস এবং সংশোধন করা হয় তা নিয়ন্ত্রণ করতে দেয়। এখানে একটি উদাহরণ:

class Circle(var radius: Double) {
    var diameter: Double
        get() = radius * 2
        set(value) {
            radius = value / 2
        }
}

fun main() {
    val circle = Circle(5.0)
    println("Diameter: ${circle.diameter}")

    circle.diameter = 10.0
    println("New Radius: ${circle.radius}")
}

আউটপুট:

Diameter: 10.0
New Radius: 5.0

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

ল্যাম্বডা আর্গুমেন্টের সাথে উচ্চ ক্রম ফাংশন

উচ্চ-ক্রম ফাংশন শক্তিশালী এবং নমনীয় কোডের জন্য অনুমতি দেয়, আর্গুমেন্ট হিসাবে অন্যান্য ফাংশন নিতে পারে। এখানে একটি উচ্চ-অর্ডার ফাংশনের একটি উদাহরণ যা একটি ল্যাম্বডা আর্গুমেন্ট ব্যবহার করে একটি গণনা সম্পাদন করে:

fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

fun main() {
    val addition = calculate(5, 3) { a, b -> a + b }
    println("Addition: $addition")

    val multiplication = calculate(5, 3) { a, b -> a * b }
    println("Multiplication: $multiplication")
}

আউটপুট:

Addition: 8
Multiplication: 15

ইনলাইন ফাংশন

‘ইনলাইন’ মডিফায়ারটি পারফরম্যান্স উন্নত করার জন্য উচ্চ-ক্রম ফাংশনের জন্য ব্যবহার করা যেতে পারে। এটি কল সাইটে সরাসরি ফাংশনের বডি ইনলাইন করে ফাংশন কলের ওভারহেড দূর করে। এখানে একটি উদাহরণ:

inline fun measureTime(block: () -> Unit) {
    val startTime = System.currentTimeMillis()
    block()
    val endTime = System.currentTimeMillis()
    println("Time taken: ${endTime - startTime} ms")
}

fun main() {
    measureTime {
        for (i in 1..1000000) {
            // Some time-consuming operation
        }
    }
}

আউটপুট:

Time taken: [Time in milliseconds]

উপনাম টাইপ করুন

প্রকার উপনাম আপনাকে বিদ্যমান প্রকারের জন্য বিকল্প নাম তৈরি করতে দেয়। এটি দীর্ঘ বা জটিল টাইপ নাম সরলীকরণ করতে দরকারী হতে পারে. এখানে একটি উদাহরণ:

typealias EmployeeId = Int
typealias EmployeeMap = Map

fun main() {
    val employees: EmployeeMap = mapOf(
        1 to "Alice",
        2 to "Bob",
        3 to "Charlie"
    )

    println("Employee Map: $employees")
}

আউটপুট:

Employee Map: {1=Alice, 2=Bob, 3=Charlie}

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

সিল ইন্টারফেস

Kotlin 1.5 সিল করা ইন্টারফেস চালু করেছে, যা সিল করা ক্লাসের মতো কিন্তু ইন্টারফেসের জন্য ব্যবহৃত হয়। সিল করা ইন্টারফেসগুলি তাদের বাস্তবায়নকে একই ফাইলের মধ্যে ঘোষণা করতে সীমাবদ্ধ করে। এখানে একটি উদাহরণ:

sealed interface Vehicle {
    fun start()
}

class Car : Vehicle {
    override fun start() {
        println("Car started")
    }
}

class Motorcycle : Vehicle {
    override fun start() {
        println("Motorcycle started")
    }
}

fun main() {
    val car: Vehicle = Car()
    val motorcycle: Vehicle = Motorcycle()

    car.start()
    motorcycle.start()
}

আউটপুট:

Car started
Motorcycle started

রিফাইড টাইপ প্যারামিটার

‘রিফাইড’ মডিফায়ার আপনাকে রানটাইমে জেনেরিক প্যারামিটারের প্রকৃত প্রকার অ্যাক্সেস করতে দেয়। ইনলাইন ফাংশন এবং প্রতিফলিত অপারেশনগুলির সাথে কাজ করার সময় এটি কার্যকর। এখানে একটি উদাহরণ:

inline fun  getTypeName() = T::class.simpleName

fun main() {
    val typeName = getTypeName()
    println("Type Name: $typeName")
}

আউটপুট:

Type Name: Int

অবজেক্ট ডিক্লারেশন

অবজেক্ট ডিক্লারেশন আপনাকে কোটলিনে সিঙ্গেলটন তৈরি করতে দেয়। অবজেক্টটি অলসভাবে তৈরি করা হয় এবং প্রথমবার অ্যাক্সেস করার সময় শুরু হয়। এখানে একটি উদাহরণ:

object Logger {
    fun log(message: String) {
        println("LOG: $message")
    }
}

fun main() {
    Logger.log("This is a log message.")
}

আউটপুট:

LOG: This is a log message.

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

স্মার্ট কাস্ট

কোটলিনের স্মার্ট কাস্টগুলি স্বয়ংক্রিয়ভাবে একটি পরিবর্তনশীলকে একটি নির্দিষ্ট ধরণের একটি টাইপ চেকের উপর ভিত্তি করে কাস্ট করে। এটি স্পষ্ট টাইপ কাস্টিংয়ের প্রয়োজনীয়তা হ্রাস করে। এখানে একটি উদাহরণ:

fun printLength(obj: Any) {
    if (obj is String) {
        // 'obj' is automatically cast to String inside this block
        println("Length of the string: ${obj.length}")
    } else {
        println("Not a string")
    }
}

fun main() {
    printLength("Hello, Kotlin")
    printLength(42)
}

আউটপুট:

Length of the string: 12
Not a string

নন-নাল অ্যাসারশন

নন-নাল অ্যাসার্শন অপারেটর ( !!) ব্যবহার করা হয় এটা নিশ্চিত করার জন্য যে একটি শূন্য ভেরিয়েবল নাল নয়। এটি একটি নিক্ষেপ NullPointerExceptionযদি পরিবর্তনশীল নাল হয়. সতর্কতার সাথে এটি ব্যবহার করুন কারণ এটি রানটাইম ব্যতিক্রম হতে পারে। এখানে একটি উদাহরণ:

fun printLength(str: String?) {
    // Using the non-null assertion operator
    val length = str!!.length
    println("Length of the string: $length")
}

fun main() {
    printLength("Hello, Kotlin")
    printLength(null) // This will throw a NullPointerException
}

আউটপুট:

Length of the string: 12
Exception in thread "main" kotlin.KotlinNullPointerException

অলস দ্বারা অর্পিত সম্পত্তি

‘অলস দ্বারা’ প্রতিনিধি বৈশিষ্ট্যগুলির অলস প্রাথমিককরণের অনুমতি দেয়। সম্পত্তিটি শুধুমাত্র গণনা করা হবে যখন এটি প্রথমবার অ্যাক্সেস করা হবে। পরবর্তী অ্যাক্সেসগুলি ক্যাশে করা মান ব্যবহার করবে। এখানে একটি উদাহরণ:

val pi: Double by lazy {
    println("Calculating PI...")
    3.14159
}

fun main() {
    println("Before accessing PI")
    println("PI: $pi")
    println("After accessing PI")
}

আউটপুট:

Before accessing PI
Calculating PI...
PI: 3.14159
After accessing PI

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

ডিফল্ট আর্গুমেন্ট এবং নামযুক্ত আর্গুমেন্ট

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

fun greet(name: String = "Guest", age: Int = 0) {
    println("Hello, $name! You are $age years old.")
}

fun main() {
    greet("Alice", 30)
    greet("Bob")
    greet(age = 25)
}

আউটপুট:

Hello, Alice! You are 30 years old.
Hello, Bob! You are 0 years old.
Hello, Guest! You are 25 years old.

‘যখন’ একাধিক শর্ত সহ অভিব্যক্তি

কোটলিনের ‘কখন’ অভিব্যক্তি কমা ব্যবহার করে একটি একক শাখায় একাধিক শর্ত পরিচালনা করতে পারে। এটি একাধিক মামলা পরিচালনা করার একটি সংক্ষিপ্ত উপায়। এখানে একটি উদাহরণ:

fun describeDay(day: String) {
    when (day) {
        "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> println("Weekday")
        "Saturday", "Sunday" -> println("Weekend")
        else -> println("Invalid day")
    }
}

fun main() {
    describeDay("Monday")
    describeDay("Saturday")
    describeDay("Sunday")
    describeDay("Wednesday")
    describeDay("Friday")
    describeDay("Holiday")
}

আউটপুট:

Weekday
Weekend
Weekend
Weekday
Weekday
Invalid day

‘ইন’ অপারেটর ব্যবহার করে

‘ইন’ অপারেটর চেক করে যে একটি মান একটি পরিসর, একটি সংগ্রহ বা একটি স্ট্রিং-এ উপস্থিত আছে কিনা। এটি কন্টেনমেন্ট চেক করার একটি সংক্ষিপ্ত উপায়। এখানে একটি উদাহরণ:

fun main() {
    val num = 5
    if (num in 1..10) {
        println("$num is between 1 and 10")
    }

    val names = listOf("Alice", "Bob", "Charlie")
    if ("Alice" in names) {
        println("Alice is in the list")
    }
}

আউটপুট:

5 is between 1 and 10
Alice is in the list

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

সহচর বস্তুর জন্য এক্সটেনশন ফাংশন

আপনি একটি ক্লাসের সহচর বস্তুর জন্য এক্সটেনশন ফাংশন তৈরি করতে পারেন। এটি আপনাকে সহচর বস্তুতে নতুন কার্যকারিতা যোগ করতে দেয়। এখানে একটি উদাহরণ:

class MyClass {
    companion object {
        fun hello() {
            println("Hello from the companion object!")
        }
    }
}

fun MyClass.Companion.greet() {
    println("Greetings from the extended companion object!")
}

fun main() {
    MyClass.hello()
    MyClass.greet()
}

আউটপুট:

Hello from the companion object!
Greetings from the extended companion object!

‘মানচিত্র’, ‘ফিল্টার’, এবং ‘কমা’ সহ কার্যকরী প্রোগ্রামিং

Kotlin ‘মানচিত্র’, ‘ফিল্টার’, এবং ‘কমাবার’ মত উচ্চ-ক্রম ফাংশন সহ কার্যকরী প্রোগ্রামিং সমর্থন করে। এখানে এই ফাংশন ব্যবহার করার একটি উদাহরণ:

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    // Using 'map' to square each number
    val squaredNumbers = numbers.map { it * it }
    println("Squared numbers: $squaredNumbers")

    // Using 'filter' to get even numbers
    val evenNumbers = numbers.filter { it % 2 == 0 }
    println("Even numbers: $evenNumbers")

    // Using 'reduce' to calculate the sum of numbers
    val sum = numbers.reduce { acc, number -> acc + number }
    println("Sum of numbers: $sum")
}

আউটপুট:

Squared numbers: [1, 4, 9, 16, 25]
Even numbers: [2, 4]
Sum of numbers: 15

এলভিস অপারেটর এবং নিরাপদ কল

এলভিস অপারেটর ( ?:) একটি ডিফল্ট মান প্রদান করে যখন বাতিলযোগ্য ভেরিয়েবলের সাথে কাজ করে। নিরাপদ কল ( ?.) আপনাকে নিরাপদে অকার্যকর বস্তুর বৈশিষ্ট্য এবং পদ্ধতি অ্যাক্সেস করতে দেয়। এখানে একটি উদাহরণ:

fun main() {
    val name: String? = null
    val length = name?.length ?: 0
    println("Length of name: $length")
}

আউটপুট:

Length of name: 0

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

Async এবং অপেক্ষার সাথে Coroutines

asyncCoroutines ব্যবহার করে এবং awaitফলাফল পুনরুদ্ধার করতে অ্যাসিঙ্ক্রোনাস অপারেশন করতে পারে । এটি আপনাকে সমসাময়িক কাজগুলি দক্ষতার সাথে সম্পাদন করতে দেয়। এখানে একটি উদাহরণ:

import kotlinx.coroutines.*

suspend fun fetchUserData(userId: Int): String {
    // Simulate an API call with a delay
    delay(1000)
    return "User data for ID $userId"
}

fun main() = runBlocking {
    val userIds = listOf(1, 2, 3)

    // Launch coroutines to fetch user data concurrently
    val deferredResults = userIds.map { userId ->
        async { fetchUserData(userId) }
    }

    // Await all the results and print them
    deferredResults.awaitAll().forEach {
        println(it)
    }
}

আউটপুট:

User data for ID 1
User data for ID 2
User data for ID 3

সংগ্রহ: ‘associateBy’ এবং ‘groupingBy’

কোটলিনের স্ট্যান্ডার্ড লাইব্রেরি দরকারী সংগ্রহ ফাংশন প্রদান করে। ফাংশনটি associateByএকটি মানচিত্র তৈরি করে যেখানে কীগুলি উপাদানগুলি থেকে উদ্ভূত হয় এবং groupingByএকটি নির্দিষ্ট কী নির্বাচকের উপর ভিত্তি করে উপাদানগুলিকে গোষ্ঠীভুক্ত করে। এখানে একটি উদাহরণ:

data class Person(val name: String, val age: Int)

fun main() {
    val people = listOf(
        Person("Alice", 30),
        Person("Bob", 25),
        Person("Charlie", 30)
    )

    // Creating a map with name as key and person as value
    val nameToPersonMap = people.associateBy { it.name }
    println("Name to Person Map: $nameToPersonMap")

    // Grouping people by age
    val peopleByAge = people.groupingBy { it.age }.eachCount()
    println("People grouped by age: $peopleByAge")
}

আউটপুট:

Name to Person Map: {Alice=Person(name=Alice, age=30), Bob=Person(name=Bob, age=25), Charlie=Person(name=Charlie, age=30)}
People grouped by age: {30=2, 25=1}

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

শূন্য প্রকারের এক্সটেনশন ফাংশন

আপনি nullable ধরনের উপর এক্সটেনশন ফাংশন সংজ্ঞায়িত করতে পারেন, আপনি nullable ভেরিয়েবলের উপর অপারেশন সঞ্চালনের অনুমতি দেয়। এখানে একটি উদাহরণ:

fun String?.isNullOrBlankOrEmpty(): Boolean {
    return this == null || this.isBlank()
}

fun main() {
    val str1: String? = null
    val str2: String? = ""
    val str3: String? = "Hello, Kotlin!"

    println("str1 is blank or empty: ${str1.isNullOrBlankOrEmpty()}")
    println("str2 is blank or empty: ${str2.isNullOrBlankOrEmpty()}")
    println("str3 is blank or empty: ${str3.isNullOrBlankOrEmpty()}")
}

আউটপুট:

str1 is blank or empty: true
str2 is blank or empty: true
str3 is blank or empty: false

ইনলাইন ক্লাস

Kotlin 1.3 ইনলাইন ক্লাস চালু করেছে, যা একটি একক মান মোড়ানো এবং এতে নতুন কার্যকারিতা যোগ করতে ব্যবহৃত হয়। এগুলি আদিম প্রকারের অনুরূপ তবে অতিরিক্ত পদ্ধতি সহ। এখানে একটি উদাহরণ:

inline class ZipCode(val value: String)

fun main() {
    val zipCode = ZipCode("12345")
    println("Zip Code: ${zipCode.value}")
}

আউটপুট:

Zip Code: 12345

ডায়নামিক টাইপ চেক

ডাইনামিক টাইপ চেক এবং টাইপ কাস্টিংয়ের জন্য Kotlin ‘is’ এবং ‘as’ অপারেটর প্রদান করে। এখানে একটি উদাহরণ:

fun printType(obj: Any) {
    if (obj is String) {
        println("$obj is a String")
    } else if (obj is Int) {
        println("$obj is an Int")
    } else {
        println("Unknown type")
    }
}

fun main() {
    printType("Hello")
    printType(42)
    printType(3.14)
}

আউটপুট:

Hello is a String
42 is an Int
Unknown type

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

কাস্টম টীকা

Kotlin আপনাকে আপনার কোডে মেটাডেটা বা আচরণ যোগ করতে কাস্টম টীকা তৈরি করতে দেয়। এখানে একটি কাস্টম টীকা সংজ্ঞায়িত এবং ব্যবহার করার একটি উদাহরণ:

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation

@MyAnnotation
class MyClass

fun main() {
    val annotation = MyClass::class.annotations.find { it.annotationClass == MyAnnotation::class }
    if (annotation != null) {
        println("MyAnnotation found on MyClass")
    } else {
        println("MyAnnotation not found on MyClass")
    }
}

আউটপুট:

MyAnnotation found on MyClass

Kotlinx সিরিয়ালাইজেশন সহ ডেটা সিরিয়ালাইজেশন

Kotlinx সিরিয়ালাইজেশন একটি মাল্টিপ্ল্যাটফর্ম লাইব্রেরি যা কোটলিন ক্লাসের জন্য সিরিয়ালাইজেশন এবং ডিসিরিয়ালাইজেশন সমর্থন প্রদান করে। এখানে Kotlinx সিরিয়ালাইজেশন ব্যবহার করার একটি উদাহরণ:

import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json

@Serializable
data class Person(val name: String, val age: Int)

fun main() {
    val person = Person("Alice", 30)

    // Serialize the object to JSON
    val json = Json.encodeToString(Person.serializer(), person)
    println("Serialized JSON: $json")

    // Deserialize JSON to an object
    val deserializedPerson = Json.decodeFromString(Person.serializer(), json)
    println("Deserialized Person: $deserializedPerson")
}

আউটপুট:

Serialized JSON: {"name":"Alice","age":30}
Deserialized Person: Person(name=Alice, age=30)

জেনেরিক সহ প্রজেকশন টাইপ করুন

outKotlin এবং কীওয়ার্ড ব্যবহার করে জেনেরিক সহ টাইপ প্রজেকশন সমর্থন করে in। এটি আপনাকে সাবটাইপ এবং সুপার টাইপের সাথে কাজ করতে দেয়। এখানে একটি উদাহরণ:

interface Source {
    fun get(): T
}

fun getSource(): Source {
    return object : Source {
        override fun get(): String = "Hello, Kotlin!"
    }
}

fun main() {
    val source: Source = getSource()
    val value: Any = source.get()
    println("Value: $value")
}

আউটপুট:

Value: Hello, Kotlin!

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

ফাংশন প্রকারের জন্য উপনাম টাইপ করুন

Kotlin আপনাকে ফাংশন প্রকারের জন্য টাইপ উপনাম তৈরি করতে দেয়, যা কোডকে আরও পঠনযোগ্য করে তুলতে পারে, বিশেষ করে জটিল ফাংশন প্রকারের জন্য। এখানে একটি উদাহরণ:

typealias Operation = (Int, Int) -> Int

fun add(a: Int, b: Int): Int = a + b
fun subtract(a: Int, b: Int): Int = a - b

fun main() {
    val operation: Operation = ::add
    println("Result of add operation: ${operation(5, 3)}")

    val anotherOperation: Operation = ::subtract
    println("Result of subtract operation: ${anotherOperation(5, 3)}")
}

আউটপুট:

Result of add operation: 8
Result of subtract operation: 2

DSL সহ টাইপ-সেফ বিল্ডার

টাইপ-সেফ বিল্ডার ব্যবহার করে কোটলিনে ডোমেন-স্পেসিফিক ল্যাঙ্গুয়েজ (DSLs) তৈরি করা যেতে পারে। এটি আপনাকে নির্দিষ্ট কাজের জন্য আরও সংক্ষিপ্ত এবং অভিব্যক্তিপূর্ণ কোড তৈরি করতে দেয়। এখানে একটি উদাহরণ:

class Person {
    var name: String = ""
    var age: Int = 0
}

fun person(block: Person.() -> Unit): Person {
    val person = Person()
    person.block()
    return person
}

fun main() {
    val person = person {
        name = "Alice"
        age = 30
    }

    println("Person: ${person.name}, ${person.age} years old.")
}

আউটপুট:

Person: Alice, 30 years old.

KotlinPoet এর সাথে টীকা প্রক্রিয়াকরণ

KotlinPoet একটি Kotlin DSL এর মাধ্যমে Kotlin কোড তৈরি করার জন্য একটি লাইব্রেরি। এটি প্রায়শই টীকা প্রক্রিয়াকরণ এবং কোড তৈরির কাজগুলির জন্য ব্যবহৃত হয়। এখানে একটি সহজ উদাহরণ:

import com.squareup.kotlinpoet.FileSpec
import com.squareup.kotlinpoet.FunSpec

fun main() {
    val mainFun = FunSpec.builder("main")
        .addStatement("println(\"Hello, KotlinPoet!\")")
        .build()

    val file = FileSpec.builder("com.example", "HelloWorld")
        .addFunction(mainFun)
        .build()

    file.writeTo(System.out)
}

আউটপুট:

package com.example

fun main() {
    println("Hello, KotlinPoet!")
}

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

ডেটা ক্লাসে সিল করা বৈশিষ্ট্য

Kotlin 1.5 ডেটা ক্লাসে “সিলড প্রপার্টি” নামে একটি নতুন বৈশিষ্ট্য চালু করেছে। এটি আপনাকে ডেটা ক্লাসে পৃথক বৈশিষ্ট্যগুলিকে সিল করা হিসাবে চিহ্নিত করার অনুমতি দেয়, তাদের উপশ্রেণীগুলিকে সীমাবদ্ধ করে এবং উপশ্রেণীগুলির একটি নির্দিষ্ট সেট প্রয়োগ করে৷ এখানে একটি উদাহরণ:

sealed interface Shape

data class Circle(val radius: Double) : Shape()
data class Square(val sideLength: Double) : Shape()

fun calculateArea(shape: Shape): Double {
    return when (shape) {
        is Circle -> Math.PI * shape.radius * shape.radius
        is Square -> shape.sideLength * shape.sideLength
    }
}

fun main() {
    val circle = Circle(5.0)
    val square = Square(4.0)

    println("Circle area: ${calculateArea(circle)}")
    println("Square area: ${calculateArea(square)}")
}

আউটপুট:

Circle area: 78.53981633974483
Square area: 16.0

ল্যাম্বডা এক্সটেনশন সহ কাস্টম ডিএসএল

আপনি আরও অভিব্যক্তিপূর্ণ এবং ডোমেন-নির্দিষ্ট কোড তৈরি করতে ল্যাম্বডা এক্সটেনশন ব্যবহার করে কোটলিনে কাস্টম ডিএসএল তৈরি করতে পারেন। এখানে একটি সাধারণ HTML DSL তৈরির একটি উদাহরণ:

class Tag(val name: String) {
    private val children = mutableListOf()

    fun tag(name: String, block: Tag.() -> Unit) {
        val child = Tag(name)
        child.block()
        children.add(child)
    }

    override fun toString(): String {
        return "<$name>${children.joinToString("")}"
    }
}

fun html(block: Tag.() -> Unit): Tag {
    val root = Tag("html")
    root.block()
    return root
}

fun main() {
    val result = html {
        tag("head") {
            tag("title") {
                "Page Title"
            }
        }
        tag("body") {
            tag("h1") {
                "Hello, DSL!"
            }
            tag("p") {
                "This is a custom DSL example."
            }
        }
    }

    println(result)
}

আউটপুট:

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

সঙ্গী অবজেক্ট এক্সটেনশন

কোটলিনে, আপনি সহচর বস্তুতে এক্সটেনশন ফাংশন যোগ করতে পারেন। এটি আপনাকে তার সোর্স কোড পরিবর্তন না করে সহচর বস্তুতে আচরণ যোগ করতে দেয়। এখানে একটি উদাহরণ:

class MyClass {
    companion object {
        fun greet() {
            println("Hello from the companion object!")
        }
    }
}

fun MyClass.Companion.sayHello() {
    println("Hello from the extended companion object!")
}

fun main() {
    MyClass.greet()
    MyClass.sayHello()
}

আউটপুট:

Hello from the companion object!
Hello from the extended companion object!

ভিন্নতা: জেনেরিকের সাথে ‘আউট’ এবং ‘ইন’ মডিফায়ার

‘আউট’ এবং ‘ইন’ মডিফায়ারগুলি ভ্যারিয়েন্স নির্দিষ্ট করতে জেনেরিক প্রকারে ব্যবহৃত হয়। ‘আউট’ একটি টাইপ প্যারামিটার কোভেরিয়েন্ট (শুধু-পঠন) করে, যখন ‘ইন’ এটিকে বিপরীত করে (শুধুমাত্র লিখতে)। এখানে একটি উদাহরণ:

interface Producer {
    fun produce(): T
}

interface Consumer {
    fun consume(item: T)
}

fun main() {
    val stringProducer: Producer = object : Producer {
        override fun produce(): String = "Hello, Kotlin!"
    }

    val anyConsumer: Consumer = object : Consumer {
        override fun consume(item: Any) {
            println("Consuming: $item")
        }
    }

    val item: Any = stringProducer.produce()
    anyConsumer.consume(item)
}

আউটপুট:

Consuming: Hello, Kotlin!

‘ইনলাইন’ সহ রিফাইড টাইপ প্যারামিটার

‘রিফাইড’ মডিফায়ারটি শুধুমাত্র ‘ইনলাইন’ ফাংশনের সাথে ব্যবহার করা যেতে পারে রানটাইমে জেনেরিক প্যারামিটারের প্রকৃত প্রকার অ্যাক্সেস করতে। এটি আপনাকে টাইপ তথ্যের প্রয়োজন এমন ক্রিয়াকলাপগুলি সম্পাদন করতে দেয়। এখানে একটি উদাহরণ:

inline fun  printType() {
    println("Type: ${T::class.simpleName}")
}

fun main() {
    printType()
    printType()
    printType()
}

আউটপুট:

Type: String
Type: Int
Type: Double

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

টাইপ ইরেজার এবং ইনলাইন রিফাইড টাইপ

কোটলিন, জাভার মতো, জেনেরিক ধরণের সাথে কাজ করার সময় টাইপ ইরেজারে ভোগে। যাইহোক, টাইপ প্যারামিটার inlineসহ ফাংশন ব্যবহার করে reified, আপনি এই সীমাবদ্ধতা অতিক্রম করতে পারেন এবং রানটাইমে জেনেরিক টাইপের তথ্য অ্যাক্সেস করতে পারেন। এখানে একটি উদাহরণ:

inline fun  printType(list: List) {
    println("List of ${T::class.simpleName}: $list")
}

fun main() {
    val listInt = listOf(1, 2, 3)
    val listString = listOf("a", "b", "c")

    printType(listInt)
    printType(listString)
}

আউটপুট:

List of Int: [1, 2, 3]
List of String: [a, b, c]

লুপগুলিতে ধ্বংসাত্মক ঘোষণা

Kotlin loops মধ্যে destructuring ঘোষণার অনুমতি দেয়, এটি জোড়া, ট্রিপল, বা কাস্টম ডেটা ক্লাসের উপাদানগুলির উপর পুনরাবৃত্তি করা সহজ করে তোলে। এখানে একটি উদাহরণ:

data class Person(val name: String, val age: Int)

fun main() {
    val people = listOf(Person("Alice", 30), Person("Bob", 25), Person("Charlie", 40))

    for ((name, age) in people) {
        println("$name is $age years old.")
    }
}

আউটপুট:

Alice is 30 years old.
Bob is 25 years old.
Charlie is 40 years old.

ট্রিপল কোট সহ স্ট্রিং ইন্টারপোলেশন

Kotlin মাল্টিলাইন স্ট্রিংগুলির জন্য ট্রিপল-কোটেড স্ট্রিং সমর্থন করে, লাইন ব্রেক সংরক্ষণ করে এবং স্ট্রিং ইন্টারপোলেশনের অনুমতি দেয়। এখানে একটি উদাহরণ:

fun main() {
    val message = """
        |Hello, Kotlin!
        |This is a multiline string.
        |${2 + 3} equals 5.
    """.trimMargin()

    println(message)
}

আউটপুট:

Hello, Kotlin!
This is a multiline string.
5 equals 5.

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

Coroutines: ব্যতিক্রম হ্যান্ডলিং

কোরোটিনে, আপনি try-catchনিয়মিত সিঙ্ক্রোনাস কোডের মতো ব্লক ব্যবহার করে ব্যতিক্রমগুলি পরিচালনা করতে পারেন। এখানে একটি উদাহরণ:

import kotlinx.coroutines.*

suspend fun doSomething() {
    delay(100)
    throw RuntimeException("Oops, something went wrong!")
}

fun main() = runBlocking {
    try {
        doSomething()
    } catch (e: Exception) {
        println("Caught exception: ${e.message}")
    }
}

আউটপুট:

Caught exception: Oops, something went wrong!

‘লেট’, ‘রান’, ‘সাথে’, ‘প্রয়োগ করুন’ এবং ‘এছাড়াও’ সহ কার্যকরী প্রোগ্রামিং

কোটলিন বিভিন্ন স্কোপ ফাংশন প্রদান করে যা কার্যকরী প্রোগ্রামিংকে আরও সংক্ষিপ্ত করে তোলে। এই ফাংশনগুলি হল letrunwithapply, এবং alsoএখানে তাদের প্রতিটি ব্যবহার করার একটি উদাহরণ:

data class Person(var name: String, var age: Int)

fun main() {
    val person = Person("Alice", 30)

    val letResult = person.let {
        it.name = "Bob"
        it.age + 5
    }
    println("letResult: $letResult, person: $person")

    val runResult = person.run {
        name = "Charlie"
        age + 10
    }
    println("runResult: $runResult, person: $person")

    val withResult = with(person) {
        name = "David"
        age + 15
    }
    println("withResult: $withResult, person: $person")

    val applyResult = person.apply {
        name = "Eva"
        age + 20
    }
    println("applyResult: $applyResult, person: $person")

    val alsoResult = person.also {
        it.name = "Fiona"
        it.age + 25
    }
    println("alsoResult: $alsoResult, person: $person")
}

আউটপুট:

letResult: 35, person: Person(name=Bob, age=30)
runResult: 40, person: Person(name=Charlie, age=40)
withResult: 45, person: Person(name=David, age=45)
applyResult: Person(name=Eva, age=45), person: Person(name=Eva, age=45)
alsoResult: Person(name=Fiona, age=45), person: Person(name=Fiona, age=45)

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

অবশ্যই, আসুন আরও কোটলিন ধারণাগুলি অন্বেষণ চালিয়ে যাই:

সিল ক্লাস এবং যখন অভিব্যক্তি

সীলমোহর করা ক্লাসগুলি সীমাবদ্ধ শ্রেণির শ্রেণিবিন্যাসের প্রতিনিধিত্ব করতে ব্যবহৃত হয়। whenএগুলি সম্পূর্ণ চেকের জন্য অভিব্যক্তির সাথে একত্রে ব্যবহার করা যেতে পারে । এখানে একটি উদাহরণ:

sealed class Result
data class Success(val data: String) : Result()
data class Error(val message: String) : Result()

fun processResult(result: Result) {
    when (result) {
        is Success -> println("Data: ${result.data}")
        is Error -> println("Error: ${result.message}")
    }
}

fun main() {
    val successResult = Success("Kotlin is awesome!")
    val errorResult = Error("Something went wrong!")

    processResult(successResult)
    processResult(errorResult)
}

আউটপুট:

Data: Kotlin is awesome!
Error: Something went wrong!

@JvmOverloads টীকা

@JvmOverloadsডিফল্ট প্যারামিটার মান সহ ফাংশন সংজ্ঞায়িত করার সময় টীকা ব্যবহার করা হয় । এটি কোটলিন কম্পাইলারকে জাভা ইন্টারঅপারেবিলিটির জন্য ফাংশনের ওভারলোডেড সংস্করণ তৈরি করার নির্দেশ দেয়। এখানে একটি উদাহরণ:

class MyCalculator {
    @JvmOverloads
    fun add(a: Int, b: Int, c: Int = 0): Int {
        return a + b + c
    }
}

fun main() {
    val calculator = MyCalculator()
    println(calculator.add(2, 3))
    println(calculator.add(2, 3, 5))
}

আউটপুট:

5
10

ইনফিক্স ফাংশন

ইনফিক্স ফাংশন আপনাকে ইনফিক্স নোটেশন ব্যবহার করে একটি একক প্যারামিটার সহ একটি ফাংশন কল করার অনুমতি দেয়। নির্দিষ্ট ক্রিয়াকলাপগুলির সাথে কাজ করার সময় এটি আপনার কোডকে আরও পাঠযোগ্য করে তুলতে পারে। এখানে একটি উদাহরণ:

infix fun Int.multiplyBy(x: Int): Int {
    return this * x
}

fun main() {
    val result = 5 multiplyBy 3
    println("Result: $result")
}

আউটপুট:

Result: 15

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

অর্পিত বৈশিষ্ট্য: ‘অলস’, ‘পর্যবেক্ষণযোগ্য’ এবং ‘ভেটোযোগ্য’

কোটলিন তিনটি দরকারী অর্পিত সম্পত্তি প্রকার সরবরাহ করে: lazyobservableএবং vetoable.

  • lazy: অলসভাবে মানটি শুরু করে এবং পরবর্তী অ্যাক্সেসের জন্য এটি ক্যাশ করে।
  • observable: একটি শ্রোতা যোগ করে যে সম্পত্তির মান পরিবর্তন পর্যবেক্ষণ করে।
  • vetoable: আপনাকে একটি কাস্টম বৈধতা প্রদান করে সম্পত্তিতে পরিবর্তন ভেটো করার অনুমতি দেয়।

এখানে একটি উদাহরণ:

import kotlin.properties.Delegates

class Example {
    val lazyValue: String by lazy {
        println("Initializing lazyValue")
        "Lazy value"
    }

    var observableValue: String by Delegates.observable("Initial value") { _, oldValue, newValue ->
        println("Old value: $oldValue, New value: $newValue")
    }

    var vetoableValue: Int by Delegates.vetoable(0) { _, oldValue, newValue ->
        newValue >= oldValue
    }
}

fun main() {
    val example = Example()

    println(example.lazyValue)
    println(example.lazyValue)

    example.observableValue = "Updated value"
    example.observableValue = "Another update"

    println("vetoableValue: ${example.vetoableValue}")
    example.vetoableValue = 10
    println("vetoableValue: ${example.vetoableValue}")
    example.vetoableValue = 5
}

আউটপুট:

Initializing lazyValue
Lazy value
Lazy value
Old value: Initial value, New value: Updated value
Old value: Updated value, New value: Another update
vetoableValue: 0
vetoableValue: 10

জটিল প্রকারের জন্য উপনাম টাইপ করুন

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

typealias DoubleList = List
typealias StringMap = Map

fun main() {
    val doubleList: DoubleList = listOf(1.0, 2.0, 3.0)
    val stringMap: StringMap = mapOf("one" to 1, "two" to 2, "three" to 3)

    println("Double List: $doubleList")
    println("String Map: $stringMap")
}

আউটপুট:

Double List: [1.0, 2.0, 3.0]
String Map: {one=1, two=2, three=3}

কাস্টম সেটার্স এবং গেটার

কোটলিনে, আপনি বৈশিষ্ট্যগুলির জন্য কাস্টম সেটার এবং গেটারকে সংজ্ঞায়িত করতে পারেন, আপনাকে মানগুলি পাওয়ার বা সেট করার সময় যুক্তি যোগ করার অনুমতি দেয়। এখানে একটি উদাহরণ:

class Person {
    var name: String = ""
        get() {
            println("Getting name: $field")
            return field
        }
        set(value) {
            println("Setting name to $value")
            field = value
        }
}

fun main() {
    val person = Person()
    person.name = "Alice"
    println("Name: ${person.name}")
}

আউটপুট:

Setting name to Alice
Getting name: Alice
Name: Alice

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

স্থানীয় ফাংশন

কোটলিনে, আপনি স্থানীয় ফাংশন হিসাবে পরিচিত অন্যান্য ফাংশনের ভিতরে ফাংশনগুলি সংজ্ঞায়িত করতে পারেন। এই ফাংশনগুলির এনক্লোসিং ফাংশনের ভেরিয়েবলগুলিতে অ্যাক্সেস রয়েছে এবং আপনাকে লজিক এনক্যাপসুলেট করতে সহায়তা করতে পারে। এখানে একটি উদাহরণ:

fun main() {
    fun printMessage(message: String) {
        println("Message: $message")
    }

    printMessage("Hello, Kotlin!")
}

আউটপুট:

Message: Hello, Kotlin!

পুচ্ছ পুনরাবৃত্ত ফাংশন

কোটলিন এমন ফাংশনগুলির জন্য টেইল রিকারশন অপ্টিমাইজেশান সমর্থন করে যেগুলি নিজেদেরকে শেষ অপারেশন হিসাবে ডাকে৷ এটি বড় পুনরাবৃত্ত কলের জন্য স্ট্যাক ওভারফ্লো ত্রুটি প্রতিরোধ করতে পারে। এখানে একটি উদাহরণ:

tailrec fun factorial(n: Int, acc: Int = 1): Int {
    return if (n == 0) acc else factorial(n - 1, acc * n)
}

fun main() {
    val result = factorial(5)
    println("Factorial of 5: $result")
}

আউটপুট:

Factorial of 5: 120

Enum ক্লাস এবং বৈশিষ্ট্য

কোটলিনে Enum ক্লাসের বৈশিষ্ট্য থাকতে পারে, ঠিক নিয়মিত ক্লাসের মতো। এটি আপনাকে প্রতিটি enum ধ্রুবকের সাথে অতিরিক্ত ডেটা যোগ করতে দেয়। এখানে একটি উদাহরণ:

enum class Color(val hexCode: String) {
    RED("#FF0000"),
    GREEN("#00FF00"),
    BLUE("#0000FF")
}

fun main() {
    println("Red Hex Code: ${Color.RED.hexCode}")
    println("Green Hex Code: ${Color.GREEN.hexCode}")
    println("Blue Hex Code: ${Color.BLUE.hexCode}")
}

আউটপুট:

Red Hex Code: #FF0000
Green Hex Code: #00FF00
Blue Hex Code: #0000FF

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

এক্সটেনশন বৈশিষ্ট্য

কোটলিনে, আপনি তাদের সোর্স কোড পরিবর্তন না করে বিদ্যমান ক্লাসে নতুন বৈশিষ্ট্য যোগ করতে এক্সটেনশন বৈশিষ্ট্যগুলিকেও সংজ্ঞায়িত করতে পারেন। এখানে একটি উদাহরণ:

class Rectangle(val width: Double, val height: Double)

val Rectangle.area: Double
    get() = width * height

fun main() {
    val rectangle = Rectangle(5.0, 3.0)
    println("Rectangle area: ${rectangle.area}")
}

আউটপুট:

Rectangle area: 15.0

দেরী-সূচনা বৈশিষ্ট্য

কোটলিনে, আপনি lateinitবৈশিষ্ট্যগুলি চিহ্নিত করতে সংশোধক ব্যবহার করতে পারেন যা পরে আরম্ভ করা হবে (বস্তু তৈরির পরে)। সম্পত্তিটি অবশ্যই একটি নন-নালেবল টাইপ হতে হবে এবং এটি অ্যাক্সেস করার আগে শুরু করা উচিত, বা এটি একটি নিক্ষেপ করবে LateinitPropertyAccessException। এখানে একটি উদাহরণ:

class Example {
    lateinit var name: String

    fun init() {
        name = "Kotlin"
    }
}

fun main() {
    val example = Example()
    example.init()

    println("Name: ${example.name}")
}

আউটপুট:

Name: Kotlin

ইন্টারফেস ফাংশনে Tailrec মডিফায়ার

Kotlin 1.5 থেকে শুরু করে, আপনি tailrecনিয়মিত ফাংশনের মতো ইন্টারফেস ফাংশনে মডিফায়ার ব্যবহার করতে পারেন। এটি ক্লাস বাস্তবায়নে টেল কল অপ্টিমাইজেশনের অনুমতি দেয়। এখানে একটি উদাহরণ:

interface FactorialCalculator {
    tailrec fun factorial(n: Int, acc: Int = 1): Int {
        return if (n == 0) acc else factorial(n - 1, acc * n)
    }
}

class FactorialImpl : FactorialCalculator

fun main() {
    val factorialImpl = FactorialImpl()
    val result = factorialImpl.factorial(5)
    println("Factorial of 5: $result")
}

আউটপুট:

Factorial of 5: 120

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

সেকেন্ডারি কনস্ট্রাক্টর

কোটলিন আপনাকে একটি ক্লাসে সেকেন্ডারি কনস্ট্রাক্টর সংজ্ঞায়িত করতে দেয়, অবজেক্ট শুরু করার বিকল্প উপায় প্রদান করে। এখানে একটি উদাহরণ:

class Person(val name: String) {
    var age: Int = 0

    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}

fun main() {
    val person1 = Person("Alice")
    val person2 = Person("Bob", 25)

    println("Person 1: ${person1.name}, ${person1.age} years old.")
    println("Person 2: ${person2.name}, ${person2.age} years old.")
}

আউটপুট:

Person 1: Alice, 0 years old.
Person 2: Bob, 25 years old.

অপারেটর ওভারলোডিং সহ সঙ্গী অবজেক্ট এক্সটেনশন

আপনি আপনার ক্লাসে অতিরিক্ত আচরণ প্রদান করতে সহচর অবজেক্টে এক্সটেনশন ফাংশন হিসাবে অপারেটর ওভারলোডগুলিকে সংজ্ঞায়িত করতে পারেন। এখানে একটি উদাহরণ:

data class Point(val x: Int, val y: Int) {
    companion object {
        operator fun Point.plus(other: Point): Point {
            return Point(x + other.x, y + other.y)
        }
    }
}

fun main() {
    val p1 = Point(2, 3)
    val p2 = Point(4, 5)
    val sum = p1 + p2
    println("Sum: (${sum.x}, ${sum.y})")
}

আউটপুট:

Sum: (6, 8)

পরিসর এবং অগ্রগতি

কোটলিন মানগুলির ক্রম উপস্থাপন করার জন্য ব্যাপ্তি এবং অগ্রগতি প্রদান করে। এখানে একটি উদাহরণ:

fun main() {
    // Closed range [1, 10]
    val range = 1..10

    // Half-open range [1, 10)
    val halfOpenRange = 1 until 10

    // Range with step 2 [1, 3, 5, 7, 9]
    val steppedRange = 1..10 step 2

    // Reverse range [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
    val reversedRange = 10 downTo 1

    // Print the ranges
    println("Range: $range")
    println("Half-Open Range: $halfOpenRange")
    println("Stepped Range: $steppedRange")
    println("Reversed Range: $reversedRange")

    // Iterate through the range
    for (i in 1..5) {
        print("$i ")
    }
}

আউটপুট:

Range: 1..10
Half-Open Range: 1 until 10
Stepped Range: 1..9 step 2
Reversed Range: 10 downTo 1
1 2 3 4 5

নামযুক্ত আর্গুমেন্টস

Kotlin-এ, আপনি নামযুক্ত আর্গুমেন্ট ব্যবহার করতে পারেন ফাংশন প্যারামিটারগুলিকে তাদের নামের দ্বারা নির্দিষ্ট করতে, তাদের অর্ডার নির্বিশেষে। এটি আপনার কোডকে আরও পঠনযোগ্য করে তুলতে পারে। এখানে একটি উদাহরণ:

fun greetPerson(name: String, age: Int) {
    println("Hello, $name! You are $age years old.")
}

fun main() {
    greetPerson(name = "Alice", age = 30)
    greetPerson(age = 25, name = "Bob")
}

আউটপুট:

Hello, Alice! You are 30 years old.
Hello, Bob! You are 25 years old.

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

এক্সটেনশন ফাংশন ইনফারেন্স

Kotlin আপনাকে স্পষ্ট নাল-চেক ছাড়াই সরাসরি বাতিলযোগ্য রিসিভার বস্তুতে এক্সটেনশন ফাংশন কল করার অনুমতি দেয়। এক্সটেনশন ফাংশনটি তখনই কল করা হবে যখন রিসিভারটি নন-নাল থাকে। এখানে একটি উদাহরণ:

fun String?.printLength() {
    if (this != null) {
        println("Length of the string: ${this.length}")
    } else {
        println("String is null")
    }
}

fun main() {
    val str1: String? = null
    val str2: String? = "Hello, Kotlin!"

    str1.printLength()
    str2.printLength()
}

আউটপুট:

String is null
Length of the string: 13

রিসিভার সহ ফাংশনের ধরন (রিসিভার সহ ফাংশন লিটারেল)

কোটলিন আপনাকে একটি রিসিভারের সাথে ফাংশন প্রকারগুলি সংজ্ঞায়িত করতে দেয়, যা রিসিভারের সাথে ফাংশন লিটারাল নামেও পরিচিত। এটি আপনাকে কীওয়ার্ড ব্যবহার করে ফাংশন ব্লকের ভিতরে রিসিভার অবজেক্ট অ্যাক্সেস করতে দেয় this। এখানে একটি উদাহরণ:

val greet: String.(String) -> String = { name -> "Hello, $name! I'm $this" }

fun main() {
    val greeting1 = "Alice".greet("Bob")
    val greeting2 = "Kotlin".greet("Developer")

    println(greeting1)
    println(greeting2)
}

আউটপুট:

Hello, Bob! I'm Alice
Hello, Developer! I'm Kotlin

HTML DSL-এর জন্য টাইপ-সেফ বিল্ডার

Kotlin আপনাকে DSL-এর জন্য টাইপ-সেফ বিল্ডার তৈরি করতে দেয়, যা HTML-এর মতো স্ট্রাকচার্ড কোড তৈরি করা সহজ করে। এখানে একটি উদাহরণ:

class Tag(val name: String) {
    private val children = mutableListOf()

    fun tag(name: String, block: Tag.() -> Unit) {
        val child = Tag(name)
        child.block()
        children.add(child)
    }

    override fun toString(): String {
        return buildString {
            append("<$name>")
            children.forEach {
                append(it)
            }
            append("")
        }
    }
}

fun html(block: Tag.() -> Unit): Tag {
    val root = Tag("html")
    root.block()
    return root
}

fun main() {
    val result = html {
        tag("head") {
            tag("title") {
                +"Page Title"
            }
        }
        tag("body") {
            tag("h1") {
                +"Hello, DSL!"
            }
            tag("p") {
                +"This is a custom HTML DSL example."
            }
        }
    }

    println(result)
}

আউটপুট:

Page TitleHello, DSL!This is a custom HTML DSL example.

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

Lambdas এ টাইপ ইনফারেন্স

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

fun processNumbers(numbers: List, operation: (Int) -> Int): List {
    return numbers.map { operation(it) }
}

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5)

    val squaredNumbers = processNumbers(numbers) { it * it }
    val doubledNumbers = processNumbers(numbers) { it * 2 }

    println("Squared Numbers: $squaredNumbers")
    println("Doubled Numbers: $doubledNumbers")
}

আউটপুট:

Squared Numbers: [1, 4, 9, 16, 25]
Doubled Numbers: [2, 4, 6, 8, 10]

ফাংশন রচনা

andThenকোটলিন আপনাকে এবং পদ্ধতিগুলি ব্যবহার করে ফাংশন রচনা করতে দেয় compose, যা কার্যকরী ইন্টারফেসে উপলব্ধ। এখানে একটি উদাহরণ:

val addOne: (Int) -> Int = { it + 1 }
val double: (Int) -> Int = { it * 2 }

val addOneAndThenDouble = addOne andThen double
val doubleAndThenAddOne = double compose addOne

fun main() {
    val result1 = addOneAndThenDouble(5)
    val result2 = doubleAndThenAddOne(5)

    println("Result1: $result1")
    println("Result2: $result2")
}

আউটপুট:

Result1: 12
Result2: 11

ইনলাইন ক্লাস

Kotlin 1.3 ইনলাইন ক্লাস চালু করেছে, যা আপনাকে লাইটওয়েট র্যাপার ক্লাস তৈরি করতে দেয়। ইনলাইন ক্লাসগুলি কম্পাইল-টাইমে তাদের অন্তর্নিহিত প্রকারগুলির সাথে প্রতিস্থাপিত হয়, রানটাইম ওভারহেড হ্রাস করে। এখানে একটি উদাহরণ:

inline class Username(val value: String)

fun printUsername(username: Username) {
    println("Username: ${username.value}")
}

fun main() {
    val username = Username("kotlin_user")
    printUsername(username)
}

আউটপুট:

Username: kotlin_user

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

স্ট্যান্ডার্ড লাইব্রেরি প্রকারের জন্য এক্সটেনশন ফাংশন

আপনি কোটলিনে স্ট্যান্ডার্ড লাইব্রেরি প্রকারের জন্য এক্সটেনশন ফাংশন তৈরি করতে পারেন, বিল্ট-ইন ক্লাসে ইউটিলিটি ফাংশন যোগ করা সহজ করে তোলে। এখানে একটি উদাহরণ:

fun String.removeWhitespace(): String {
    return this.replace("\\s+".toRegex(), "")
}

fun List.sumAll(): Int {
    return this.reduce { acc, i -> acc + i }
}

fun main() {
    val text = "  Hello  Kotlin  "
    val numbers = listOf(1, 2, 3, 4, 5)

    val cleanedText = text.removeWhitespace()
    val totalSum = numbers.sumAll()

    println("Cleaned Text: '$cleanedText'")
    println("Total Sum: $totalSum")
}

আউটপুট:

Cleaned Text: 'HelloKotlin'
Total Sum: 15

ইনলাইনড হাই-অর্ডার ফাংশন

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

inline fun execute(action: () -> Unit) {
    println("Start execution")
    action()
    println("End execution")
}

fun main() {
    execute {
        println("Inside inline function")
    }
}

আউটপুট:

Start execution
Inside inline function
End execution

টাইপ ইরেজার এবং রিফাইড টাইপ প্যারামিটার

কোটলিনে, জেনেরিক প্রকারগুলি টাইপ ইরেজারের মধ্য দিয়ে যায় এবং রানটাইমে তাদের টাইপ আর্গুমেন্ট পাওয়া যায় না। যাইহোক, আপনি reifiedরানটাইমে টাইপ তথ্য পুনরুদ্ধার করতে ইনলাইন ফাংশন সহ মডিফায়ার ব্যবহার করতে পারেন। এখানে একটি উদাহরণ:

inline fun  printType() {
    println("Type: ${T::class.simpleName}")
}

fun main() {
    printType()
    printType()
    printType()
}

আউটপুট:

Type: String
Type: Int
Type: Double

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

‘in’ এবং ‘is’ এর সাথে ‘when’ এক্সপ্রেশন চেক ব্যবহার করে

সাধারণ মান পরীক্ষা ছাড়াও, whenKotlin-এ অভিব্যক্তি আপনাকে আরও জটিল অবস্থার জন্য ‘in’ এবং ‘is’ চেক ব্যবহার করতে দেয়। এখানে একটি উদাহরণ:

fun describeValue(value: Any) {
    when (value) {
        in 1..10 -> println("Value is in the range of 1 to 10")
        is String -> println("Value is a String with length ${value.length}")
        is Boolean -> println("Value is a Boolean with value $value")
        else -> println("Value is something else")
    }
}

fun main() {
    describeValue(5)
    describeValue("Kotlin")
    describeValue(true)
    describeValue(3.14)
}

আউটপুট:

Value is in the range of 1 to 10
Value is a String with length 6
Value is a Boolean with value true
Value is something else

‘lateinit’ সহ দেরী-সূচনাকৃত বৈশিষ্ট্য

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

class Person {
    lateinit var name: String

    fun initPerson() {
        name = "Alice"
    }

    fun printName() {
        println("Name: $name")
    }
}

fun main() {
    val person = Person()
    person.initPerson()
    person.printName()
}

আউটপুট:

Name: Alice

মানচিত্র সহ ধ্বংসাত্মক ঘোষণা

কোটলিনে, আপনি মানচিত্র থেকে কী-মান জোড়া বের করতে ধ্বংসাত্মক ঘোষণা ব্যবহার করতে পারেন। এখানে একটি উদাহরণ:

fun main() {
    val personInfo = mapOf("name" to "Alice", "age" to 30, "city" to "Wonderland")

    val (name, age, city) = personInfo

    println("Name: $name, Age: $age, City: $city")
}

আউটপুট:

Name: Alice, Age: 30, City: Wonderland

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

অবজেক্ট এক্সপ্রেশন

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

interface Greeter {
    fun greet(name: String)
}

fun main() {
    val englishGreeter = object : Greeter {
        override fun greet(name: String) {
            println("Hello, $name!")
        }
    }

    val frenchGreeter = object : Greeter {
        override fun greet(name: String) {
            println("Bonjour, $name!")
        }
    }

    englishGreeter.greet("Alice")
    frenchGreeter.greet("Bob")
}

আউটপুট:

Hello, Alice!
Bonjour, Bob!

ইউনারি মাইনাস অপারেটর ওভারলোডিং

কোটলিনে, আপনি -একটি unaryMinus() ফাংশন সংজ্ঞায়িত করে আপনার কাস্টম ক্লাসের জন্য unary মাইনাস অপারেটর ( ) ওভারলোড করতে পারেন। এখানে একটি উদাহরণ:

data class Point(val x: Int, val y: Int) {
    operator fun unaryMinus() = Point(-x, -y)
}

fun main() {
    val point = Point(3, 4)
    val negativePoint = -point

    println("Original Point: (${point.x}, ${point.y})")
    println("Negative Point: (${negativePoint.x}, ${negativePoint.y})")
}

আউটপুট:

Original Point: (3, 4)
Negative Point: (-3, -4)

কাস্টম অবজেক্টের সাথে ‘ইন’ ব্যবহার করা

কোটলিনে, আপনি অপারেটর ( inকে ওভারলোড করে আপনার কাস্টম ক্লাসের জন্য অপারেটরকে সংজ্ঞায়িত করতে পারেন। এটি আপনাকে একটি বস্তু আপনার কাস্টম বস্তুর একটি সংগ্রহের অন্তর্গত কিনা তা পরীক্ষা করতে কীওয়ার্ড ব্যবহার করতে দেয় । এখানে একটি উদাহরণ:containsinin

data class Fruit(val name: String)

class FruitBasket(private val fruits: List) {
    operator fun contains(fruit: Fruit) = fruit in fruits
}

fun main() {
    val apple = Fruit("Apple")
    val orange = Fruit("Orange")

    val basket = FruitBasket(listOf(apple, orange))

    println("Is Apple in the basket? ${apple in basket}")
    println("Is Banana in the basket? ${Fruit("Banana") in basket}")
}

আউটপুট:

Is Apple in the basket? true
Is Banana in the basket? false

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

স্মার্ট কাস্ট

Kotlin স্মার্ট কাস্ট বৈশিষ্ট্য, যা আপনাকে স্বয়ংক্রিয়ভাবে একটি ভিন্ন ধরনের একটি পরিবর্তনশীল কাস্ট করার অনুমতি দেয় যখন নির্দিষ্ট শর্ত পূরণ হয়. উদাহরণস্বরূপ, একটি টাইপ চেক করার পরে, ভেরিয়েবলটি স্বয়ংক্রিয়ভাবে সংশ্লিষ্ট ব্লকের মধ্যে চেক করা টাইপে কাস্ট করা হয়। এখানে একটি উদাহরণ:

fun printLength(obj: Any) {
    if (obj is String) {
        println("String length: ${obj.length}")
    } else {
        println("Not a String")
    }
}

fun main() {
    printLength("Kotlin")
    printLength(10)
}

আউটপুট:

String length: 6
Not a String

অবজেক্ট ডিক্লারেশন

কোটলিনে, অবজেক্ট ডিক্লারেশন আপনাকে সিঙ্গেলটন তৈরি করতে দেয়, যেগুলো ক্লাসের শুধুমাত্র একটি উদাহরণ আছে। অবজেক্ট ডিক্লারেশন ব্যবহার করা হয় একটি অবজেক্ট ইনস্ট্যান্স অন-ডিমান্ড তৈরি করতে যখন প্রথম অ্যাক্সেস করা হয়। এখানে একটি উদাহরণ:

object Singleton {
    fun greet() {
        println("Hello, I'm a Singleton!")
    }
}

fun main() {
    Singleton.greet()
}

আউটপুট:

Hello, I'm a Singleton!

ফাংশন টাইপ নোটেশন

কোটলিন আপনাকে ফাংশনে পরামিতি হিসাবে ফাংশন প্রকারগুলি ব্যবহার করার অনুমতি দেয়। ফাংশন প্রকারগুলি বন্ধনী ব্যবহার করে চিহ্নিত করা হয়, যেখানে প্যারামিটারের প্রকারগুলি বন্ধনীতে তালিকাভুক্ত করা হয়, তারপরে একটি তীর ( ->) এবং রিটার্ন টাইপ। এখানে একটি উদাহরণ:

fun doOperation(operation: (Int, Int) -> Int) {
    val result = operation(5, 3)
    println("Result: $result")
}

fun main() {
    val add: (Int, Int) -> Int = { a, b -> a + b }
    val subtract: (Int, Int) -> Int = { a, b -> a - b }

    doOperation(add)
    doOperation(subtract)
}

আউটপুট:

Result: 8
Result: 2

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

ফাংশন রেফারেন্স

Kotlin আপনাকে ফাংশন রেফারেন্স ব্যবহার করার অনুমতি দেয়, যা একটি ফাংশনকে এটিকে আহ্বান না করে একটি যুক্তি হিসাবে পাস করার একটি সংক্ষিপ্ত উপায়। আপনি ::একটি ফাংশনের একটি রেফারেন্স পেতে অপারেটর ব্যবহার করতে পারেন। এখানে একটি উদাহরণ:

fun add(a: Int, b: Int): Int {
    return a + b
}

fun multiply(a: Int, b: Int): Int {
    return a * b
}

fun main() {
    val numbers = listOf(2, 3, 4)

    // Using function references
    val sum = numbers.fold(0, ::add)
    val product = numbers.fold(1, ::multiply)

    println("Sum: $sum")
    println("Product: $product")
}

আউটপুট:

Sum: 9
Product: 24

আর্গুমেন্ট ছাড়া ‘কখন’ এক্সপ্রেশন ব্যবহার করা

কোটলিনে, আপনি whenকোনো যুক্তি ছাড়াই অভিব্যক্তি ব্যবহার করতে পারেন। এই ক্ষেত্রে, প্রতিটি শাখা মূল্যায়ন করা হয় এবং যদি তার অবস্থা হয় তাহলে মৃত্যুদন্ড কার্যকর করা হয় true। এখানে একটি উদাহরণ:

fun main() {
    val day = "Monday"

    when {
        day == "Monday" -> println("Start of the week")
        day == "Friday" -> println("End of the week")
        day == "Wednesday" || day == "Thursday" -> println("Midweek")
        else -> println("Normal day")
    }
}

আউটপুট:

Start of the week
4344 Views
No Comments
Forward Messenger
2
পিএইচপি সম্পূর্ণ মৌলিক ধারণা
-
- -
No comments to “কোটলিন”