Open classes and inheritance: named parameters and default values; open and abstract; interface; getters and setters; visibility of properties, methods and class

📖 Theory

The class that refused to be extended

A Java programmer's first Kotlin inheritance attempt usually fails with a confusing error. You write class Attendee : Person(), and Kotlin complains that Person is FINAL and cannot be inherited.

This is Kotlin's most surprising OOP rule: classes are final by default. To allow inheritance, you must explicitly mark the parent open, the exact OPPOSITE of Java, where everything is inheritable unless you write final. It is a deliberate safety choice. This lesson covers Kotlin inheritance, abstract classes, interfaces, property accessors, visibility, and default parameter values, completing FestConnect Mobile's object model.

📖 Theory

Inheritance: open is required

In Kotlin, to inherit from a class, BOTH must cooperate:

• the parent class must be marked open: open class Person(val name: String)
• a member you want to override must ALSO be open
• the child uses override: override fun describe()

Syntax: class Attendee(name: String) : Person(name) (a colon, and the parent constructor is called).

This is the REVERSE of Java (BCA403), where classes and methods are open by DEFAULT and you write final to CLOSE them. Kotlin's default is final (closed); you opt IN to inheritance. The reasoning: inheritance should be a deliberate design decision, not an accident, so the safe default is 'cannot be extended unless intended'.

⌨️ Practical

open class, override, and a default parameter

// Parent must be OPEN to be inherited:
open class Person(val name: String) {
    open fun describe() = "Person: $name"   // open to allow override
}

// Child inherits with : and calls the parent constructor:
class Attendee(name: String, val event: String) : Person(name) {
    override fun describe() = "Attendee $name for $event"   // override
}

// DEFAULT PARAMETER VALUE: role defaults to "guest"
fun register(name: String, role: String = "guest") =
    "$name registered as $role"

fun main() {
    val p: Person = Attendee("Riya", "Garba")
    println(p.describe())            // Attendee Riya for Garba
    println(register("Aman"))        // Aman registered as guest (default)
    println(register("Zoya", "vip")) // Zoya registered as vip
}

📖 Theory

Abstract, interfaces, accessors, visibility, defaults

The rest of Kotlin's OOP toolkit, mostly familiar:

• abstract classes: cannot be instantiated; abstract members must be overridden (like Java)
• interfaces: interface, with abstract members AND default implementations; a class can implement several
• getters/setters: properties have default accessors; you can write a custom get()/set(value) with a backing field when you need logic
• visibility: public (default), private, protected, and internal (visible in the same MODULE, a level Java lacks)
• default parameter values: fun greet(name: String = "Guest") lets callers omit arguments, reducing the need for overloaded functions

Default values pair beautifully with named parameters (last lesson): one flexible function replaces many overloads.

🧩 Quiz

You write class Attendee : Person() but get an error that Person cannot be inherited. Why, and what fixes it?

1. Person needs a constructor; add one
2. Kotlin classes are FINAL by default; mark the parent 'open class Person' to allow inheritance (the opposite of Java)
3. You must use the 'extends' keyword, not a colon
4. Kotlin does not support inheritance

💭 Think first

Why is 'final by default' the safer choice?

Java classes are open (inheritable) by default; Kotlin classes are final (closed) by default. Why does Kotlin consider its default safer? Then tap.

⚠️ Watch out

Kotlin inheritance traps

Forgetting open: classes and members are final by default; mark them open to inherit/override (the Java-reflex bug).

extends/implements: Kotlin uses a colon (:) for both inheritance and interface implementation, not those keywords.

Calling the parent constructor: : Person(name) calls it; forgetting the arguments errors.

override keyword required: you must write override on an overriding member (Kotlin will not let you accidentally shadow).

internal vs private: internal is module-wide, private is class/file: know the difference (internal is new vs Java).

📖 Theory

Unit 2 complete: Kotlin OOP mastered

FestConnect Mobile now has a full Kotlin object model: concise classes, safe inheritance (open by intent), abstract classes, interfaces, custom accessors, and default parameters. That is the language, complete. Unit 3 turns to actually BUILDING the Android app: parsing JSON, moving between screens with intents, storing data in SQLite, and using device features like location and the camera. From the language to a real, data-driven, multi-screen mobile app.

✅ Summary

Key takeaways

• Kotlin classes are FINAL by default: mark the parent 'open' to allow inheritance, and members 'open' to override (opposite of Java).
• Inherit with a colon: class Attendee(name) : Person(name); the child uses 'override' on overridden members.
• abstract classes cannot be instantiated; interfaces can have abstract members and default implementations, and a class can implement several.
• Properties have default getters/setters; write custom get()/set(value) with a backing field for logic.
• Visibility: public (default), private, protected, internal (same module: new vs Java).
• Default parameter values (fun greet(name: String = "Guest")) let callers omit arguments, reducing overloads; pair with named parameters.
• Memory hook: final by default, open to inherit, override to override: inheritance is opt-in.