Inheritance and interfaces

Why inheritance?

Sometimes several kinds of things share a lot: a bus ticket, a train ticket and a flight ticket all have a passenger name and a price, but each calculates its fee differently. Inheritance lets a subclass (child) reuse the properties and functions of a superclass (parent) and change only what differs.

open and override

Kotlin chose a safe default: classes and their functions are final, meaning they cannot be inherited or overridden, unless you say open. This prevents accidental changes in subclasses that the original author never planned for.

open class Ticket(val passenger: String, val baseFare: Int) {
    open fun total(): Int = baseFare
    fun summary() = "$passenger: Rs ${total()}"
}

class TrainTicket(passenger: String, baseFare: Int, val tatkal: Boolean) : Ticket(passenger, baseFare) {
    override fun total(): Int = if (tatkal) baseFare + 300 else baseFare
}

class FlightTicket(passenger: String, baseFare: Int) : Ticket(passenger, baseFare) {
    override fun total(): Int = baseFare + 750       // fees
}

fun main() {
    val tickets: List<Ticket> = listOf(TrainTicket("Ravi", 1200, true), FlightTicket("Meena", 4500))
    for (t in tickets) println(t.summary())
}

Polymorphism (many forms) means one call, t.total(), does different things depending on the actual object. The loop does not need to know which kind of ticket it has.

The subclass header TrainTicket(...) : Ticket(passenger, baseFare) passes values up to the parent constructor. The parent's properties (passenger, baseFare) are then available in the child without being declared again.

super

class FestiveTrainTicket(p: String, fare: Int) : Ticket(p, fare) {
    override fun total(): Int = super.total() - 100    // reuse the parent's logic, then adjust
}

Abstract classes

An abstract class cannot be created directly; it exists to be inherited. It can declare abstract members with no body, which every subclass must implement, alongside normal shared code.

abstract class Shape {
    abstract fun area(): Double
    fun describe() = "Area: %.2f".format(area())
}

class Circle(val r: Double) : Shape() {
    override fun area() = Math.PI * r * r
}

Interfaces

An interface describes an ability, like "can be shared" or "can be paid". Many unrelated classes can implement it, and a class can implement several interfaces but extend only one class. Interface functions can have default bodies.

interface Payable {
    fun amountPaise(): Long
    fun display() = "Rs ${amountPaise() / 100}"    // default implementation
}

interface Shareable {
    fun shareText(): String
}

class Invoice(val no: String, val paise: Long) : Payable, Shareable {
    override fun amountPaise() = paise
    override fun shareText() = "Invoice $no: ${display()}"
}

Composition over inheritance

Deep inheritance trees (A extends B extends C extends D) become hard to change. Most modern Kotlin and Android code prefers composition: a class holds other objects that do parts of the work, and interfaces describe what can be swapped. Use inheritance for a genuine "is a" relationship and keep trees shallow.

Common mistakes

• Forgetting open: "This type is final, so it cannot be inherited from".
• Forgetting override when redefining a function: the compiler requires it explicitly.
• Trying to inherit from two classes. Use one class plus interfaces.
• Building deep hierarchies for code reuse. Prefer small classes composed together.