Interface with default implementations in Kotlin - Mini Project: Build & Apply

Interface with Default Implementations in Kotlin

📖 Scenario: Imagine you are creating a simple app to manage different types of vehicles. Each vehicle can start and stop, but some vehicles have a default way to start and stop.

🎯 Goal: You will create an interface called Vehicle with default implementations for start() and stop() methods. Then, you will create a class Car that uses these defaults and a class Bike that overrides the default start() method.

📋 What You'll Learn

Create an interface called Vehicle with default methods start() and stop()

Create a class called Car that implements Vehicle and uses default methods

Create a class called Bike that implements Vehicle and overrides the start() method

Create instances of Car and Bike and call their start() and stop() methods

Print the output of these method calls

💡 Why This Matters

🌍 Real World

Interfaces with default implementations help you write flexible and reusable code. For example, vehicle management systems can share common behavior while allowing specific vehicles to customize actions.

💼 Career

Understanding interfaces with default methods is important for Kotlin developers working on Android apps or backend services where code reuse and clean design are essential.

1

Create the Vehicle interface with default methods

Create an interface called Vehicle with two methods: start() and stop(). Provide default implementations for both methods that print "Vehicle is starting" and "Vehicle is stopping" respectively.

Kotlin

interface Vehicle {
    // Your code here
}

Hint

Use fun start() { println(...) } inside the interface to provide default behavior.

2

Create the Car class implementing Vehicle using default methods

Create a class called Car that implements the Vehicle interface. Do not override any methods so it uses the default start() and stop() implementations.

Kotlin

interface Vehicle {
    fun start() {
        println("Vehicle is starting")
    }

    fun stop() {
        println("Vehicle is stopping")
    }
}

class Car : Vehicle {
    // Your code here
}

Hint

Just write class Car : Vehicle and leave the body empty to use defaults.

3

Create the Bike class overriding the start method

Create a class called Bike that implements the Vehicle interface. Override the start() method to print "Bike is starting differently" but keep the default stop() method.

Kotlin

interface Vehicle {
    fun start() {
        println("Vehicle is starting")
    }

    fun stop() {
        println("Vehicle is stopping")
    }
}

class Car : Vehicle {
    // Uses default implementations
}

class Bike : Vehicle {
    override fun start() {
        // Your code here
    }
}

Hint

Use override fun start() { println(...) } inside Bike.

4

Create instances and call start and stop methods

Create instances of Car and Bike named myCar and myBike. Call start() and stop() on both instances. Print the output of these calls.

Kotlin

interface Vehicle {
    fun start() {
        println("Vehicle is starting")
    }

    fun stop() {
        println("Vehicle is stopping")
    }
}

class Car : Vehicle {
    // Uses default implementations
}

class Bike : Vehicle {
    override fun start() {
        println("Bike is starting differently")
    }
}

fun main() {
    // Your code here
}

Hint

Create val myCar = Car() and val myBike = Bike(). Then call start() and stop() on both.

Practice

1.

What is the main purpose of providing a default implementation in a Kotlin interface?

interface Example { fun greet() { println("Hello") } }

easy

A. To allow classes to use the function without implementing it themselves

B. To prevent classes from overriding the function

C. To make the interface abstract and unusable

D. To force all classes to implement the function

Solution

1. Step 1: Understand default implementations in interfaces

   Default implementations provide a function body inside the interface itself.

2. Step 2: Effect on implementing classes

   Classes can use this default function without writing their own version.

3. Final Answer:

   To allow classes to use the function without implementing it themselves -> Option A

4. Quick Check:

   Default implementation means no need to override [OK]

Hint: Default means usable without override [OK]

Common Mistakes:

• Thinking default means function cannot be overridden
• Confusing default implementation with abstract function
• Believing interface becomes unusable with default methods

2.

Which of the following is the correct syntax for a Kotlin interface with a default implementation of a function fun info()?

easy

A. interface Info { fun info() = println("Info") }

B. interface Info { fun info() println("Info") }

C. interface Info { fun info() -> println("Info") }

D. interface Info { fun info; println("Info") }

Solution

1. Step 1: Recall Kotlin interface function syntax

   Default implementations use = followed by expression or block with braces.

2. Step 2: Check each option

   interface Info { fun info() = println("Info") } uses = with println(), which is correct syntax for default implementation.

3. Final Answer:

   interface Info { fun info() = println("Info") } -> Option A

4. Quick Check:

   Default function uses = expression [OK]

Hint: Default functions use = for single expression [OK]

Common Mistakes:

• Using braces without = in interface default functions
• Using arrow -> instead of =
• Writing function body outside interface

3.

What will be the output of the following Kotlin code?

interface Printer {
    fun print() { println("Printing from interface") }
}

class Document : Printer {
    override fun print() { println("Printing from Document") }
}

fun main() {
    val doc: Printer = Document()
    doc.print()
}

medium

A. Printing from interface

B. Compilation error due to override

C. Printing from Document

D. Runtime error

Solution

1. Step 1: Understand override behavior

   The class Document overrides the print() function from Printer interface.

2. Step 2: Check which print() is called

   Even though the variable type is Printer, the actual object is Document, so overridden print() runs.

3. Final Answer:

   Printing from Document -> Option C

4. Quick Check:

   Overridden method runs on object type [OK]

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

Common Mistakes:

• Thinking interface default method runs instead of override
• Confusing variable type with object type
• Expecting compilation error for override

4.

Identify the error in this Kotlin code snippet:

interface Logger {
    fun log() { println("Logging") }
}

class FileLogger : Logger {
    fun log() { println("File logging") }
}

medium

A. FileLogger cannot implement Logger without constructor

B. Missing override keyword in FileLogger's log() function

C. Interface functions cannot have bodies

D. log() function must be abstract in interface

Solution

1. Step 1: Check interface function declaration

   Logger interface has a default implementation of log().

2. Step 2: Check FileLogger's log() function

   It defines log() but misses the override keyword, which is required.

3. Final Answer:

   Missing override keyword in FileLogger's log() function -> Option B

4. Quick Check:

   Override keyword required when overriding [OK]

Hint: Override keyword is mandatory for overrides [OK]

Common Mistakes:

• Forgetting override keyword
• Thinking interface functions cannot have bodies
• Assuming abstract keyword needed in interface

5.

Given this Kotlin interface and classes, what will be the output when main() runs?

interface Speaker {
    fun speak() { println("Speaking from Speaker") }
}

class Person : Speaker

class Robot : Speaker {
    override fun speak() { println("Speaking from Robot") }
}

fun main() {
    val list: List<Speaker> = listOf(Person(), Robot())
    for (item in list) {
        item.speak()
    }
}

hard

A. Compilation error due to missing override in Person

B. Speaking from Person
Speaking from Robot

C. Speaking from Speaker
Speaking from Speaker

D. Speaking from Speaker
Speaking from Robot

Solution

1. Step 1: Analyze Person class

   Person does not override speak(), so it uses Speaker's default implementation.

2. Step 2: Analyze Robot class

   Robot overrides speak(), so its own version runs.

3. Step 3: Loop output

   First item (Person) prints "Speaking from Speaker", second (Robot) prints "Speaking from Robot".

4. Final Answer:

   Speaking from Speaker Speaking from Robot -> Option D

5. Quick Check:

   Default + override methods run accordingly [OK]

Hint: Classes use default unless overridden [OK]

Common Mistakes:

• Expecting Person to print "Speaking from Person"
• Thinking missing override causes error
• Assuming both print Robot's message