Kotlin - Inheritance

Inheritance in Kotlin

Inheritance is a fundamental concept in object-oriented programming that allows a class to inherit properties and functions from another class. In Kotlin, inheritance promotes code reusability and establishes a hierarchical relationship between classes.

1. Basic Concepts of Inheritance

1.1 Superclass and Subclass

In Kotlin, the class being inherited from is called the superclass or base class, and the class that inherits is called the subclass or derived class.

1.2 The 'open' Keyword

By default, all classes in Kotlin are final, meaning they cannot be inherited. To allow a class to be inherited, it must be marked with the open keyword.

open class Animal {
    fun eat() {
        println("Eating...")
    }
}

1.3 Inheriting a Class

To inherit a class, use the colon (:) symbol followed by the superclass name.

class Dog : Animal() {
    fun bark() {
        println("Barking...")
    }
}

2. Constructors in Inheritance

2.1 Primary Constructors

If the superclass has a primary constructor, the subclass must initialize it using the super keyword.

open class Person(val name: String)

class Student(name: String, val studentId: Int) : Person(name)

2.2 Secondary Constructors

If the subclass has a secondary constructor, it must delegate to the primary constructor of the superclass.

open class Person(val name: String)

class Student : Person {
    constructor(name: String, val studentId: Int) : super(name)
}

3. Overriding Methods and Properties

3.1 Overriding Methods

To allow a method to be overridden, mark it with the open keyword. The subclass can then override it using the override keyword.

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

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

3.2 Overriding Properties

Similar to methods, properties can be overridden. A val property can be overridden by another val or a var, but a var cannot be overridden by a val.

open class Shape {
    open val sides: Int = 0
}

class Triangle : Shape() {
    override val sides: Int = 3
}

4. Calling Superclass Implementations

The super keyword is used to call the superclass's methods or access its properties.

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

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

5. Initialization Order

When creating an instance of a subclass, the initialization process follows this order:

1. Evaluation of arguments for the superclass constructor
2. Execution of the superclass's init blocks and property initializers
3. Execution of the subclass's init blocks and property initializers

open class Base(val name: String) {
    init {
        println("Initializing Base")
    }
}

class Derived(name: String) : Base(name) {
    init {
        println("Initializing Derived")
    }
}

6. Abstract Classes

An abstract class cannot be instantiated and may contain abstract members that must be implemented by subclasses.

abstract class Animal {
    abstract fun sound()
}

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

7. Interfaces

Kotlin supports multiple inheritance through interfaces. An interface can contain abstract methods and properties, as well as method implementations.

interface Animal {
    fun sound()
}

interface Pet {
    fun play()
}

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

    override fun play() {
        println("Dog plays fetch")
    }
}

8. Sealed Classes

Sealed classes are used to represent restricted class hierarchies, where a value can have one of the types from a limited set.

sealed class Result

class Success(val data: String) : Result()
class Error(val error: String) : Result()

• Use inheritance only when there is a clear "is-a" relationship.
• Prefer composition over inheritance to reduce tight coupling.
• Mark classes and methods as open only when necessary.
• Use interfaces to achieve multiple inheritance.

Inheritance in Kotlin provides a powerful mechanism to build upon existing code, promoting reusability and a clear hierarchical structure. By understanding and applying the principles of inheritance, constructors, method overriding, and interfaces, you can design robust and maintainable Kotlin applications.