Inheritance and Polymorphism in Kotlin: Bringing Classes to Life

Inheritance and Polymorphism in Kotlin: Bringing Classes to Life | CodeSignal Learn

Introduction

Greetings! Today, we're going to demystify the crucial terms of Object-oriented programming (OOP): Inheritance and Polymorphism . These concepts form the backbone of efficient OOP. Our journey will unfold as follows: we'll start with an intuitive grasp of Inheritance and its implementation in Kotlin, and then we'll delve into Polymorphism, with a special focus on method overriding.

Understanding Inheritance

Inheritance is akin to repurposing an old blueprint to create something new. In OOP, it allows one class to inherit features (properties and functions) from another. In Kotlin, we have the Parent Class (also known as Superclass), which provides features, and the Child Class (or Subclass), which receives these features. When implementing, we use the open keyword for the Parent Class (to allow inheritance), and the : symbol for the Child class indicates which Parent class the features are coming from. Kotlin // Defining an 'Animal' class (Parent Class). Marking it as 'open' allows other classes to inherit from it. open class Animal {fun eat() {println("This animal eats food.") // Prints: "This animal eats food."}} // 'Cat' class inherits from 'Animal' (Child Class) class Cat : Animal() {// Inherits all features from 'Animal'} val myCat = Cat() myCat.eat() // Prints: "This animal eats food."

Handling Constructors in Inheritance

Join the 1M+ learners on CodeSignal

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

Concept of Method Overriding in Inheritance

Method overriding allows a Child Class to provide unique implementations for methods provided by its Parent Class. In Kotlin, to indicate that a method in the Parent Class can be overridden, we use the open keyword. In the Child Class, we use the override keyword before the method that is intended to provide a new implementation: Kotlin open class Animal {open fun eat() {println("This animal eats food.")}} class Cat : Animal() {override fun eat() {println("The cat eats fish.") // A custom message for the Cat class}} val myAnimal = Animal() myAnimal.eat() // Prints: "This animal eats food." val myCat = Cat() myCat.eat() // Prints: "The cat eats fish." open class Animal {open fun eat() {println("This animal eats food.")}} class Cat : Animal() {override fun eat() {println("The cat eats fish.") // A custom message for the Cat class}} val myAnimal = Animal() myAnimal.eat() // Prints: "This animal eats food." val myCat = Cat() myCat.eat() // Prints: "The cat eats fish." When an instance of Animal and Cat call their eat() methods, they print "This animal eats food." and "The cat eats fish." respectively, showcasing how subclasses can customize inherited behavior.

Exploring Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common superclass, enabling a method to perform differently based on the object it operates on. This concept, pivotal in Object-Oriented Programming (OOP), leverages inheritance and method overriding for dynamic behavior at runtime. To see polymorphism in action, consider an example with animals and their eating habits: Kotlin open class Animal {open fun eat() {println("This animal eats food.")}} class Cat : Animal() {override fun eat() {println("The cat prefers fish.")}} class Dog : Animal() {override fun eat() {println("The dog enjoys bones.")}} fun main() {val animals = arrayOf(Cat(), Dog()) // Array of Animal type for (animal in animals) {animal.eat() // Executes overridden eat method} // Output shows specific eating preferences: // The cat prefers fish. // The dog enjoys bones.} open class Animal {open fun eat() {println("This animal eats food.")}} class Cat : Animal() {override fun eat() {println("The cat prefers fish.")}} class Dog : Animal() {override fun eat() {println("The dog enjoys bones.")}} fun main() {val animals = arrayOf(Cat(), Dog()) // Array of Animal type for (animal in animals) {animal.eat() // Executes overridden eat method} // Output shows specific eating preferences: // The cat prefers fish. // The dog enjoys bones.} In this example, Cat and Dog override the eat method from Animal . Iterating over an array of Animal objects calls the specific eat method for each, illustrating polymorphism: the same operation (eat) varies by the object type, even when accessed through a reference of the superclass. Polymorphism facilitates flexible and reusable code, allowing operations on more general types while ensuring the correct specific behaviors are invoked.