Kotlin Abstract Class

A Kotlin abstract class is a special type of class that cannot be instantiated directly and serves as a blueprint for other classes. The abstract keyword in Kotlin is used to declare these classes, which can contain both abstract and concrete members. Unlike regular classes, Kotlin abstract classes are designed to be inherited by subclasses that must implement all abstract methods and properties defined in the parent abstract class.

The primary purpose of Kotlin abstract class is to provide a common template that multiple related classes can extend while enforcing certain methods to be implemented by child classes. This makes Kotlin abstract classes essential for creating well-structured, inheritance-based architectures in Android applications.

Kotlin Abstract Class Syntax and Declaration

To declare a Kotlin abstract class, you use the abstract keyword before the class definition. Here’s the basic syntax for Kotlin abstract class declaration:

abstract class AbstractClassName {
    // Abstract properties
    abstract var abstractProperty: String
    
    // Abstract methods
    abstract fun abstractMethod(): Unit
    
    // Concrete properties
    var concreteProperty: String = "Default Value"
    
    // Concrete methods
    fun concreteMethod() {
        println("This is a concrete method")
    }
}

Key Properties of Kotlin Abstract Class:

1. Cannot Be Instantiated: You cannot create objects directly from a Kotlin abstract class. This is the fundamental characteristic that distinguishes abstract classes from regular classes.

abstract class Vehicle {
    abstract fun start()
}

// This will cause a compilation error
// val vehicle = Vehicle() // Error: Cannot create an instance of an abstract class

2. Can Contain Abstract Members: Kotlin abstract classes can have abstract properties and methods that must be implemented by subclasses.

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

3. Can Contain Concrete Members: Unlike interfaces, Kotlin abstract classes can have concrete implementations alongside abstract ones.

abstract class Animal {
    // Concrete property
    var species: String = "Unknown"
    
    // Concrete method
    fun eat() {
        println("Animal is eating")
    }
    
    // Abstract method
    abstract fun makeSound()
}

4. Always Open for Inheritance: Kotlin abstract classes are implicitly open, meaning you don’t need to use the open keyword for inheritance.

abstract class BaseClass {
    abstract fun abstractFunction()
}

// No need for 'open' keyword
class ChildClass : BaseClass() {
    override fun abstractFunction() {
        println("Implementation in child class")
    }
}

Kotlin Abstract Methods and Properties

Abstract Methods in Kotlin

Kotlin abstract methods are function declarations without implementation that must be overridden in subclasses. Here’s how to define and use abstract methods in Kotlin:

abstract class Database {
    // Abstract method without implementation
    abstract fun connect(url: String): Boolean
    
    // Abstract method with parameters
    abstract fun executeQuery(query: String): List<String>
    
    // Concrete method that can use abstract methods
    fun performOperation(query: String) {
        if (connect("database://localhost")) {
            val results = executeQuery(query)
            println("Operation completed with ${results.size} results")
        }
    }
}

Abstract Properties in Kotlin

Kotlin abstract properties define property declarations that subclasses must implement:

abstract class Configuration {
    // Abstract val property
    abstract val serverUrl: String
    
    // Abstract var property
    abstract var timeout: Int
    
    // Concrete property
    val version: String = "1.0"
    
    // Method using abstract properties
    fun displayConfig() {
        println("Server: $serverUrl, Timeout: $timeout, Version: $version")
    }
}

Implementing Kotlin Abstract Class

When you inherit from a Kotlin abstract class, you must implement all abstract members. Here’s a comprehensive example showing Kotlin abstract class implementation:

abstract class MediaPlayer {
    // Abstract properties
    abstract val supportedFormats: List<String>
    abstract var currentVolume: Int
    
    // Abstract methods
    abstract fun play(file: String): Boolean
    abstract fun pause(): Boolean
    abstract fun stop(): Boolean
    
    // Concrete properties
    var isPlaying: Boolean = false
    
    // Concrete methods
    fun getStatus(): String {
        return if (isPlaying) "Playing" else "Stopped"
    }
    
    protected fun validateFormat(file: String): Boolean {
        val extension = file.substringAfterLast(".")
        return supportedFormats.contains(extension)
    }
}

class AudioPlayer : MediaPlayer() {
    // Implementing abstract properties
    override val supportedFormats = listOf("mp3", "wav", "flac")
    override var currentVolume = 50
    
    // Implementing abstract methods
    override fun play(file: String): Boolean {
        if (!validateFormat(file)) {
            println("Unsupported audio format")
            return false
        }
        
        isPlaying = true
        println("Playing audio file: $file at volume $currentVolume")
        return true
    }
    
    override fun pause(): Boolean {
        if (isPlaying) {
            isPlaying = false
            println("Audio paused")
            return true
        }
        return false
    }
    
    override fun stop(): Boolean {
        isPlaying = false
        currentVolume = 0
        println("Audio stopped")
        return true
    }
    
    // Additional concrete method specific to AudioPlayer
    fun adjustBass(level: Int) {
        println("Bass adjusted to level: $level")
    }
}

Kotlin Abstract Class with Constructor

Kotlin abstract classes can have constructors, including primary and secondary constructors:

abstract class Employee(
    val name: String,
    val id: Int
) {
    // Secondary constructor
    constructor(name: String, id: Int, department: String) : this(name, id) {
        this.department = department
    }
    
    var department: String = "General"
    
    // Abstract method
    abstract fun calculateSalary(): Double
    
    // Concrete method
    fun getEmployeeInfo(): String {
        return "Employee: $name (ID: $id) - Department: $department"
    }
}

class Developer(
    name: String,
    id: Int,
    private val experience: Int
) : Employee(name, id, "Engineering") {
    
    override fun calculateSalary(): Double {
        return 50000.0 + (experience * 5000.0)
    }
    
    fun writeCode(language: String) {
        println("$name is writing code in $language")
    }
}

class Manager(
    name: String,
    id: Int,
    private val teamSize: Int
) : Employee(name, id, "Management") {
    
    override fun calculateSalary(): Double {
        return 70000.0 + (teamSize * 2000.0)
    }
    
    fun conductMeeting() {
        println("$name is conducting a team meeting")
    }
}

Kotlin Abstract Class vs Interface

Understanding the differences between Kotlin abstract class and interface is crucial for making the right design decisions:

Feature	Kotlin Abstract Class	Kotlin Interface
Instantiation	Cannot be instantiated	Cannot be instantiated
State Storage	Can store state (properties with values)	Cannot store state (properties must be abstract or have custom accessors)
Constructor	Can have constructors	Cannot have constructors
Inheritance	Single inheritance only	Multiple interface implementation
Abstract Members	Can have abstract and concrete members	All members are abstract by default (except with default implementations)

// Abstract class example
abstract class AbstractVehicle {
    var fuel: Double = 0.0  // Can store state
    abstract fun startEngine()
}

// Interface example
interface VehicleInterface {
    // val fuel: Double = 0.0  // Error: Cannot store state
    val fuel: Double  // Must be abstract
    fun startEngine()
}

Advanced Kotlin Abstract Class Examples

Nested Abstract Classes

Kotlin abstract classes can contain nested abstract classes:

abstract class GameEngine {
    abstract fun render()
    
    abstract class Renderer {
        abstract fun drawSprite(x: Int, y: Int)
        abstract fun drawText(text: String, x: Int, y: Int)
        
        fun clearScreen() {
            println("Screen cleared")
        }
    }
    
    abstract class AudioSystem {
        abstract fun playSound(soundId: String)
        abstract fun stopAllSounds()
    }
}

class Unity3DEngine : GameEngine() {
    override fun render() {
        println("Unity3D rendering frame")
    }
    
    class UnityRenderer : Renderer() {
        override fun drawSprite(x: Int, y: Int) {
            println("Drawing Unity sprite at ($x, $y)")
        }
        
        override fun drawText(text: String, x: Int, y: Int) {
            println("Drawing Unity text '$text' at ($x, $y)")
        }
    }
}

Abstract Class with Generic Types

Kotlin abstract classes support generic parameters:

abstract class Repository<T> {
    abstract fun save(item: T): Boolean
    abstract fun findById(id: String): T?
    abstract fun findAll(): List<T>
    abstract fun delete(id: String): Boolean
    
    protected fun validateItem(item: T): Boolean {
        return item != null
    }
    
    fun count(): Int {
        return findAll().size
    }
}

class UserRepository : Repository<User>() {
    private val users = mutableMapOf<String, User>()
    
    override fun save(item: User): Boolean {
        if (!validateItem(item)) return false
        users[item.id] = item
        return true
    }
    
    override fun findById(id: String): User? {
        return users[id]
    }
    
    override fun findAll(): List<User> {
        return users.values.toList()
    }
    
    override fun delete(id: String): Boolean {
        return users.remove(id) != null
    }
}

data class User(val id: String, val name: String, val email: String)

Complete Working Example: E-commerce System

Here’s a comprehensive example demonstrating Kotlin abstract class usage in an e-commerce context:

// Import statements (if needed)
import kotlin.math.PI

// Abstract base class for products
abstract class Product(
    val id: String,
    val name: String,
    protected var basePrice: Double
) {
    // Abstract properties
    abstract val category: String
    abstract val weight: Double
    
    // Abstract methods
    abstract fun calculatePrice(): Double
    abstract fun getShippingCost(): Double
    
    // Concrete properties
    var isAvailable: Boolean = true
    var description: String = ""
    
    // Concrete methods
    fun displayInfo() {
        println("Product: $name")
        println("Category: $category")
        println("Price: $${calculatePrice()}")
        println("Shipping: $${getShippingCost()}")
        println("Available: $isAvailable")
        if (description.isNotEmpty()) {
            println("Description: $description")
        }
        println("---")
    }
    
    protected fun applyTax(amount: Double): Double {
        return amount * 1.08 // 8% tax
    }
}

// Electronics product implementation
class Electronics(
    id: String,
    name: String,
    basePrice: Double,
    private val warrantyMonths: Int,
    override val weight: Double
) : Product(id, name, basePrice) {
    
    override val category = "Electronics"
    
    override fun calculatePrice(): Double {
        val warrantyFee = warrantyMonths * 10.0
        return applyTax(basePrice + warrantyFee)
    }
    
    override fun getShippingCost(): Double {
        return when {
            weight <= 1.0 -> 5.99
            weight <= 5.0 -> 12.99
            else -> 25.99
        }
    }
    
    fun getWarrantyInfo(): String {
        return "$warrantyMonths months warranty included"
    }
}

// Clothing product implementation
class Clothing(
    id: String,
    name: String,
    basePrice: Double,
    private val size: String,
    override val weight: Double
) : Product(id, name, basePrice) {
    
    override val category = "Clothing"
    
    override fun calculatePrice(): Double {
        val sizePremium = if (size in listOf("XL", "XXL")) 5.0 else 0.0
        return applyTax(basePrice + sizePremium)
    }
    
    override fun getShippingCost(): Double {
        return if (weight <= 0.5) 3.99 else 7.99
    }
    
    fun getSizeInfo(): String {
        return "Available in size: $size"
    }
}

// Books product implementation
class Book(
    id: String,
    name: String,
    basePrice: Double,
    private val pageCount: Int,
    private val isHardcover: Boolean,
    override val weight: Double
) : Product(id, name, basePrice) {
    
    override val category = "Books"
    
    override fun calculatePrice(): Double {
        val hardcoverFee = if (isHardcover) 5.0 else 0.0
        return applyTax(basePrice + hardcoverFee)
    }
    
    override fun getShippingCost(): Double {
        return when {
            weight <= 0.3 -> 2.99
            weight <= 1.0 -> 4.99
            else -> 8.99
        }
    }
    
    fun getBookDetails(): String {
        val coverType = if (isHardcover) "Hardcover" else "Paperback"
        return "$coverType, $pageCount pages"
    }
}

// Shopping cart to manage products
class ShoppingCart {
    private val products = mutableListOf<Product>()
    
    fun addProduct(product: Product) {
        products.add(product)
        println("Added ${product.name} to cart")
    }
    
    fun removeProduct(productId: String) {
        products.removeIf { it.id == productId }
        println("Removed product with ID: $productId from cart")
    }
    
    fun calculateTotal(): Double {
        return products.sumOf { it.calculatePrice() + it.getShippingCost() }
    }
    
    fun displayCart() {
        if (products.isEmpty()) {
            println("Cart is empty")
            return
        }
        
        println("=== Shopping Cart ===")
        products.forEach { it.displayInfo() }
        println("Total: $${String.format("%.2f", calculateTotal())}")
        println("=====================")
    }
    
    fun getProductCount(): Int = products.size
}

// Main function demonstrating the usage
fun main() {
    // Create various products
    val laptop = Electronics(
        id = "E001",
        name = "Gaming Laptop",
        basePrice = 1299.99,
        warrantyMonths = 24,
        weight = 2.5
    ).apply {
        description = "High-performance laptop for gaming and professional work"
    }
    
    val tshirt = Clothing(
        id = "C001",
        name = "Cotton T-Shirt",
        basePrice = 29.99,
        size = "L",
        weight = 0.3
    ).apply {
        description = "100% organic cotton, comfortable fit"
    }
    
    val novel = Book(
        id = "B001",
        name = "Kotlin Programming Guide",
        basePrice = 45.99,
        pageCount = 520,
        isHardcover = true,
        weight = 0.8
    ).apply {
        description = "Comprehensive guide to Kotlin programming"
    }
    
    val smartphone = Electronics(
        id = "E002",
        name = "Flagship Smartphone",
        basePrice = 899.99,
        warrantyMonths = 12,
        weight = 0.2
    ).apply {
        description = "Latest flagship smartphone with advanced features"
    }
    
    // Create shopping cart and add products
    val cart = ShoppingCart()
    
    // Add products to cart
    cart.addProduct(laptop)
    cart.addProduct(tshirt)
    cart.addProduct(novel)
    cart.addProduct(smartphone)
    
    println("\n")
    
    // Display cart contents
    cart.displayCart()
    
    // Demonstrate specific product methods
    println("\n=== Product Specific Information ===")
    println("Laptop warranty: ${laptop.getWarrantyInfo()}")
    println("T-shirt size: ${tshirt.getSizeInfo()}")
    println("Book details: ${novel.getBookDetails()}")
    println("Smartphone warranty: ${smartphone.getWarrantyInfo()}")
    
    // Remove a product
    println("\n")
    cart.removeProduct("C001")
    
    println("\n")
    cart.displayCart()
}

Expected Output:

Added Gaming Laptop to cart
Added Cotton T-Shirt to cart
Added Kotlin Programming Guide to cart
Added Flagship Smartphone to cart


=== Shopping Cart ===
Product: Gaming Laptop
Category: Electronics
Price: $1463.99
Shipping: $25.99
Available: true
Description: High-performance laptop for gaming and professional work
---
Product: Cotton T-Shirt
Category: Clothing
Price: $32.39
Shipping: $3.99
Available: true
Description: 100% organic cotton, comfortable fit
---
Product: Kotlin Programming Guide
Category: Books
Price: $55.07
Shipping: $4.99
Available: true
Description: Comprehensive guide to Kotlin programming
---
Product: Flagship Smartphone
Category: Electronics
Price: $1031.99
Shipping: $5.99
Available: true
Description: Latest flagship smartphone with advanced features
---
Total: $2624.39
=====================

=== Product Specific Information ===
Laptop warranty: 24 months warranty included
T-shirt size: Available in size: L
Book details: Hardcover, 520 pages
Smartphone warranty: 12 months warranty included

Removed product with ID: C001 from cart

=== Shopping Cart ===
Product: Gaming Laptop
Category: Electronics
Price: $1463.99
Shipping: $25.99
Available: true
Description: High-performance laptop for gaming and professional work
---
Product: Kotlin Programming Guide
Category: Books
Price: $55.07
Shipping: $4.99
Available: true
Description: Comprehensive guide to Kotlin programming
---
Product: Flagship Smartphone
Category: Electronics
Price: $1031.99
Shipping: $5.99
Available: true
Description: Latest flagship smartphone with advanced features
---
Total: $2588.03
=====================

This comprehensive example demonstrates how Kotlin abstract classes provide a solid foundation for building complex, inheritance-based systems. The abstract Product class defines the common structure and behavior that all products must have, while concrete implementations like Electronics, Clothing, and Book provide specific implementations for their respective categories.