Inheritance in Kotlin

# CHAPTER 15

Inheritance in Kotlin #

1. Chapter Introduction #

2. Learning Objectives #

• Understand the concept of Parent (Super) and Child (Sub) classes.

• Use the open keyword to allow inheritance.

• Inherit properties and methods using the : syntax.

• Override parent methods using the override keyword.

• Call parent logic using the super keyword.

3. The open Keyword (Kotlin's Safety Feature) #

// The 'open' keyword allows other classes to inherit from this one
open class Animal(val name: String) {
    fun eat() {
        println("$name is eating.")
    }
}

4. Creating a Subclass #

// Dog inherits from Animal
// We pass the 'name' from Dog's constructor directly into Animal's constructor!
class Dog(name: String) : Animal(name) {
    fun bark() {
        println("Woof!")
    }
}

fun main() {
    val myDog = Dog("Buddy")
    
    // myDog has access to its own methods...
    myDog.bark() 
    
    // AND it inherited the methods from Animal!
    myDog.eat()  
}

5. Method Overriding #

1. 1. The parent method must be marked open.

1. 2. The child method must use the override keyword.

open class Animal(val name: String) {
    // We explicitly allow this method to be overridden
    open fun makeSound() {
        println("Some generic animal sound...")
    }
}

class Cat(name: String) : Animal(name) {
    // We override the parent method
    override fun makeSound() {
        println("Meow!")
    }
}

fun main() {
    val myCat = Cat("Whiskers")
    myCat.makeSound() // Prints: Meow!
}

6. The super Keyword #

class GuardDog(name: String) : Animal(name) {
    override fun makeSound() {
        super.makeSound() // Calls the Animal's generic sound first
        println("And a loud Bark!") // Then adds its own behavior
    }
}

7. Real-World Analogy: UI Components #

8. Common Mistakes #

• Forgetting open: If you try to inherit from a standard class Animal, the compiler will throw: "This type is final, so it cannot be inherited from." You must add open.

• Forgetting the parent constructor (): Writing class Dog : Animal is invalid. You must call the parent's constructor: class Dog : Animal().

9. Best Practices #

• Favor Composition over Inheritance: While Inheritance is powerful, don't overuse it. Deep inheritance trees (e.g., Dog inherits Mammal inherits Animal inherits Organism) become incredibly hard to maintain.

10. Exercises #

1. 1. Create an open class Vehicle with a method startEngine().

1. 2. Create a class Car that inherits from Vehicle.

1. 3. Override startEngine() in Car to print "Vroom!". Don't forget the open and override keywords.

11. MCQs with Answers #

12. Interview Questions #

• Q: Why does Kotlin require the open keyword for inheritance and method overriding, whereas Java does not?

• Q: Explain the purpose of the super keyword in an overridden method.

13. Summary #

14. Next Chapter Recommendation #