Kotlin Inheritance

Kotlin Inheriting fields from a Class

We inherit all of its fields and functions when we inherit a class to derive a class. We can use Parent Class attributes and methods in derived classes.

Code:

open class BaseClass{
    val ch = "A"
 }
 class DerivedClass: BaseClass() {
    fun dev() {
        println("ch is equal to $ch")
    }
 }
 fun main() {
    val derivedClass = DerivedClass()
    derivedClass.dev()
 }  

Output:

ch is equal to A

We are calling dev() from the DerivedClass object. One thing to note here is we are using ch variable, which is defined in BaseClass.

We can access ch variable because we have derived the properties and parameters of BaseClass into DerivedClass.

Kotlin Inheritance and Primary Constructor

If the primary function property() is shared by both the base and derived classes, the parameters are initialized in the base class's primary function property(). In the preceding inheritance example, all classes have three parameters: side and property, and all of these parameters are initialized in the base class's primary function property().

When the primary constructors of a base and derived class have different parameters, the base class parameters are initialized from the derived class object.

Code:

open class Shape(property: String, side: Int) {
    init {
        println("Property of Shape is $property.")
        println("Side of Shape is $side")
    }
 }
 
 class Circle(property: String, private val side: Int): Shape(property,side) {
    init {
        println("Property of Circle is $property.")
        println("Side of Circle is $side")
    }
    fun printRadius(){
        println("this circle has $side as a radius")
    }
 }
 
 class Rectangle(property: String,private val side: Int): Shape(property,side) {
    init {
        println("Property of Rectangle is $property.")
        println("Side of Rectangle is $side")
    }
    fun printSides(){
        println("this rectangle has $side sides")
    }
 }
 
 fun main() {
    val circle = Circle("circle with radius 10",10)
    circle.printRadius()
    val rectangle = Rectangle("NaN",5)
    rectangle.printSides()
 }

Output:

Property of Shape is circle with radius 10.
Side of Shape is 10
Property of Circle is circle with radius 10.
Side of Circle is 10
this circle has 10 as a radius
Property of Shape is NaN.
Side of Shape is 5
Property of Rectangle is NaN.
Side of Rectangle is 5
this rectangle has 5 sides

Here, the init block of the parent class is called first before its own init block. The hierarchy of the object goes from top to bottom, first calling the parent class block then the derived class block.

So when we are initializing a child class object first, this class will call its parent class to inherit the parent class parameters and methods.

Kotlin Inheritance and Secondary Constructor

If the derived class lacks the primary constructor, the super keyword must invoke the base class's secondary constructor from the derived class.

Code:

open class Parent {
    constructor(name: String, age: Int) {
        println("execute super constructor $name: $age")
    }
 }
 
 class Child : Parent {
    constructor(name: String, age: Int, dept: String) : super(name, age) {
        print("execute child class constructor with property $name, $age, $dept")
    }
 }
 
 fun main() {
    val child = Child("Coding", 17, "Ninjas")
 }

Output:

execute super constructor Coding: 17
execute child class constructor with property Coding, 17, Ninjas

In the preceding example, when an object of the Child class is created, it invokes its initializer and sets its parameters to "Coding," "17," and "Ninjas." At the same time, the child class construction manager uses the super keyword to invoke the superclass initializer with the values name and id. Because the super keyword is present, the body of the superclass function constructor is executed first and then returns to the Child class function constructor.

Kotlin Multiple Class Implementations

When a derived class implements the same function name of numerous classes, it utilizes a supertype name in angle brackets.

For example, a derived class Orange extends its superclass Fruit and implements the Apple interface, which contains the same function property as the superclass Fruit(). To invoke a certain class or interface method, we must include the supertype name in angle brackets like super<Fruit>. super<Apple> and property() For each method, use property().

Code:

open class Fruit {
    open var color = "Unknown"
    open fun property() {
        println("Fruit color is $color")
    }
 }
 
 interface Apple {
    fun property() {
        println("Apple is a fruit")
    }
 }
 
 class Orange : Fruit(), Apple {
    override var color = "Orange"
    override fun property() {
        super<Fruit>.property()
        super<Apple>.property()
        println("Orange is a fruit")
    }
 }
 
 fun main() {
    val orange = Orange()
    orange.property()
    println(orange.color)
 }

Output:

Fruit color is Orange
Apple is a fruit
Orange is a fruit
Orange

We have now learned about Inheritance and why it should be used. Multiple inheritance support can help us build classes more beautifully.

Note that by Multiple Inheritance we can inherit one class only but can inherit multiple interfaces.

FAQs

1. Does Kotlin have a static keyword?
   Suppose you are an Android developer who enjoys creating Android applications in Java. In that case, you must have used the static keyword in your code to create static variables, static methods, and so on. Yes, you read that correctly: Kotlin lacks a static keyword.
    
2. What is lazy in Kotlin?
   Because the same object is accessed throughout, lazy is mostly utilized when accessing a read-only property.
    
3. What is polymorphism in Kotlin?
   Polymorphism enables computer code to be contextualized. Because it is both intensely and statically typed, Kotlin allows for two types of polymorphism. When the code is compiled, the first type of polymorphism occurs. The other form happens during runtime.

Key Takeaways

Cheers if you reached here!! 

The purpose of this article was to introduce you to the Kotlin Inheritance, the basic syntax of implementing this super, override keyword, and understand the basic core concept about Inheritance in Android Development.

If you want to learn more about Recursion Functions in Kotlin, you can jump to this article which covers them in great detail.

However, learning never stops, and there is more to learn. So head over to our Android Development Course on the Coding Ninjas Website to dive deep into Android Development and build future applications. Till then, Happy Learning!