Implementing Inheritance Wisely in Kotlin

Introduction

Welcome to another lesson in the Clean Code in Kotlin course! Throughout this course, we've delved into essential concepts like the Single Responsibility Principle, encapsulation, and constructors, all crucial for writing clear, maintainable, and efficient Kotlin code. In this lesson, we'll focus on applying inheritance effectively in Kotlin. By understanding the role of inheritance, we'll learn how to enhance code readability and organization while adhering to clean code principles.

How Inheritance is Important to Writing Clean Code

Inheritance is a significant feature in object-oriented programming that promotes code reuse and logical organization. It allows developers to create new classes based on existing ones, inheriting properties and behaviors. When used correctly, it can lead to clearer and more maintainable code. Code Reuse and Reduction of Redundancies : By creating subclasses that inherit from a base class, redundant code is minimized, making the system easier to extend and maintain. Improved Readability : Logical inheritance hierarchies enhance software clarity. For instance, with a base class Vehicle and subclasses Car and Motorcycle, the structure is intuitive and illuminates each class's role. Alignment with Previous Concepts : Inheritance should respect the Single Responsibility Principle and encapsulation. Each class, whether a base or a subclass, must have a distinct purpose and protect its data.

Best Practices When Using Inheritance

To utilize inheritance effectively in Kotlin, it's essential to consider the following practices: Favor Composition Over Inheritance : When inheritance results in tight coupling, consider using composition, where classes are composed of instances of other classes, instead. Leverage Kotlin Features : Utilize Kotlin's data classes for simple data-holding classes, and employ interfaces and sealed classes to define restricted class hierarchies and encapsulate types safely. Avoid Deep Inheritance Hierarchies : Extensive hierarchies lead to complexity, complicating understanding and maintenance, and making debugging and modifications challenging. Common pitfalls include excessive inheritance for non-"is-a" relationships and using inheritance merely for code sharing without logical alignment.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Kotlin

open class Person(val name: String, val age: Int) {
    open fun work() {
        println("Person working")
    }
}

class Employee(name: String, age: Int, val employeeId: String) : Person(name, age) {
    fun fileTaxes() {
        println("$name filing taxes")
    }
}

class Manager(name: String, age: Int, employeeId: String) : Employee(name, age, employeeId) {
    fun holdMeeting() {
        println("$name holding a meeting")
    }
}

open class Person(val name: String, val age: Int) {
    open fun work() {
        println("Person working")
    }
}

class Employee(name: String, age: Int, val employeeId: String) : Person(name, age) {
    fun fileTaxes() {
        println("$name filing taxes")
    }
}

class Manager(name: String, age: Int, employeeId: String) : Employee(name, age, employeeId) {
    fun holdMeeting() {
        println("$name holding a meeting")
    }
}

Kotlin

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

class Employee(val personDetails: Person, val employeeId: String) {
    fun fileTaxes() {
        println("${personDetails.name} filing taxes")
    }
}

class Manager(personDetails: Person, employeeId: String) : Employee(personDetails, employeeId) {
    fun holdMeeting() {
        println("${personDetails.name} holding a meeting")
    }
}

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

class Employee(val personDetails: Person, val employeeId: String) {
    fun fileTaxes() {
        println("${personDetails.name} filing taxes")
    }
}

class Manager(personDetails: Person, employeeId: String) : Employee(personDetails, employeeId) {
    fun holdMeeting() {
        println("${personDetails.name} holding a meeting")
    }
}

Kotlin

open class Person(val name: String, val age: Int) {
    open fun work() {
        println("Person working")
    }
}

class Employee(name: String, age: Int, val employeeId: String) : Person(name, age) {
    fun fileTaxes() {
        println("$name filing taxes")
    }
}

class Manager(name: String, age: Int, employeeId: String) : Employee(name, age, employeeId) {
    fun holdMeeting() {
        println("$name holding a meeting")
    }
}

Kotlin

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

class Employee(val personDetails: Person, val employeeId: String) {
    fun fileTaxes() {
        println("${personDetails.name} filing taxes")
    }
}

class Manager(personDetails: Person, employeeId: String) : Employee(personDetails, employeeId) {
    fun holdMeeting() {
        println("${personDetails.name} holding a meeting")
    }
}

Introduction

How Inheritance is Important to Writing Clean Code

Best Practices When Using Inheritance

Join the 1M+ learners on CodeSignal

Bad Example

Refactored Example

Summary and Next Steps