📌 Inheritance in Kotlin

Inheritance in Kotlin allows a class to acquire the properties and methods of another class. It is a fundamental concept of Object-Oriented Programming (OOP) that promotes code reuse and logical structuring.

✅ 1. Key Concepts of Inheritance in Kotlin

• Superclass (Parent) → The class whose properties and functions are inherited.

• Subclass (Child) → The class that inherits from the superclass.

• open Keyword → By default, classes in Kotlin are final (cannot be inherited). Use the open keyword to allow inheritance.

• Override → Methods from the superclass can be overridden using the override keyword.

✅ 2. Basic Inheritance Example

📌 Superclass and Subclass

kotlin
open class Animal(val name: String) {    fun () {        println("$name makes a sound")    }}class Dog(name: String) : Animal(name) {    fun () {        println("$name barks loudly")    }}fun () {    val dog = Dog("Buddy")    dog.sound()  // From superclass    dog.bark()   // From subclass}

Output:

css
Buddy makes a soundBuddy barks loudly

• Dog class inherits from Animal using the : Animal(name) syntax.

• The sound() method is accessible in Dog using inheritance.

✅ 3. Overriding Methods

You can override superclass methods using the override keyword.

📌 Example:

kotlin// Superclass
open class Animal {    open fun () {        println("Animal makes a sound")    }}// Subclass overriding sound() methodclass Cat : Animal() {    override fun () {        println("Cat meows")    }}fun () {    val cat = Cat()    cat.sound() // Output: Cat meows}

• The sound() method in the Cat class overrides the one in Animal.

✅ 4. Calling Superclass Methods

You can call the superclass method using the super keyword.

📌 Example:

kotlinopen class Animal {
    open fun () {        println("Animal makes a sound")    }}class Dog : Animal() {    override fun () {        super.sound() // Calls parent method        println("Dog barks")    }}fun () {    val dog = Dog()    dog.sound()}

Output:

css
Animal makes a soundDog barks

• super.sound() calls the parent class's method before executing the overridden code.

✅ 5. Inheritance with Properties

Properties can also be inherited and overridden using the override keyword.

📌 Example:

kotlin
open class Shape {    open val name: String = "Unknown Shape"}class Circle : Shape() {    override val name: String = "Circle"}fun () {    val circle = Circle()    println("Shape Name: ${circle.name}")}

Output:

pgsql
Shape // Abstract classabstract class Vehicle {    abstract fun ()}// Subclass implementing the abstract methodclass Car : Vehicle() {    override fun () {        println("Car is driving")    }}fun () {    val car = Car()    car.drive()}

Output:

csharp
Car is driving

• The Car class provides its own implementation of the drive() method.

✅ 7. Final Keyword

If you don’t want a class or method to be inherited or overridden, you can use the final keyword.

📌 Example:

kotlin
open class Device {    final fun operate() {        println("Operating device")    }}class Mobile : Device() {    // fun operate() {} // Error: Cannot override final method}

• operate() cannot be overridden because it is marked as final.

✅ Conclusion

• Use open to allow inheritance.

• Use override to customize methods or properties in the subclass.

• Use super to access parent class methods.

• Use abstract for base classes that need implementation in derived classes.

• Use final to prevent further inheritance or method overriding.