Open classes and methods in Kotlin - Step-by-Step Execution

Concept Flow - Open classes and methods

Define class

↓

Is class 'open'?

No→Class is final, no inheritance

Yes↓

Define methods

↓

Is method 'open'?

No→Method is final, no override

Yes↓

Subclass inherits class

↓

Override open methods

↓

Use subclass instance

This flow shows how Kotlin classes and methods must be marked 'open' to allow inheritance and overriding.

Execution Sample

Kotlin

open class Animal {
    open fun sound() = "Some sound"
}

class Dog : Animal() {
    override fun sound() = "Bark"
}

println(Dog().sound())

Defines an open class and method, then overrides the method in a subclass and prints the result.

Execution Table

Step	Action	Evaluation	Result
1	Define open class Animal	Class Animal created	Animal is open for inheritance
2	Define open method sound in Animal	Method sound() returns "Some sound"	Method is open for override
3	Define class Dog inheriting Animal	Dog inherits Animal	Dog can override open methods
4	Override sound() in Dog	sound() returns "Bark"	Dog's sound() overrides Animal's
5	Create Dog instance and call sound()	Dog().sound()	"Bark" printed

💡 Execution ends after printing overridden method output

Variable Tracker

Variable	Start	After Step 3	After Step 5
Animal	Defined open class	Inherited by Dog	No instance created
Dog	Not defined	Defined subclass of Animal	Instance created
sound()	"Some sound"	Overridden to "Bark"	Returns "Bark" when called

Key Moments - 3 Insights

Why do we need to mark a class as 'open' to inherit it?

By default, Kotlin classes are final and cannot be inherited. Marking a class 'open' (see step 1 in execution_table) allows other classes to inherit from it.

Can we override methods that are not marked 'open'?

No, only methods marked 'open' (step 2) can be overridden. Trying to override a non-open method causes a compile error.

What happens if we don't override an open method in a subclass?

The subclass inherits the original method behavior (step 3), so calling the method uses the parent class's version.

Visual Quiz - 3 Questions

Look at the execution_table, what does the Dog's sound() method return at step 4?

A "Bark"

B No return, error

C "Some sound"

D "Meow"

💡 Hint

Check the 'Evaluation' column at step 4 in execution_table

At which step is the Dog class defined as a subclass of Animal?

A Step 1

B Step 2

C Step 3

D Step 5

💡 Hint

Look at the 'Action' column for subclass definition in execution_table

If the Animal class was not marked 'open', what would happen when defining Dog?

A Dog inherits Animal normally

B Compile error, cannot inherit final class

C Dog can override methods but not inherit

D Runtime error when creating Dog instance

💡 Hint

Refer to the concept_flow where non-open classes cannot be inherited

Concept Snapshot

Kotlin classes and methods are final by default.
Use 'open' keyword to allow inheritance and method overriding.
Subclass inherits open class and can override open methods.
Override methods with 'override' keyword.
Trying to inherit or override non-open members causes errors.

Full Transcript

In Kotlin, classes and methods are final by default, meaning you cannot inherit or override them unless you explicitly mark them as 'open'. This example defines an open class Animal with an open method sound(). Then, a subclass Dog inherits Animal and overrides the sound() method. When we create a Dog instance and call sound(), it prints "Bark", showing the override works. The execution table traces each step: defining classes, marking open, subclassing, overriding, and calling the method. The variable tracker shows how the class and method states change. Key moments clarify why 'open' is needed and what happens if you don't override. The quiz tests understanding of these steps. Remember, 'open' is the key to inheritance and overriding in Kotlin.

Practice

1. In Kotlin, what does the open keyword do when applied to a class or method?

easy

A. Prevents the class or method from being used

B. Makes the class or method private

C. Allows the class or method to be inherited or overridden

D. Automatically overrides the method in subclasses

Solution

1. Step 1: Understand Kotlin class and method defaults

   By default, Kotlin classes and methods are final, meaning they cannot be inherited or overridden.

2. Step 2: Role of the open keyword

   The open keyword explicitly allows a class to be inherited or a method to be overridden in subclasses.

3. Final Answer:

   Allows the class or method to be inherited or overridden -> Option C

4. Quick Check:

   open means inheritance allowed [OK]

Hint: Remember: open means 'can be changed' [OK]

Common Mistakes:

• Thinking classes are open by default
• Confusing open with override
• Assuming open makes methods private

2. Which of the following is the correct way to declare an open method named display in Kotlin?

easy

A. open fun display() { }

B. fun display() open { }

C. fun open display() { }

D. open display fun() { }

Solution

1. Step 1: Recall Kotlin method declaration syntax

   In Kotlin, the keyword fun starts the function declaration, followed by the function name and parentheses.

2. Step 2: Position of open keyword

   The open keyword must come before fun to mark the method as open for overriding.

3. Final Answer:

   open fun display() { } -> Option A

4. Quick Check:

   open fun is correct order [OK]

Hint: Put open before fun for methods [OK]

Common Mistakes:

• Placing open after fun
• Putting open after method name
• Using open without fun keyword

3. What will be the output of the following Kotlin code?

open class Animal {
    open fun sound() = "Some sound"
}

class Dog : Animal() {
    override fun sound() = "Bark"
}

fun main() {
    val pet: Animal = Dog()
    println(pet.sound())
}

medium

A. Some sound

B. Bark

C. Compilation error

D. Runtime error

Solution

1. Step 1: Understand class inheritance and method overriding

   The class Dog inherits from Animal and overrides the sound() method to return "Bark".

2. Step 2: Polymorphism in action

   Even though pet is typed as Animal, it holds a Dog instance, so the overridden sound() method in Dog is called.

3. Final Answer:

   Bark -> Option B

4. Quick Check:

   Overridden method runs on subclass instance [OK]

Hint: Overridden methods run on actual object type [OK]

Common Mistakes:

• Expecting base class method output
• Confusing compile-time and run-time types
• Forgetting to mark methods open

4. Identify the error in the following Kotlin code:

class Vehicle {
    open fun start() = "Starting"
}

class Car : Vehicle() {
    fun start() = "Car starting"
}

medium

A. Method start() in Car must be marked override

B. No error, code is correct

C. Car class cannot inherit from Vehicle

D. Vehicle class must be open to allow inheritance

Solution

1. Step 1: Check if Vehicle class allows inheritance

   By default, Kotlin classes are final. Since Vehicle is not marked open, it cannot be inherited.

2. Step 2: Analyze the inheritance attempt

   Car tries to inherit from Vehicle, which causes a compilation error because Vehicle is not open.

3. Final Answer:

   Vehicle class must be open to allow inheritance -> Option D

4. Quick Check:

   Classes must be open to inherit [OK]

Hint: Mark classes open to inherit them [OK]

Common Mistakes:

• Forgetting to mark base class open
• Assuming methods override without keyword
• Ignoring Kotlin's default final classes

5. You want to create a Kotlin class Shape with an open method area() that returns 0.0 by default. Then create a subclass Circle that overrides area() to return the circle's area using its radius. Which code correctly implements this?

hard

A. open class Shape {
open fun area() = 0.0
}

class Circle(val radius: Double) : Shape() {
override fun area() = 3.14 * radius * radius
}

B. class Shape {
fun area() = 0.0
}

class Circle(val radius: Double) : Shape() {
fun area() = 3.14 * radius * radius
}

C. open class Shape {
fun area() = 0.0
}

class Circle(val radius: Double) : Shape() {
override fun area() = 3.14 * radius * radius
}

D. class Shape {
open fun area() = 0.0
}

class Circle(val radius: Double) : Shape() {
override fun area() = 3.14 * radius * radius
}

Solution

1. Step 1: Mark base class and method open

   To allow inheritance and overriding, Shape must be open and its area() method must also be open.

2. Step 2: Override method correctly in subclass

   Circle inherits from Shape and overrides area() using override keyword, calculating area using radius.

3. Final Answer:

   Option A code correctly implements open class and method with override -> Option A

4. Quick Check:

   Open base and override subclass method [OK]

Hint: Open base class and method, override in subclass [OK]

Common Mistakes:

• Not marking class or method open
• Missing override keyword in subclass
• Trying to override non-open method