đŸ”Ĩ āχāύāĻšেāϰিāϟেāύ্āϏ āĻŽাāύে āĻ•ী?

 āϚāĻŽā§ŽāĻ•াāϰ! āφāϜ āϚāϞি 🧠-āĻĢ্āϰেāύ্āĻĄāϞি āϏ্āϟাāχāϞে āχāύāĻšেāϰিāϟেāύ্āϏ (Inheritance) āĻĒুāϰোāϟা āĻŦোāĻাāϰ āĻŽিāĻļāύে! 😄

āφāĻŽāϰা āϏāĻšāϜ āĻ­াāώাāϝ়, āωāĻĻাāĻšāϰāĻŖ āĻĻিāϝ়ে āĻŽাāĻĨাāϝ় āĻ—েঁāĻĨে āϰাāĻ–āĻŦ!


đŸ”Ĩ āχāύāĻšেāϰিāϟেāύ্āϏ āĻŽাāύে āĻ•ী?

āχāύāĻšেāϰিāϟেāύ্āϏ = "āĻŦাāĻĒ āĻĻাāĻĻাāϰ āĻ—ুāĻŖ āύিāϜেāϰ āĻŽāϧ্āϝে āĻĒেāϝ়ে āϝাāĻ“āϝ়া!"
āĻŽাāύে, āĻāĻ•āϟা āĻ•্āϞাāϏ āĻ…āύ্āϝ āĻ•্āϞাāϏেāϰ āĻ—ুāĻŖ, āĻĢাংāĻļāύ, āĻĒ্āϰāĻĒাāϰ্āϟি āϏāĻŦ āωāϤ্āϤāϰাāϧিāĻ•াāϰ āĻšিāϏেāĻŦে āĻĒাāϝ়।

đŸ¯ āϏāĻšāϜ āĻ­াāώা⧟:

  • āĻŦাāĻŦা āϝāĻĻি āĻŦাāϘ āĻšā§Ÿ, āĻ›েāϞে āĻŦাāϚ্āϚাāĻ“ āĻŦাāϘāχ āĻšāĻŦে ➡️ āĻ•িāĻ›ু āĻ—ুāĻŖ āĻŦাāĻŦা āĻĨেāĻ•ে āφāϏāĻŦে।

  • āĻ›েāϞে āϚাāχāϞে āύিāϜেāϰāĻ“ āĻ•িāĻ›ু āύāϤুāύ āĻ—ুāĻŖ āϝোāĻ— āĻ•āϰāϤে āĻĒাāϰāĻŦে। āĻāϟাāĻ•েāχ āĻŦāϞে Inheritance।


🌱 āχāύāĻšেāϰিāϟেāύ্āϏেāϰ āĻŽূāϞ āĻ•āĻĨা:

  • Parent/Base/Super Class ➔ āϝেāĻ–াāύ āĻĨেāĻ•ে āĻ—ুāĻŖ āωāϤ্āϤāϰাāϧিāĻ•াāϰ āĻĒাāĻ“ā§Ÿা āĻšā§Ÿ।

  • Child/Derived/Sub Class ➔ āϝে āĻ•্āϞাāϏ āĻāχ āĻ—ুāĻŖ āĻĒা⧟ āĻāĻŦং āϚাāχāϞে āĻŦা⧜া⧟।


✅ āĻ•োāĻĄেāϰ āϏāĻšāϜ āωāĻĻাāĻšāϰāĻŖ (Kotlin):

// ✅ Parent class (Base class)
open class Animal {
    fun eat() {
        println("Animal is eating")
    }
}

// ✅ Child class (Derived class)
class Dog : Animal() {
    fun bark() {
        println("Dog is barking")
    }
}

fun main() {
    val dog = Dog()
    dog.eat()   // ✅ āĻāχ āĻĢাংāĻļāύāϟা Animal āĻĨেāĻ•ে āĻĒাāĻ“ā§Ÿা
    dog.bark()  // ✅ āĻāχāϟা Dog-āĻāϰ āύিāϜāϏ্āĻŦ āĻ—ুāĻŖ
}

🧠 āĻŽাāĻĨা⧟ āϰাāĻ–ো:

  • open ➔ Kotlin-āĻ āĻ•্āϞাāϏ āĻŦা āĻĢাংāĻļāύāĻ•ে āχāύāĻšেāϰিāϟ āĻ•āϰāϤে āϚাāχāϞে āφāĻ—ে open āĻ•āϰāϤে āĻšā§Ÿ।

  • : ➔ āĻŽাāύে āχāύāĻšেāϰিāϟ āĻ•āϰা āĻšāϚ্āĻ›ে। (Dog ➔ Animal āĻĨেāĻ•ে āĻĒে⧟েāĻ›ে)


🐾 āχāύāĻšেāϰিāϟেāύ্āϏেāϰ āϏুāĻŦিāϧা:

✅ āϏুāĻŦিāϧা 📝 āĻŽাāύে
Code Reuse āĻŦাāϰāĻŦাāϰ āĻāĻ•āχ āĻ•োāĻĄ āύা āϞিāĻ–ে, āĻŦাāĻĒ-āĻĻাāĻĻাāϰ āĻ•োāĻĄ āĻŦ্āϝāĻŦāĻšাāϰ āĻ•āϰা āϝা⧟
Structure āĻĒāϰিāώ্āĻ•াāϰ āĻ•ে āĻ•াāϰ āĻ—ুāĻŖ āĻĒে⧟েāĻ›ে āϏেāϟা āĻŦোāĻা āϏāĻšāϜ
Extension āϏāĻšāϜ āĻĒুāϰাāύো āĻ•্āϞাāϏ āϰেāĻ–ে āύāϤুāύ āĻ—ুāĻŖ āϝোāĻ— āĻ•āϰা āϝা⧟

đŸ”Ĩ āχāύāĻšেāϰিāϟেāύ্āϏেāϰ āĻĒ্āϰāĻ•াāϰāĻ­েāĻĻ (Brain-friendly āĻ­াāĻ™ি⧟ে āĻŦুāĻি)

1️⃣ Single Inheritance

👉 āĻāĻ•āϟা āĻ•্āϞাāϏ āĻļুāϧু āĻāĻ•āϟা āĻ•্āϞাāϏ āĻĨেāĻ•ে āωāϤ্āϤāϰাāϧিāĻ•াāϰ āĻĒা⧟।

open class Animal
class Dog : Animal()

2️⃣ Multilevel Inheritance

👉 āĻŦাāĻŦা ➔ āĻ›েāϞে ➔ āύাāϤি ➔ āĻāĻ­াāĻŦে āϞাāχāύ āϚāϞে।

open class Animal
open class Dog : Animal()
class Puppy : Dog()

3️⃣ Hierarchical Inheritance

👉 āĻāĻ• āĻŦাāĻĒেāϰ āĻ…āύেāĻ• āĻ›েāϞে

open class Animal
class Dog : Animal()
class Cat : Animal()

Multiple Inheritance

👉 Kotlin āĻ•্āϞাāϏেāϰ āĻ•্āώেāϤ্āϰে āĻāϟা āύেāχ (āĻ•াāϰāĻŖ Confusion āĻšā§Ÿ āĻ•োāύ āĻŦাāĻĒেāϰ āĻ—ুāĻŖ āφāĻ—ে āφāϏāĻŦে)।
āĻ•িāύ্āϤু Kotlin-āĻ interface āĻĻিāϝ়ে āĻāϟা āĻ•āϰা āϝাāϝ়! (āĻāϟাāĻ•ে āĻŦāϞে multiple inheritance via interface)


đŸŸĸ āχāύāĻšেāϰিāϟেāύ্āϏ + Overriding (āĻŦাāϚ্āϚা āϚাāχāϞে āĻŦাāĻŦাāϰ āĻ—ুāĻŖ āĻĒāϰিāĻŦāϰ্āϤāύāĻ“ āĻ•āϰāϤে āĻĒাāϰে!)

open class Animal {
    open fun sound() {
        println("Animal sound")
    }
}

class Dog : Animal() {
    override fun sound() {
        println("Dog barks")
    }
}

fun main() {
    val dog = Dog()
    dog.sound()  // ✅ "Dog barks" āĻšāĻŦে āĻ•াāϰāĻŖ āĻŦাāϚ্āϚা āύিāϜেāϰ āĻŽāϤো āĻ—ুāĻŖ āĻŦāĻĻāϞে āύি⧟েāĻ›ে!
}

đŸ”Ĩ āĻāχāϟাāĻ•ে āĻŦāϞে ➔ Method Overriding


đŸ¯ āĻŦাāϏ্āϤāĻŦ āωāĻĻাāĻšāϰāĻŖ (Android āĻĻৃāώ্āϟিāĻ•োāĻŖ āĻĨেāĻ•ে):

āϤুāĻŽি āϝāĻ–āύ Android āĻ āĻāχāϰāĻ•āĻŽ āĻ•িāĻ›ু āĻĻেāĻ–ো:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // ...
    }
}

➡️ āĻāĻ–াāύেāĻ“ MainActivity ➔ AppCompatActivity āĻĨেāĻ•ে āχāύāĻšেāϰিāϟ āĻ•āϰেāĻ›ে।
āφāϰ onCreate() āĻšāϞো overriding — āĻŽাāύে āφāĻŽāϰা āύিāϜেāϰ āĻŽāϤো āĻ•āϰে āϏেāϟাāϰ āĻ•াāϜ āĻĒāϰিāĻŦāϰ্āϤāύ āĻ•āϰেāĻ›ি।


🧠 āχāύāĻšেāϰিāϟেāύ্āϏ āĻŽāύে āϰাāĻ–াāϰ āĻĢāϰ্āĻŽুāϞা:

  • Parent ➔ Base ➔ Super = āĻ—ুāĻŖ āĻĻে⧟।

  • Child ➔ Derived ➔ Sub = āĻ—ুāĻŖ āĻĒা⧟ + āύিāϜেāϰ āĻ—ুāĻŖ āϝোāĻ— āĻ•āϰে।

  • open ➔ "āϤোāĻŽাāĻ•ে āχāύāĻšেāϰিāϟ āĻ•āϰাāϰ āĻ…āύুāĻŽāϤি āĻĻিāϞাāĻŽ!"

  • override ➔ "āĻŦাāĻĒেāϰ āĻ—ুāĻŖ āφāĻŽি āĻŦāĻĻāϞে āĻĻিāϚ্āĻ›ি!"


đŸ”Ĩ āχāύāĻšেāϰিāϟেāύ্āϏ = "āωāϤ্āϤāϰাāϧিāĻ•াāϰ + āύāϤুāύāϤ্āĻŦ"

➡️ āĻĒুāϰāύো āĻ—ুāĻŖ āύিāχ + āϚাāχāϞে āύāϤুāύ āĻ—ুāĻŖ āϝোāĻ— āĻ•āϰি + āϚাāχāϞে āĻĒুāϰāύোāϟা āĻŦāĻĻāϞাāχ ✅


āϚাāχāϞে āφāĻŽি āϤোāĻŽাāĻ•ে āχāύāĻšেāϰিāϟেāύ্āϏেāϰ āϏাāĻĨে āϏাāĻĨে Interface vs Inheritance āĻĒাāϰ্āĻĨāĻ•্āϝāĻ“ āĻŦ্āϰেāχāύ-āĻĢ্āϰেāύ্āĻĄāϞি āĻ•āϰে āĻŦুāĻি⧟ে āĻĻিāϤে āĻĒাāϰি। āϚাāχ? 😄

Comments

Popular posts from this blog

AI (Artificial Intelligence) āϏāĻšāϜāĻ­াāĻŦে āĻŦোāĻাāϰ āϜāύ্āϝ āĻāĻ•āĻĻāĻŽ āĻŽāϏ্āϤিāώ্āĻ•-āĻŦাāύ্āϧāĻŦ āĻŦ্āϝাāĻ–্āϝা 🧠🤖

🧠 Regex āĻ•ী?

Kotlin-āĻ āĻ­েāϰিāϝ়েāĻŦāϞ āϘোāώāĻŖা āĻ•āϰাāϰ āĻĻুāχ āωāĻĒাāϝ়