Implementing Inheritance Wisely in Kotlin | CodeSignal Learn

Implementing Inheritance Wisely in Kotlin | CodeSignal Learn

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.

Sign up

Join the 1M+ learners on CodeSignal

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

Bad Example

Let’s explore a bad example of inheritance misuse in 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")}} In this example: The hierarchy is too deep with Manager extending Employee, which extends Person . The Person class having a work() method may be inappropriate since not every person works, making the base class less flexible. The inheritance structure might be forced, with the role of Employee being questionable.

Refactored Example

Here's a refactored version following best practices: 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")}} In the refactored version: Person is a data class, free from unnecessary behavior, making it more general. Employee employs composition by utilizing a Person object instead of inheriting from Person . This approach simplifies the hierarchy. Manager continues to extend Employee, maintaining a logical and streamlined structure.

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")
    }
}