Abstract Class

In Kotlin, abstract classes are a powerful feature that allows developers to define a class with incomplete implementations. This means you can create a blueprint for other classes without providing full details. Abstract classes play a significant role in object-oriented programming, especially when designing systems that require a common interface for multiple implementations.

Why Abstract Classes Matter

Abstract classes are essential for several reasons:

• ✅ Code Reusability: They allow you to define methods and properties that can be shared across different subclasses, reducing code duplication.
• ✅ Enforcement of Structure: By using abstract methods, you ensure that all subclasses implement specific functionalities, maintaining a consistent structure.
• ✅ Flexibility: They enable you to create versatile and adaptable code, allowing for modifications without altering existing implementations.

You typically use abstract classes when you want to provide a base class that cannot be instantiated on its own, but can be extended by other classes that implement its abstract methods.

Concept Explanation

What Is an Abstract Class?

An abstract class is a class that cannot be instantiated directly; instead, it must be subclassed. An abstract class can contain both abstract methods (which do not have an implementation) and concrete methods (which do). This can be likened to a blueprint of a house: while the blueprint provides the essential layout and features, it cannot be inhabited until actual houses (subclasses) are built based on it.

Key Characteristics of Abstract Classes

• ✅ Cannot be instantiated: You cannot create an object of an abstract class.
• ✅ May contain abstract and concrete methods: Abstract methods are declared without an implementation, while concrete methods can have a body.
• ✅ Can have properties: Abstract classes can have properties that may or may not be overridden by subclasses.

Comparison with Interfaces

While both abstract classes and interfaces are used to achieve abstraction, they serve different purposes:

Syntax of Abstract Classes

Here’s how you define an abstract class in Kotlin:

abstract class Vehicle {
    abstract fun drive()
}

Explanation of the Syntax

• ✅ abstract class: This keyword is used to declare a class as abstract.
• ✅ Vehicle: The name of the abstract class.
• ✅ abstract fun drive: This declares an abstract method named drive, which must be implemented by any concrete subclass.

Working Examples

Example 1: Basic Abstract Class

In this example, we define an abstract class Animal with an abstract method makeSound.

abstract class Animal {
    abstract fun makeSound()
}

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

class Cat : Animal() {
    override fun makeSound() {
        println("Meow!")
    }
}

fun main() {
    val dog: Animal = Dog()
    dog.makeSound() // Output: Woof!
    
    val cat: Animal = Cat()
    cat.makeSound() // Output: Meow!
}

Output:

Woof!
Meow!

Example 2: Abstract Class with Concrete Methods

Here, we define an abstract class Appliance that includes a concrete method along with an abstract method.

abstract class Appliance {
    abstract fun turnOn()
    
    fun description() {
        println("This is an appliance.")
    }
}

class WashingMachine : Appliance() {
    override fun turnOn() {
        println("Washing machine is now on.")
    }
}

fun main() {
    val washer: Appliance = WashingMachine()
    washer.description() // Output: This is an appliance.
    washer.turnOn()      // Output: Washing machine is now on.
}

Output:

This is an appliance.
Washing machine is now on.

Example 3: Abstract Class with Properties

In this example, we create an abstract class Employee that has an abstract method and a concrete property.

abstract class Employee(val name: String) {
    abstract fun work()
    
    fun showDetails() {
        println("Employee Name: $name")
    }
}

class Developer(name: String) : Employee(name) {
    override fun work() {
        println("$name is coding.")
    }
}

fun main() {
    val dev: Employee = Developer("Alice")
    dev.showDetails() // Output: Employee Name: Alice
    dev.work()        // Output: Alice is coding.
}

Output:

Employee Name: Alice
Alice is coding.

Example 4: Real-World Scenario with Abstract Classes

Consider a banking system where different banks calculate interest differently.

abstract class Bank {
    abstract fun calculateInterest(principal: Double, rate: Double, time: Int): Double
}

class SBI : Bank() {
    override fun calculateInterest(principal: Double, rate: Double, time: Int): Double {
        return (principal * rate * time) / 100
    }
}

class PNB : Bank() {
    override fun calculateInterest(principal: Double, rate: Double, time: Int): Double {
        return (principal * (rate + 0.5) * time) / 100 // Slightly different calculation
    }
}

fun main() {
    val sbi: Bank = SBI()
    println("SBI Interest: ${sbi.calculateInterest(1000.0, 5.0, 3)}") // Output: SBI Interest: 150.0
    
    val pnb: Bank = PNB()
    println("PNB Interest: ${pnb.calculateInterest(1000.0, 4.5, 3)}") // Output: PNB Interest: 135.0
}

Output:

SBI Interest: 150.0
PNB Interest: 135.0

Common Mistakes

Mistake 1: Instantiating an Abstract Class

One common mistake is trying to create an instance of an abstract class directly. This will lead to a compilation error.

// Incorrect usage
val myVehicle = Vehicle() // Error: Cannot create an instance of an abstract class

Mistake 2: Forgetting to Override Abstract Methods

If a subclass does not provide an implementation for an abstract method, it will also need to be declared as abstract.

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

class Circle : Shape() {
    // Incorrect: Must override area()
}

// Correct:
class Circle : Shape() {
    override fun area(): Double {
        return Math.PI * 2 * 2 // Example for radius 2
    }
}

Best Practices

• ✅ Use meaningful names: Ensure that your abstract classes and methods convey their purpose clearly.
• ✅ Keep it simple: Avoid complex hierarchies of abstract classes. Prefer composition over inheritance when possible.
• ✅ Document your code: Use comments and documentation to explain the purpose of abstract methods and classes.

Practice Exercises

1. Create an Abstract Class for Vehicles: Design an abstract class called Vehicle with an abstract method drive. Implement subclasses for Car and Bike that override drive.
2. Banking System Extension: Extend the previous banking example by adding another bank, HDFC, that implements a different interest calculation method.
3. Shape Area Calculation: Create an abstract class Shape with an abstract method area. Implement this class with a Rectangle and a Triangle, and provide the area calculations.

By engaging with these exercises, you'll solidify your understanding of abstract classes and their role in designing robust, maintainable Kotlin applications. Happy coding!