Understanding Abstraction in Kotlin | CodeSignal Learn

Understanding Abstraction in Kotlin | CodeSignal Learn

Welcome to Abstraction

Welcome back! Previously, you delved into polymorphism and learned how to create more flexible code structures using classes and inheritance. In this session, we will take a step further and explore a crucial aspect of Object-Oriented Programming: Abstraction .

Understanding Abstract Classes and Abstract Methods

Abstract classes and abstract methods are essential tools for achieving abstraction. They allow you to define a common interface for a group of derived classes, ensuring that specific methods are implemented. This approach helps you write more robust and scalable programs.

1. Defining an Abstract Class

Let's revisit some of the key concepts through the following code example: Kotlin // Define an abstract class Shape. Note that the abstractness is achieved by having at least one abstract method. abstract class Shape(private val color: String) {// Abstract methods for calculating the area and perimeter abstract fun area(): Double abstract fun perimeter(): Double // Concrete method to get the color fun getColor(): String {return color}} In this snippet, we define an abstract class Shape with a property color and a concrete method getColor to retrieve the color. The class also contains two abstract methods: area and perimeter . An abstract class can have properties and fully defined methods, but it must contain at least one abstract method, making it impossible to instantiate directly.

2. Implementing the Abstract Methods in Derived Classes

Next, we create concrete classes that extend the abstract class Shape . Circle Class Kotlin // Define a Circle class that inherits from Shape class Circle(private val radius: Double, color: String) : Shape(color) {// Implement the area and perimeter methods override fun area(): Double {return Math.PI * radius * radius} override fun perimeter(): Double {return 2 * Math.PI * radius}} Here, the Circle class inherits from Shape and provides concrete implementations for the abstract methods area and perimeter . It also includes a primary constructor to initialize the radius and color.

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Rectangle Class

Let's look at one more example. // Define a Rectangle class that inherits from Shape class Rectangle(private val width: Double, private val height: Double, color: String) : Shape(color) {// Implement the area and perimeter methods override fun area(): Double {return width * height} override fun perimeter(): Double {return 2 * (width + height)}} Similarly, the Rectangle class inherits from Shape and implements the necessary methods area and perimeter . It also includes a constructor to initialize the width, height, and color, ensuring that all necessary attributes are properly initialized.

Kotlin

// Define a Rectangle class that inherits from Shape
class Rectangle(private val width: Double, private val height: Double, color: String) : Shape(color) {

    // Implement the area and perimeter methods
    override fun area(): Double {
        return width * height
    }

    override fun perimeter(): Double {
        return 2 * (width + height)
    }
}

Finally, let's see how we can use these classes in a main function:

Kotlin

fun main() {
    val circle = Circle(5.0, "Red")
    val rectangle = Rectangle(4.0, 6.0, "Blue")

    println("Circle Area: ${circle.area()}, Perimeter: ${circle.perimeter()}, Color: ${circle.getColor()}")
    println("Rectangle Area: ${rectangle.area()}, Perimeter: ${rectangle.perimeter()}, Color: ${rectangle.getColor()}")

    // Using a Shape reference to a Circle object
    val shape: Shape = Circle(3.0, "Green")
    println("Shape Area: ${shape.area()}, Perimeter: ${shape.perimeter()}, Color: ${shape.getColor()}")

    // Uncommenting the following line will cause an error as you can't instantiate an abstract class
    // val invalidShape = Shape("Yellow")
}

By running the main function, you can see how the Circle and Rectangle classes correctly implement the area and perimeter methods defined in the Shape abstract class, while also utilizing the getColor method. The example also demonstrates polymorphism by using a Shape reference to a Circle object.

It's important to note that attempting to instantiate an abstract class directly, as shown by the commented-out line, will result in a compilation error. This reinforces the concept that abstract classes are meant to be subclassed, not instantiated.