Kotlin OOP

Welcome to The Coding College, your go-to resource for programming knowledge. In this article, we’ll dive into Object-Oriented Programming (OOP) in Kotlin, which enables developers to structure programs efficiently by modeling real-world entities.

What is OOP in Kotlin?

Object-Oriented Programming (OOP) is a paradigm that organizes code using objects, classes, and their interactions. Kotlin fully supports OOP principles, making it easy to build scalable, maintainable, and reusable applications.

The key principles of OOP are:

  • Encapsulation
  • Inheritance
  • Polymorphism
  • Abstraction

OOP Terminology in Kotlin

1. Class

A blueprint for creating objects.

2. Object

An instance of a class.

3. Property

A variable within a class.

4. Method

A function within a class.

Defining a Class

Here’s how to define a basic class in Kotlin:

class Person(val name: String, var age: Int) {
    fun greet() {
        println("Hello, my name is $name, and I am $age years old.")
    }
}

fun main() {
    val person = Person("Naman", 24)
    person.greet()
}
// Output: Hello, my name is Naman, and I am 24 years old.

Constructors in Kotlin

Kotlin classes can have primary and secondary constructors.

Primary Constructor

Defined as part of the class header.
Example:

class Car(val brand: String, val model: String, val year: Int)

fun main() {
    val car = Car("Tesla", "Model S", 2024)
    println("Car: ${car.brand} ${car.model} (${car.year})")
}
// Output: Car: Tesla Model S (2024)

Secondary Constructor

Allows additional initialization logic.
Example:

class Book {
    var title: String
    var author: String

    constructor(title: String, author: String) {
        this.title = title
        this.author = author
    }
}

fun main() {
    val book = Book("Kotlin for Beginners", "The Coding College")
    println("Book: ${book.title} by ${book.author}")
}
// Output: Book: Kotlin for Beginners by The Coding College

Encapsulation

Encapsulation restricts access to certain class members. Use visibility modifiers in Kotlin:

  • private
  • protected
  • public (default)
  • internal

Example:

class BankAccount(private var balance: Double) {
    fun deposit(amount: Double) {
        if (amount > 0) balance += amount
    }

    fun getBalance(): Double {
        return balance
    }
}

fun main() {
    val account = BankAccount(1000.0)
    account.deposit(500.0)
    println("Balance: ${account.getBalance()}")
}
// Output: Balance: 1500.0

Inheritance

Kotlin supports inheritance using the open keyword for parent classes.

Example:

open class Animal(val name: String) {
    open fun sound() {
        println("$name makes a sound")
    }
}

class Dog(name: String) : Animal(name) {
    override fun sound() {
        println("$name barks")
    }
}

fun main() {
    val dog = Dog("Buddy")
    dog.sound()
}
// Output: Buddy barks

Polymorphism

Polymorphism allows methods to behave differently based on the object calling them.

Example:

open class Shape {
    open fun draw() {
        println("Drawing a shape")
    }
}

class Circle : Shape() {
    override fun draw() {
        println("Drawing a circle")
    }
}

fun main() {
    val shape: Shape = Circle()
    shape.draw()
}
// Output: Drawing a circle

Abstraction

Abstraction is achieved using abstract classes or interfaces.

Abstract Class

Example:

abstract class Vehicle {
    abstract fun drive()
}

class Car : Vehicle() {
    override fun drive() {
        println("Driving a car")
    }
}

fun main() {
    val car = Car()
    car.drive()
}
// Output: Driving a car

Interface

Example:

interface Flyable {
    fun fly()
}

class Plane : Flyable {
    override fun fly() {
        println("Flying a plane")
    }
}

fun main() {
    val plane = Plane()
    plane.fly()
}
// Output: Flying a plane

Why Learn Kotlin OOP with The Coding College?

At The Coding College, we simplify complex concepts like Kotlin OOP with practical examples and real-world scenarios. Our tutorials are designed to help you write better, more efficient Kotlin code while adhering to best practices.

Conclusion

Understanding OOP in Kotlin is crucial for building scalable, maintainable applications. By mastering classes, objects, inheritance, polymorphism, and abstraction, you can unlock the full potential of Kotlin for your projects.

Leave a Comment