Kotlin - Abstract Classes and Interfaces

Kotlin Abstract Classes and Interfaces 

Introduction to Abstraction in Kotlin

Kotlin is a modern, statically typed programming language widely used for Android development, server-side applications, and multiplatform projects. One of the most important object-oriented programming concepts supported by Kotlin is abstraction. Abstraction allows developers to hide implementation details and expose only essential features of a class or component.

In Kotlin, abstraction is mainly achieved using abstract classes and interfaces. These two constructs are fundamental for designing flexible, scalable, and maintainable applications. Understanding their differences, similarities, use cases, and best practices is crucial for Kotlin developers.this detailed guide explains Kotlin abstract classes and interfaces with syntax, rules, examples, real-world use cases, and comparisons. The content is structured for learning platforms, interviews, and exam preparation while also including important keywords commonly searched by learners.

What is Abstraction in Kotlin?

Abstraction is an object-oriented programming principle that focuses on showing only the necessary information to the user and hiding the internal implementation details. In Kotlin, abstraction helps achieve:

• Loose coupling between components
• Improved code readability
• Better maintainability
• Enhanced scalability
• Support for polymorphism

Kotlin supports abstraction using:

• Abstract classes
• Interfaces

Kotlin Abstract Classes

Definition of Abstract Class in Kotlin

An abstract class in Kotlin is a class that cannot be instantiated directly. It is declared using the abstract keyword and may contain both abstract (unimplemented) methods and concrete (implemented) methods.

Abstract classes are used when multiple related classes share common behavior but also require specific implementations.

Syntax of Abstract Class in Kotlin

abstract class Vehicle {
    abstract fun start()

    fun fuelType(): String {
        return "Petrol or Diesel"
    }
}

Key Characteristics of Abstract Classes

• Declared using the abstract keyword
• Cannot create objects directly
• Can contain abstract and non-abstract methods
• Can have properties with initial values
• Supports constructors
• Supports inheritance (single inheritance)

Abstract Methods in Kotlin

Abstract methods are methods without a body. They must be implemented by the subclass that inherits the abstract class.

abstract class Shape {
    abstract fun area(): Double
}

Implementing Abstract Class in Kotlin

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

In the above example, the Circle class provides the implementation of the abstract method area.

Abstract Properties in Kotlin

Abstract classes can also contain abstract properties without initialization. These properties must be overridden in the subclass.

abstract class Employee {
    abstract val salary: Double
}

class Developer : Employee() {
    override val salary: Double = 50000.0
}

Constructors in Abstract Classes

Unlike interfaces, abstract classes can have constructors. These constructors are called when a subclass is instantiated.

abstract class Person(val name: String) {
    abstract fun role()
}

class Teacher(name: String) : Person(name) {
    override fun role() {
        println("Teaching students")
    }
}

Use Cases of Abstract Classes

• When classes share common state and behavior
• When default method implementations are required
• When constructors are needed
• When partial abstraction is sufficient

Kotlin Interfaces

Definition of Interface in Kotlin

An interface in Kotlin is a blueprint that defines methods and properties without maintaining state. Interfaces are declared using the interface keyword. They support full abstraction and multiple inheritance.

Syntax of Interface in Kotlin

interface Animal {
    fun sound()
}

Implementing an Interface in Kotlin

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

Interface with Default Method Implementation

Kotlin interfaces can have method implementations, unlike Java interfaces before Java 8.

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

class Bike : Vehicle

Interface Properties in Kotlin

Interfaces can declare properties, but they cannot store state. Properties must be overridden in implementing classes.

interface User {
    val username: String
}

class Admin : User {
    override val username: String = "admin"
}

Multiple Inheritance Using Interfaces

Kotlin supports multiple inheritance through interfaces. A class can implement multiple interfaces at the same time.

interface A {
    fun show()
}

interface B {
    fun display()
}

class C : A, B {
    override fun show() {
        println("Show from A")
    }

    override fun display() {
        println("Display from B")
    }
}

Resolving Method Conflicts in Interfaces

When multiple interfaces have methods with the same signature, Kotlin requires the implementing class to override and resolve the conflict.

interface X {
    fun demo() {
        println("X demo")
    }
}

interface Y {
    fun demo() {
        println("Y demo")
    }
}

class Z : X, Y {
    override fun demo() {
        super.demo()
        super.demo()
    }
}

Use Cases of Interfaces

• Achieving full abstraction
• Supporting multiple inheritance
• Defining contracts for classes
• Decoupling components
• Implementing design patterns

Difference Between Abstract Class and Interface in Kotlin

Abstract Class vs Interface – When to Use What?

Use abstract classes when:

• You need to share code among related classes
• You need constructors
• You need protected or internal members

Use interfaces when:

• You need multiple inheritance
• You want to define behavior contracts
• You need loose coupling
• You want to support functional programming concepts

 Example Using Abstract Class and Interface

interface Payment {
    fun pay(amount: Double)
}

abstract class OnlinePayment : Payment {
    fun validate() {
        println("Validating payment")
    }
}

class CreditCardPayment : OnlinePayment() {
    override fun pay(amount: Double) {
        validate()
        println("Paid using credit card: $amount")
    }
}

 Abstract Classes and Interfaces in Kotlin

• Prefer interfaces for defining APIs
• Use abstract classes for shared implementation
• Keep interfaces small and focused
• Use meaningful method names
• Avoid deep inheritance hierarchies

Abstract classes and interfaces are core components of Kotlin’s object-oriented programming model. They enable developers to write clean, reusable, and flexible code. Abstract classes are best suited for sharing common functionality, while interfaces are ideal for defining contracts and supporting multiple inheritance.Mastering Kotlin abstract classes and interfaces is essential for building robust Android applications, backend systems, and scalable software architectures.