Abstract Classes And Interfaces | Classes And Objects

Introduction

In Kotlin, abstract classes and interfaces are powerful tools for defining contracts and behaviors that can be shared among various classes. They play a crucial role in object-oriented programming by enabling polymorphism and code reusability.

Abstract Classes

An abstract class is a class that cannot be instantiated on its own and is meant to be subclassed. It can contain both abstract methods (which have no body) and concrete methods (which have an implementation). Abstract classes are useful when you want to define a base class that provides some common functionality while allowing derived classes to implement specific behaviors.

Defining an Abstract Class

You define an abstract class in Kotlin using the abstract keyword. Here’s an example:

abstract class Animal {
  abstract fun sound(): String
  fun eat() {
    println("This animal is eating.")
  }
}

Subclassing an Abstract Class

To create a subclass, you extend the abstract class and provide implementations for its abstract methods:

class Dog : Animal() {
  override fun sound(): String {
    return "Woof!"
  }
}

Using the Abstract Class

You can now create an instance of the Dog class and use its methods:

fun main() {
  val dog = Dog()
  println(dog.sound()) // Output: Woof!
  dog.eat() // Output: This animal is eating.
}

Interfaces

An interface in Kotlin is a contract that classes can implement. It can contain abstract methods and properties, but unlike abstract classes, interfaces cannot provide any implementation for the methods (prior to Kotlin 1.2, though you can provide default implementations in the interface itself).

Defining an Interface

You define an interface using the interface keyword. Here’s an example:

interface Vehicle {
fun drive(): String
}

Implementing an Interface

A class implements an interface using the : symbol. Here’s how to implement the Vehicle interface:

class Car : Vehicle {
  override fun drive(): String {
    return "Car is driving."
  }
}

Using the Interface

Once the interface is implemented, you can create an instance of the class and use the methods defined in the interface:

fun main() {
val car = Car()
println(car.drive()) // Output: Car is driving.
}

Differences Between Abstract Classes and Interfaces

While both abstract classes and interfaces are used to define a common structure, there are key differences:

Instantiation: Abstract classes cannot be instantiated directly, while interfaces cannot be instantiated at all.
Multiple Inheritance: A class can implement multiple interfaces but can extend only one abstract class.
Method Implementation: Abstract classes can have method implementations, while interfaces can provide default implementations starting from Kotlin 1.2.

Conclusion

Abstract classes and interfaces are essential components of Kotlin programming that promote code reusability and the design of flexible systems. Understanding when to use each can greatly enhance the maintainability and scalability of your applications.

Abstract Classes and Interfaces in Kotlin

Introduction