Interfaces and Abstract Classes

# CHAPTER 16

Interfaces and Abstract Classes #

1. Chapter Introduction #

2. Learning Objectives #

• Define and implement Interfaces.

• Understand how Interfaces bypass single-inheritance limits.

• Create Abstract Classes.

• Distinguish between when to use an Interface vs an Abstract Class.

3. What is an Interface? #

// Define the Interface (The Contract)
interface Drivable {
    fun drive() // No body! Just the signature.
    fun stop()
}

// Implement the Interface
class Car : Drivable {
    // We MUST override the methods to fulfill the contract!
    override fun drive() {
        println("Car is moving forward.")
    }

    override fun stop() {
        println("Car brakes applied.")
    }
}

4. Multiple Interfaces (Solving Single Inheritance) #

interface Flyable {
    fun fly()
}

interface Swimmable {
    fun swim()
}

// The Duck class implements two interfaces!
class Duck : Flyable, Swimmable {
    override fun fly() {
        println("Duck is flying!")
    }

    override fun swim() {
        println("Duck is swimming!")
    }
}

*Because Interfaces only provide signatures, there is no confusion about which parent logic to use, making multiple implementation safe.*

5. Interfaces with Default Methods #

interface Clickable {
    // Default implementation!
    fun click() {
        println("Button was clicked!")
    }
}

class MyButton : Clickable // We don't HAVE to override click() because it has a default!

6. What is an Abstract Class? #

• Like an Interface: It cannot be instantiated (you can't do val x = Animal()).

• Like a regular Class: It can hold state (actual variables).

Use it when you want a base class to provide *some* core logic and state, but force the child classes to fill in the missing pieces.

abstract class Shape {
    var name: String = "Generic Shape" // It holds state!

    // Abstract method: Has no body. Child MUST override it.
    abstract fun calculateArea(): Double 
    
    // Standard method: Child inherits this automatically.
    fun printInfo() {
        println("This is a $name")
    }
}

// Circle MUST provide calculateArea()
class Circle(val radius: Double) : Shape() {
    init {
        name = "Circle"
    }

    override fun calculateArea(): Double {
        return 3.14 * radius * radius
    }
}

7. Interface vs Abstract Class Comparison #

8. Common Mistakes #

• Trying to instantiate an Interface or Abstract Class: val s = Shape() will trigger a compiler error. They are blueprints for blueprints; they cannot exist as standalone objects.

• Putting state in an Interface: Writing var count: Int = 0 inside an interface is not allowed. Interfaces describe behavior, not state.

9. Best Practices #

• Code to an Interface: When passing parameters to a function, ask for the Interface, not the concrete class. fun testDrive(vehicle: Drivable) is better than fun testDrive(vehicle: Car), because now the function accepts Cars, Trucks, and Motorcycles!

10. Exercises #

1. 1. Create an interface Playable with a method play().

1. 2. Create classes Guitar and Piano that implement Playable.

1. 3. Create a function performConcert(instrument: Playable) that calls play().

1. 4. Call performConcert() using both instruments in main().

11. MCQs with Answers #

Q1. Can you instantiate an Interface directly (e.g., val x = MyInterface())? a) Yes b) No Answer: b) No.

Q5. Can an Abstract Class hold actual state (state variables)? a) Yes b) No Answer: a) Yes.

Q6. Can a class inherit from multiple Abstract Classes? a) Yes b) No, abstract classes are still classes and follow Single Inheritance rules Answer: b) No.

Q9. Which concept is best used to model a "Can-Do" behavior (e.g., A Bird CAN FLY)? a) Abstract Class b) Interface Answer: b) Interface.

12. Interview Questions #

• Q: Explain the difference between an Interface and an Abstract Class. When would you use one over the other?

• Q: How do Interfaces solve the problem of Multiple Inheritance in Kotlin?

13. Summary #

14. Next Chapter Recommendation #