Inheritance

The open keyword applied to the class allows you to inherit from that class. By default classes are final and cannot be parent to other classes.

You can specify a parent class after primary constructor.

By default parent class is Any class. In other words the Any class is superclass for all other classes in Kotlin.

open class Base(p: Int)

class Derived(p: Int) : Base(p)
class MyView : View { constructor(ctx: Context) : super(ctx) constructor(ctx: Context, attrs: AttributeSet) : super(ctx, attrs) }

polymorphism

The open keyword applied to a method allows you to override the method in a child class. By default, methods are final and you cannot override them in child classes.

The override keyword is used to ensure that you are overriding a method and not defining a new method.

The final keyword allows you to prohibit re-overriding method.

The super keyword refers to the parent class. It is useful for calling parent version of method.

Same rules are applied to the properties.

open class Shape {
    open val vertexCount: Int = 0
     
    open fun draw() { /*...*/ }
    fun fill() { /*...*/ }
}

class Circle() : Shape() { 
   final override fun draw() { /*...*/ }
}

open class Rectangle() : Shape() {
    val borderColor: String get() = "black"
    override val vertexCount = 4
    override fun draw() { /*...*/ }
}

class FilledRectangle : Rectangle() {
    override fun draw() {
        super.draw()
        /*...*/
    }

    val fillColor: String get() = super.borderColor
}