Kotlin - Interfaces & Abstract Classes

Abstract Classes

Abstract classes cannot be instantiated and are designed to be extended. They can contain both abstract and concrete members.

Basic Abstract Class

abstract class Animal {
    // Concrete property
    val isAlive = true
    
    // Abstract property
    abstract val species: String
    
    // Concrete method
    fun sleep() {
        println("$species is sleeping")
    }
    
    // Abstract method
    abstract fun makeSound()
    
    // Method with default implementation that can be overridden
    open fun move() {
        println("$species is moving")
    }
}

class Dog(override val species: String = "Canine") : Animal() {
    override fun makeSound() {
        println("Woof! Woof!")
    }
    
    override fun move() {
        println("Dog is running on four legs")
    }
}

class Bird(override val species: String = "Avian") : Animal() {
    override fun makeSound() {
        println("Tweet! Tweet!")
    }
    
    override fun move() {
        println("Bird is flying with wings")
    }
}

fun main() {
    val dog = Dog()
    dog.makeSound()  // Woof! Woof!
    dog.move()       // Dog is running on four legs
    dog.sleep()      // Canine is sleeping
    
    val bird = Bird()
    bird.makeSound() // Tweet! Tweet!
    bird.move()      // Bird is flying with wings
}

Abstract Classes with Constructors

abstract class Vehicle(val brand: String, val model: String) {
    // Abstract properties
    abstract val maxSpeed: Int
    abstract val fuelType: String
    
    // Concrete method
    fun displayInfo() {
        println("$brand $model - Max Speed: ${maxSpeed}km/h, Fuel: $fuelType")
    }
    
    // Abstract method
    abstract fun start()
    abstract fun stop()
}

class Car(
    brand: String, 
    model: String, 
    override val maxSpeed: Int,
    override val fuelType: String = "Gasoline"
) : Vehicle(brand, model) {
    
    override fun start() {
        println("$brand $model engine started")
    }
    
    override fun stop() {
        println("$brand $model engine stopped")
    }
}

class ElectricCar(
    brand: String, 
    model: String, 
    override val maxSpeed: Int,
    val batteryCapacity: Int
) : Vehicle(brand, model) {
    
    override val fuelType = "Electric"
    
    override fun start() {
        println("$brand $model electric motor activated")
    }
    
    override fun stop() {
        println("$brand $model electric motor deactivated")
    }
    
    fun chargeBattery() {
        println("Charging battery (${batteryCapacity}kWh capacity)")
    }
}

fun main() {
    val car = Car("Toyota", "Camry", 180)
    car.displayInfo()  // Toyota Camry - Max Speed: 180km/h, Fuel: Gasoline
    car.start()        // Toyota Camry engine started
    
    val tesla = ElectricCar("Tesla", "Model 3", 225, 75)
    tesla.displayInfo() // Tesla Model 3 - Max Speed: 225km/h, Fuel: Electric
    tesla.chargeBattery() // Charging battery (75kWh capacity)
}

Real-World Example: Payment Processing System

// Payment interface defining the contract
interface PaymentProcessor {
    val processingFee: Double
    
    fun processPayment(amount: Double): PaymentResult
    fun refund(transactionId: String, amount: Double): RefundResult
    
    // Default implementation for fee calculation
    fun calculateTotalAmount(amount: Double): Double {
        return amount + (amount * processingFee)
    }
}

// Additional interface for digital wallets
interface DigitalWallet {
    val walletBalance: Double
    fun checkBalance(): Double
    fun addFunds(amount: Double)
}

// Data classes for results
data class PaymentResult(val success: Boolean, val transactionId: String, val message: String)
data class RefundResult(val success: Boolean, val refundId: String, val message: String)

// Abstract base class for payment methods
abstract class PaymentMethod(val provider: String) {
    abstract fun validatePayment(amount: Double): Boolean
    
    protected fun generateTransactionId(): String {
        return "TXN_${System.currentTimeMillis()}"
    }
    
    protected fun log(message: String) {
        println("[$provider] $message")
    }
}

// Concrete implementation: Credit Card
class CreditCardProcessor(
    provider: String,
    private val cardNumber: String
) : PaymentMethod(provider), PaymentProcessor {
    
    override val processingFee = 0.029  // 2.9%
    
    override fun validatePayment(amount: Double): Boolean {
        return amount > 0 && cardNumber.length == 16
    }
    
    override fun processPayment(amount: Double): PaymentResult {
        if (!validatePayment(amount)) {
            return PaymentResult(false, "", "Invalid payment details")
        }
        
        val transactionId = generateTransactionId()
        val totalAmount = calculateTotalAmount(amount)
        
        log("Processing credit card payment: $${totalAmount}")
        
        // Simulate payment processing
        return PaymentResult(true, transactionId, "Payment successful")
    }
    
    override fun refund(transactionId: String, amount: Double): RefundResult {
        log("Processing refund for transaction: $transactionId")
        return RefundResult(true, "REF_${System.currentTimeMillis()}", "Refund processed")
    }
}

// Digital wallet implementation
class PayPalProcessor : PaymentMethod("PayPal"), PaymentProcessor, DigitalWallet {
    
    override val processingFee = 0.034  // 3.4%
    private var _walletBalance = 1000.0
    
    override val walletBalance: Double
        get() = _walletBalance
    
    override fun validatePayment(amount: Double): Boolean {
        return amount > 0 && walletBalance >= calculateTotalAmount(amount)
    }
    
    override fun processPayment(amount: Double): PaymentResult {
        if (!validatePayment(amount)) {
            return PaymentResult(false, "", "Insufficient balance or invalid amount")
        }
        
        val totalAmount = calculateTotalAmount(amount)
        _walletBalance -= totalAmount
        val transactionId = generateTransactionId()
        
        log("PayPal payment processed: $${totalAmount}, Remaining balance: $${walletBalance}")
        
        return PaymentResult(true, transactionId, "PayPal payment successful")
    }
    
    override fun refund(transactionId: String, amount: Double): RefundResult {
        _walletBalance += amount
        log("Refund processed: $${amount}, New balance: $${walletBalance}")
        return RefundResult(true, "REF_${System.currentTimeMillis()}", "Refund added to wallet")
    }
    
    override fun checkBalance(): Double = walletBalance
    
    override fun addFunds(amount: Double) {
        _walletBalance += amount
        log("Added funds: $${amount}, New balance: $${walletBalance}")
    }
}

// Usage example
fun main() {
    val creditCard = CreditCardProcessor("Visa", "1234567890123456")
    val paypal = PayPalProcessor()
    
    // Process payments
    val ccResult = creditCard.processPayment(100.0)
    println("Credit Card: ${ccResult.message}")
    
    val ppResult = paypal.processPayment(50.0)
    println("PayPal: ${ppResult.message}")
    
    // Check wallet balance
    if (paypal is DigitalWallet) {
        println("PayPal balance: $${paypal.checkBalance()}")
    }
    
    // Process refund
    val refund = paypal.refund(ppResult.transactionId, 50.0)
    println("Refund: ${refund.message}")
}

Interface vs Abstract Class Guidelines

Common Pitfalls

• Diamond Problem: Be careful with multiple interface inheritance with conflicting default methods
• Interface Pollution: Keep interfaces focused and cohesive (Interface Segregation Principle)
• Over-abstraction: Don't create abstract classes if you only need a contract
• Property Conflicts: Be explicit when resolving property conflicts in multiple inheritance

Practice Exercises

1. Create a Sortable interface with a default quickSort() method
2. Design an abstract DatabaseConnection class with concrete and abstract methods
3. Implement a plugin system using interfaces for different plugin types
4. Create a notification system with multiple delivery methods (Email, SMS, Push)

Quick Quiz

1. What's the difference between an interface and an abstract class in Kotlin?
2. How do you resolve conflicts when implementing multiple interfaces with the same method signature?
3. Can an interface have properties with backing fields?