Class Inheritance in Kotlin
Any object-oriented programming language has some form of class inheritance. Let me revise:
Imagine you had to program a bunch of fruit: Apples
, Oranges
and Pears
. They all differ in size, shape and color, that's why we have different classes.
But let's say their differences don't matter for a second and you just want a Fruit
, no matter which exactly? What return type would getFruit()
have?
The answer is class Fruit
.
We create a new class and make all fruits inherit from it!
Basics: the 'open' keyword
In Kotlin, classes are final by default which means they cannot be inherited from.
To allow inheritance on a class, use the open
keyword.
open class Thing {
// I can now be extended!
}
Note: abstract classes, sealed classes and interfaces will be
open
by default.
Inheriting fields from a class
Defining the base class:
open class BaseClass {
val x = 10
}
Defining the derived class:
class DerivedClass: BaseClass() {
fun foo() {
println("x is equal to " + x)
}
}
Using the subclass:
fun main(args: Array<String>) {
val derivedClass = DerivedClass()
derivedClass.foo() // prints: 'x is equal to 10'
}
Inheriting methods from a class
Defining the base class:
open class Person {
fun jump() {
println("Jumping...")
}
}
Defining the derived class:
class Ninja: Person() {
fun sneak() {
println("Sneaking around...")
}
}
The Ninja has access to all of the methods in Person
fun main(args: Array<String>) {
val ninja = Ninja()
ninja.jump() // prints: 'Jumping...'
ninja.sneak() // prints: 'Sneaking around...'
}
Overriding properties and methods
Overriding properties (both read-only and mutable):
abstract class Car {
abstract val name: String;
open var speed: Int = 0;
}
class BrokenCar(override val name: String) : Car() {
override var speed: Int
get() = 0
set(value) {
throw UnsupportedOperationException("The car is bloken")
}
}
fun main(args: Array<String>) {
val car: Car = BrokenCar("Lada")
car.speed = 10
}
Overriding methods:
interface Ship {
fun sail()
fun sink()
}
object Titanic : Ship {
var canSail = true
override fun sail() {
sink()
}
override fun sink() {
canSail = false
}
}
Syntax
- open {Base Class}
- class {Derived Class} : {Base Class}({Init Arguments})
- override {Function Definition}
- {DC-Object} is {Base Class} == true
Parameters
Parameter | Details |
---|---|
Base Class | Class that is inherited from |
Derived Class | Class that inherits from Base Class |
Init Arguments | Arguments passed to constructor of Base Class |
Function Definition | Function in Derived Class that has different code than the same in the Base Class |
DC-Object | ”Derived Class-Object“ Object that has the type of the Derived Class |