Kotlin Tutorial - 9 Polymorphism
Tags: kotlin, beginners, tutorial
Published: 2021-10-14 06:14:23

In object oriented programming, there is a principle called polymorphism. Polymorphism is a mechanism when a behavior can be implemented differently by many classes. For example, the human and cat entity has a walk behavior but implemented differently. The human walks with two legs whether the cat walks with four legs.

## Create a Sealed Class

Sealed class is a class that contains many sub classes that inherit sealed class. Basically, sealed class is identical with enum but sealed class could contains many classes. Sealed class is an abstract class so the object cannot be created or instantiated from sealed class.

This is the basic syntax to create sealed class.

```
sealed class class_name(attributes,...) {
    // create many sub classes..
}
```

The sealed class can be created with this other syntax.

```
sealed class class_name
// create many sub classes..
```

In this example, the sealed class is created inside `Vehicle.kt` file.

```kotlin
// create a sealed class called Vehicle
sealed class Vehicle
// create two data classes that inherit Vehicle class
data class Motorcycle(val manufacturer: String, val type: String): Vehicle()
data class Car(val manufacturer: String, val type: String): Vehicle()

// create a run()  method that can be called
// from a class that inherits Vehicle class
fun Vehicle.run() {
    // define the run() implementation
    // based on specific class
    when(this) {
        is Motorcycle -> println("Running with two wheels")
        is Car -> println("Running with four wheels")
    }
}
```

Create an object from `Motorcycle` class that inherits sealed class called `Vehicle`.

```kotlin
fun main() {
    // create an object from Motorcycle class
    val motorcycle = Motorcycle("Honda","CBR")
    // call run() method
    motorcycle.run()
}
```

Output

```
Running with two wheels

```

Based on the code above, the sealed class is created called `Vehicle` that contains many sub classes including `Motorcycle` and `Car`.

The implementation from `run()` method inside `Vehicle` class is defined based on specific class with `when` condition selection.

```kotlin
// create a run()  method that can be called
// from a class that inherits Vehicle class
fun Vehicle.run() {
    // define the run() implementation
    // based on specific class
    when(this) {
        is Motorcycle -> println("Running with two wheels")
        is Car -> println("Running with four wheels")
    }
}
```

## Create an Interface

Interface is a class that only contains many abstract methods. Interface can be used to define contract that has to be fulfilled for a class. This is the basic syntax to create an interface.

```
interface interface_name {
    // create many abstract methods...
}
```

In this example, the interface called `ShapeInterface` is created in `ShapeInterface.kt` file.

```kotlin
interface ShapeInterface {
    fun getArea(): Double
}
```

The interface that already created is implemented by `Circle` class.

```kotlin
// create a Circle class that implements ShapeInterface
class Circle(val radius: Double): ShapeInterface {

    // the getArea() method is implemented
    override fun getArea(): Double {
        return Math.PI * radius * radius
    }
}
```

The object from `Circle` class is created in `main()` method.

```kotlin
fun main() {
    // create an object from Circle class
    val circle = Circle(7.0)
    // call getArea() method
    val area = circle.getArea()
    // print out the result from getArea() method
    println("Area of circle: $area")
}
```

Output

```
Area of circle: 153.93804002589985

```

Based on the code above, the interface called `ShapeInterface` is created that contains abstract method called `getArea()`. The `Circle` class is implementing `ShapeInterface` so all of the methods inside this interface must be implemented. In `main()` method, the object from `Circle` class is created then the `getArea()` method is called.

The class can implements many interfaces. In this example, the `Circle` class implements two interfaces.

The new interface is created called `EntityInterface` in `EntityInterface.kt` file.

```kotlin
interface EntityInterface {
    fun getInfo()
}
```

The two interfaces is implemented in `Circle` class.

```kotlin
// create a Circle class that implements two interfaces
class Circle(val radius: Double): ShapeInterface, EntityInterface {

    // getArea() method is implemented
    override fun getArea(): Double {
        return Math.PI * radius * radius
    }

    // getInfo() method is implemented
    override fun getInfo() {
        println("Radius: $radius")
        println("Area of circle: ${getArea()}")
    }
}
```

The object from `Circle` class is created in `main()` method.

```kotlin
fun main() {
    // create an object from Circle class
    val circle = Circle(7.0)
    // getInfo() method is called
    circle.getInfo()
}
```

Output

```
Radius: 7.0
Area of circle: 153.93804002589985

```

## Notes

- Sealed class can be used to make many classes that inherit sealed class.

- Interface can be used to define certain contract that has to be fulfilled by certain class.

> This is the final part of Kotlin basic tutorial series in this blog. I hope this Kotlin basic tutorial series is helpful for learning the Kotlin programming language 😀.

## Sources

- Learn more about sealed class in this [link](https://kotlinlang.org/docs/sealed-classes.html).

- Learn more about interface in this [link](https://kotlinlang.org/docs/interfaces.html).

- Learn more about the example of sealed class usage in this [link](https://medium.com/@kamilbekar/how-to-use-sealed-class-in-kotlin-f186c30a21e2).

I hope this article is helpful for learning the Kotlin programming language. If you have any thoughts or comments you can write in the discussion section below.