# Class Inheritance

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

← Class Delegation Visibility Modifiers →