Interface declaration and implementation in Kotlin - Mini Project: Build & Apply

Interface declaration and implementation

📖 Scenario: You are creating a simple program to represent different types of vehicles. Each vehicle can start and stop. You will use an interface to define these actions and then create classes that implement this interface.

🎯 Goal: Build a Kotlin program that declares an interface called Vehicle with two functions: start() and stop(). Then create two classes, Car and Bike, that implement the Vehicle interface. Finally, create objects of these classes and call their start() and stop() functions.

📋 What You'll Learn

Declare an interface called Vehicle with two functions: start() and stop()

Create a class called Car that implements the Vehicle interface

Create a class called Bike that implements the Vehicle interface

In both classes, provide simple print statements inside start() and stop() functions

Create objects of Car and Bike and call their start() and stop() functions

💡 Why This Matters

🌍 Real World

Interfaces are used in real-world apps to define common behaviors for different objects, like vehicles, users, or devices, so they can be handled in a uniform way.

💼 Career

Understanding interfaces is important for Kotlin developers to write clean, modular, and maintainable code, especially in Android app development and backend services.

1

Declare the Vehicle interface

Declare an interface called Vehicle with two functions: start() and stop(). Both functions should have no parameters and no return value.

Kotlin

// Declare interface Vehicle with start() and stop() functions
// Your code here

Hint

Use the interface keyword to declare an interface. Inside, declare two functions start() and stop() without bodies.

2

Create the Car class implementing Vehicle

Create a class called Car that implements the Vehicle interface. Override the start() function to print "Car started" and the stop() function to print "Car stopped".

Kotlin

interface Vehicle {
    fun start()
    fun stop()
}

// Create class Car implementing Vehicle
// Your code here

Hint

Use class Car : Vehicle to implement the interface. Use override keyword for the functions and add println statements inside.

3

Create the Bike class implementing Vehicle

Create a class called Bike that implements the Vehicle interface. Override the start() function to print "Bike started" and the stop() function to print "Bike stopped".

Kotlin

interface Vehicle {
    fun start()
    fun stop()
}

class Car : Vehicle {
    override fun start() {
        println("Car started")
    }

    override fun stop() {
        println("Car stopped")
    }
}

// Create class Bike implementing Vehicle
// Your code here

Hint

Similar to Car, create Bike class implementing Vehicle and override the functions with print statements.

4

Create objects and call functions

Create an object called myCar of type Car and an object called myBike of type Bike. Call start() and stop() on both objects.

Kotlin

interface Vehicle {
    fun start()
    fun stop()
}

class Car : Vehicle {
    override fun start() {
        println("Car started")
    }

    override fun stop() {
        println("Car stopped")
    }
}

class Bike : Vehicle {
    override fun start() {
        println("Bike started")
    }

    override fun stop() {
        println("Bike stopped")
    }
}

// Create objects myCar and myBike
// Call start() and stop() on both
// Your code here

Hint

Create objects using val myCar = Car() and val myBike = Bike(). Then call start() and stop() on each object. Put this code inside a main() function.

Practice

1. What is the main purpose of an interface in Kotlin?

easy

A. To inherit implementation from multiple classes

B. To create objects directly without classes

C. To store data like variables and constants

D. To define a contract with functions and properties without implementation

Solution

1. Step 1: Understand what an interface is

   An interface in Kotlin declares functions and properties but does not provide their implementation.

2. Step 2: Compare options with interface purpose

   To define a contract with functions and properties without implementation correctly states that interfaces define a contract without implementation. Other options describe features unrelated to interfaces.

3. Final Answer:

   To define a contract with functions and properties without implementation -> Option D

4. Quick Check:

   Interface = Contract without code [OK]

Hint: Interfaces declare what, not how, functions work [OK]

Common Mistakes:

• Thinking interfaces can create objects directly
• Confusing interfaces with classes that store data
• Believing interfaces inherit from classes

2. Which of the following is the correct way to declare an interface in Kotlin?

easy

A. interface MyInterface { fun doWork() }

B. class MyInterface { fun doWork() }

C. fun interface MyInterface { fun doWork(); fun doOther() }

D. interface MyInterface() { fun doWork() }

Solution

1. Step 1: Recall Kotlin interface syntax

   Interfaces are declared with the keyword interface followed by the name and curly braces containing function declarations without parentheses after the name.

2. Step 2: Check each option

   interface MyInterface { fun doWork() } matches the correct syntax. class MyInterface { fun doWork() } uses class instead of interface. fun interface MyInterface { fun doWork() } uses fun interface which is for functional interfaces but requires a single abstract method and different usage. interface MyInterface() { fun doWork() } incorrectly adds parentheses after the interface name.

3. Final Answer:

   interface MyInterface { fun doWork() } -> Option A

4. Quick Check:

   Interface syntax = interface Name { ... } [OK]

Hint: Interfaces use 'interface' keyword without parentheses [OK]

Common Mistakes:

• Using class keyword instead of interface
• Adding parentheses after interface name
• Confusing fun interface with regular interface

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

interface Greeter {
    fun greet(): String
}

class FriendlyGreeter : Greeter {
    override fun greet() = "Hello!"
}

fun main() {
    val greeter: Greeter = FriendlyGreeter()
    println(greeter.greet())
}

medium

A. FriendlyGreeter

B. Greeter

C. Hello!

D. Compilation error

Solution

1. Step 1: Understand interface implementation

   The interface Greeter declares a function greet(). The class FriendlyGreeter implements this interface and overrides greet() to return "Hello!".

2. Step 2: Trace the main function output

   In main(), an instance of FriendlyGreeter is assigned to a variable of type Greeter. Calling greet() on this instance returns "Hello!" which is printed.

3. Final Answer:

   Hello! -> Option C

4. Quick Check:

   Interface method call returns overridden string [OK]

Hint: Interface calls use implemented class methods [OK]

Common Mistakes:

• Expecting interface name printed instead of method result
• Thinking it causes compilation error without implementation
• Confusing class name with output

4. Identify the error in this Kotlin code snippet:

interface Animal {
    fun sound(): String
}

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

medium

A. Dog class must override sound() with 'override' keyword

B. Interface cannot have functions with return type

C. Dog class should not implement Animal interface

D. sound() function should be private in Dog class

Solution

1. Step 1: Check interface function implementation rules

   When a class implements an interface function, it must use the override keyword to provide the implementation.

2. Step 2: Analyze the Dog class

   The Dog class defines sound() without override. This causes a compilation error because it does not properly override the interface method.

3. Final Answer:

   Dog class must override sound() with 'override' keyword -> Option A

4. Quick Check:

   Override keyword required for interface methods [OK]

Hint: Always use 'override' when implementing interface methods [OK]

Common Mistakes:

• Omitting the override keyword
• Thinking interface methods can't have return types
• Making interface implementation optional

5. Given the interface and classes below, what will be the output when main() is run?

interface Calculator {
    fun calculate(x: Int, y: Int): Int
}

class Adder : Calculator {
    override fun calculate(x: Int, y: Int) = x + y
}

class Multiplier : Calculator {
    override fun calculate(x: Int, y: Int) = x * y
}

fun main() {
    val calculators: List<Calculator> = listOf(Adder(), Multiplier())
    for (calc in calculators) {
        println(calc.calculate(3, 4))
    }
}

hard

A. 12
7

B. 7
12

C. 34
34

D. Compilation error due to interface list

Solution

1. Step 1: Understand interface implementations

   Two classes implement Calculator: Adder adds two numbers, Multiplier multiplies them.

2. Step 2: Trace the loop output

   The list contains an Adder and a Multiplier. Calling calculate(3,4) on Adder returns 7, on Multiplier returns 12. These are printed in order.

3. Final Answer:

   7 12 -> Option B

4. Quick Check:

   Adder + Multiplier outputs 7 and 12 [OK]

Hint: Interface list calls each class's method in order [OK]

Common Mistakes:

• Mixing order of outputs
• Expecting string concatenation instead of arithmetic
• Thinking interface list causes error