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.
// 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
.
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.
// 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.
interface ShapeInterface {
fun getArea(): Double
}
The interface that already created is implemented by Circle
class.
// 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.
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.
interface EntityInterface {
fun getInfo()
}
The two interfaces is implemented in Circle
class.
// 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.
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.
Learn more about interface in this link.
Learn more about the example of sealed class usage in this link.
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.
Top comments (0)