Kotlin - Abstract Classes and Interfaces

Abstract Classes and Interfaces in Kotlin

Kotlin is a modern, statically-typed programming language that runs on the Java Virtual Machine (JVM) and is officially supported for Android development. One of Kotlin’s strengths is its object-oriented features, including **abstract classes** and **interfaces**, which play a fundamental role in designing robust and flexible code architectures. This article provides an in-depth look at abstract classes and interfaces in Kotlin, covering their syntax, differences, use cases, and best practices.

Understanding Abstract Classes in Kotlin

What is an Abstract Class?

An abstract class in Kotlin is a class that cannot be instantiated directly. It serves as a blueprint for other classes. Abstract classes may contain both abstract members (which have no implementation) and concrete members (which have an implementation). They are used when classes share some common functionality but also have some behavior that should be implemented by subclasses.

abstract class Animal {
    abstract fun makeSound()
    
    fun sleep() {
        println("The animal is sleeping")
    }
}

Creating a Subclass

To use an abstract class, another class must inherit from it and provide implementations for all abstract members.

class Dog : Animal() {
    override fun makeSound() {
        println("Woof")
    }
}

Key Features of Abstract Classes

• Cannot be instantiated directly.
• Can contain both abstract and concrete methods.
• Support constructor parameters and initialization blocks.
• Can have properties with or without implementations.

Abstract Properties

Just like abstract methods, you can define abstract properties that must be implemented in derived classes.

abstract class Person {
    abstract val name: String
    abstract var age: Int
}

Concrete Properties and Methods

Concrete (non-abstract) properties and methods can be shared among subclasses:

abstract class Shape {
    fun displayType() {
        println("This is a shape.")
    }
}

Constructors in Abstract Classes

Abstract classes can have primary and secondary constructors.

abstract class Vehicle(val brand: String) {
    abstract fun start()
}

class Car(brand: String): Vehicle(brand) {
    override fun start() {
        println("$brand car is starting")
    }
}

Understanding Interfaces in Kotlin

What is an Interface?

An interface in Kotlin defines a contract that other classes can implement. Unlike abstract classes, interfaces do not hold state. They can define abstract methods as well as default implementations for methods.

interface Drivable {
    fun drive()
    fun stop() {
        println("Vehicle stopped")
    }
}

Implementing an Interface

Any class can implement an interface using the : keyword followed by the interface name.

class Truck : Drivable {
    override fun drive() {
        println("Truck is driving")
    }
}

Properties in Interfaces

Interfaces can declare properties. These can either be abstract or have getters.

interface Identifiable {
    val id: String
    val description: String
        get() = "Default description"
}

Abstract Class vs Interface: Key Differences

Multiple Interfaces

A class in Kotlin can implement more than one interface.

interface A {
    fun methodA()
}

interface B {
    fun methodB()
}

class MyClass : A, B {
    override fun methodA() = println("Method A")
    override fun methodB() = println("Method B")
}

Conflict Resolution in Interfaces

If a class implements multiple interfaces with the same method signature, it must resolve the conflict explicitly.

interface First {
    fun greet() {
        println("Hello from First")
    }
}

interface Second {
    fun greet() {
        println("Hello from Second")
    }
}

class Greeter : First, Second {
    override fun greet() {
        super.greet()
        super.greet()
    }
}

Interface Inheritance

Interfaces in Kotlin can extend other interfaces:

interface Animal {
    fun eat()
}

interface Bird : Animal {
    fun fly()
}

Implementing Extended Interface

class Sparrow : Bird {
    override fun eat() {
        println("Sparrow is eating")
    }

    override fun fly() {
        println("Sparrow is flying")
    }
}

When to Use Abstract Classes

• When there’s shared implementation and state among multiple classes.
• When classes are closely related and follow an "is-a" relationship.
• When you want to enforce a common base class with common functionality.
• When you need constructor parameters or hold state in the base class.

When to Use Interfaces

• When you want to define a contract for classes without enforcing inheritance.
• When you need multiple inheritance.
• When implementation varies completely among classes.
• When you want to separate behavior from class hierarchy.

Combining Abstract Classes and Interfaces

Kotlin allows combining abstract classes and interfaces. A class can inherit from one abstract class and implement multiple interfaces.

abstract class Machine {
    abstract fun operate()
}

interface Washable {
    fun wash()
}

interface Dryable {
    fun dry()
}

class WashingMachine : Machine(), Washable, Dryable {
    override fun operate() {
        println("Operating machine")
    }

    override fun wash() {
        println("Washing clothes")
    }

    override fun dry() {
        println("Drying clothes")
    }
}

Real-World Example: Payment System

abstract class PaymentProcessor {
    abstract fun processPayment(amount: Double)
    
    fun logTransaction() {
        println("Transaction logged")
    }
}

interface Refundable {
    fun refund(amount: Double)
}

class CreditCardProcessor : PaymentProcessor(), Refundable {
    override fun processPayment(amount: Double) {
        println("Processing credit card payment: $$amount")
    }

    override fun refund(amount: Double) {
        println("Refunding $$amount to credit card")
    }
}

Best Practices

• Use interfaces for capabilities (e.g., Drivable, Runnable).
• Use abstract classes for shared implementation logic.
• Keep interfaces small and focused (Interface Segregation Principle).
• Don’t abuse default method implementations in interfaces.
• Favor composition over inheritance when possible.

Abstract classes and interfaces are two cornerstone features in Kotlin that enable polymorphism, code reuse, and adherence to the SOLID principles of object-oriented design. Abstract classes provide a strong foundation for creating hierarchies where classes share common behavior and structure, while interfaces allow defining capabilities and contracts without dictating inheritance chains.

Understanding when to use abstract classes versus interfaces, how to implement and combine them effectively, and how to resolve method conflicts are essential skills for any Kotlin developer. With the flexibility that Kotlin provides, you can design systems that are both scalable and maintainable, promoting clean architecture and reusable code.