Amol Pawar

Type casting is a common operation in Kotlin, allowing developers to convert one type into another. Kotlin provides two main ways to perform type casts: as (unsafe casting) and as? (safe casting). Understanding the differences between these two is crucial for writing robust and error-free Kotlin code.

Understanding Type Casting in Kotlin

Before diving into safe vs. unsafe casting, let’s briefly review how type casting works in Kotlin.

Kotlin uses type casting to convert an object from one type to another. The two primary casting operators are:

• as (Unsafe Cast): Forces a cast and throws a ClassCastException if the cast fails.
• as? (Safe Cast): Returns null if the cast is not possible, preventing runtime exceptions.

Let’s explore both in detail.

Unsafe Casting Using as

Unsafe casting with as is straightforward but risky. If the object cannot be cast to the desired type, a ClassCastException occurs.

fun main() {
    val obj: Any = "Hello, Kotlin!"
    val str: String = obj as String // Successful cast
    println(str)
}

This works fine because obj is indeed a String. However, let’s see what happens when the type does not match:

fun main() {
    val obj: Any = 42
    val str: String = obj as String // Throws ClassCastException
    println(str)
}

Output:

Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

Here, obj is an Int, and forcing it into a String type results in a crash. This is where safe casting (as?) is useful.

Safe Casting Using as?

The safe cast operator as? prevents runtime exceptions by returning null if the cast is not possible.

fun main() {
    val obj: Any = 42
    val str: String? = obj as? String // Returns null instead of throwing an exception
    println(str) // Output: null
}

Using as?, we avoid the crash because instead of forcing an invalid cast, it simply assigns null to str.

When to Use as? Instead of as

When Type is Uncertain

• If you’re dealing with dynamic or uncertain types, always prefer as? to avoid crashes.

fun safeCastExample(value: Any) {
    val number: Int? = value as? Int
    println(number ?: "Not an Int")
}

fun main() {
    safeCastExample(100)   // Output: 100
    safeCastExample("Kotlin") // Output: Not an Int
}

When Handling Nullable Types

• Since as? returns null on failure, it works well with nullable types.

fun main() {
    val obj: Any = "Kotlin"
    val str: String? = obj as? String // No crash, just null if not castable
    println(str ?: "Cast failed")
}

To Avoid ClassCastException

• Using as? ensures the program does not terminate due to a casting error.

When to Use as

Although unsafe, as is still useful when you’re certain of the type.

fun main() {
    val text: Any = "Safe Casting"
    val str: String = text as String // Works because the type matches
    println(str)
}

Using as is fine in cases where you control the input type and are confident about the cast.

Conclusion

Type casts in Kotlin play an essential role in handling object types. However, using as carelessly can lead to runtime crashes. To ensure safer code, always prefer as? when the type is uncertain. This approach avoids ClassCastException and makes your Kotlin applications more robust and error-free.

Generics are a fundamental concept in Kotlin that helps make code more flexible, reusable, and type-safe. If you’ve ever wondered how Kotlin allows functions and classes to operate on different data types while maintaining type safety, you’re in the right place. In this article, we’ll explore Generic Type Parameters in Kotlin in a simple and approachable way.

What Are Generic Type Parameters?

Generic type parameters allow you to write code that can work with different types while enforcing compile-time type safety. Instead of specifying a fixed type, you define a placeholder (like T), which can represent any type the user provides.

For example, without generics, you’d need multiple implementations of the same function for different types:

fun printInt(value: Int) {
    println(value)
}

fun printString(value: String) {
    println(value)
}

With generics, you can write a single function:

fun <T> printValue(value: T) {
    println(value)
}

Now, printValue can accept any type while still ensuring type safety!

Declaring Generic Classes

Generics shine when defining reusable classes. Let’s take a simple example of a generic class:

class Box<T>(private val item: T) {
    fun getItem(): T {
        return item
    }
}

Here, T is a type parameter that can be replaced with any type at the time of object creation:

val intBox = Box(10)
val stringBox = Box("Hello, Kotlin!")

println(intBox.getItem()) // Output: 10
println(stringBox.getItem()) // Output: Hello, Kotlin!

This approach makes our Box class more versatile and eliminates the need for multiple implementations.

Bounded Type Parameters

Sometimes, you may want to restrict the type that can be used as a generic parameter. Kotlin allows you to specify upper bounds using :, ensuring that only subtypes of a specified class/interface can be used.

For example, let’s create a function that works only with numbers:

fun <T : Number> doubleValue(value: T): Double {
    return value.toDouble() * 2
}

Now, calling doubleValue with an Int, Double, or Float works, but passing a String results in a compilation error:

println(doubleValue(5)) // Output: 10.0
println(doubleValue(3.5)) // Output: 7.0
// println(doubleValue("Hello")) // Compilation Error!

This ensures that our function is used correctly while retaining the benefits of generics.

Variance in Kotlin Generics

Variance determines how generics behave with subtype relationships. Kotlin provides two keywords: out and in to handle variance properly.

Covariance (out)

When you declare out T, it means the type parameter is only produced (returned) and not consumed (accepted as a function parameter). This is useful for read-only data structures like List<T>.

interface Producer<out T> {
    fun produce(): T
}

Since T is only returned, we can safely use out to allow subtype assignment:

val stringProducer: Producer<String> = object : Producer<String> {
    override fun produce() = "Hello"
}

val anyProducer: Producer<Any> = stringProducer // Allowed because of 'out'

println(anyProducer.produce())  // O/P - Hello

Contravariance (in)

Conversely, in T means the type parameter is only consumed (accepted as a function parameter) and never produced. This is useful for function parameters.

interface Consumer<in T> {
    fun consume(item: T)
}

Since T is only an input, we can safely use in to allow supertype assignment:

val anyConsumer: Consumer<Any> = object : Consumer<Any> {
    override fun consume(item: Any) {
        println("Consumed: $item")
    }
}

val stringConsumer: Consumer<String> = anyConsumer // Allowed because of 'in'
 
println(stringConsumer.consume("Hello"))   // O/P - Consumed: Hello

Understanding variance prevents type mismatches and allows for better design patterns when working with generics.

Reified Type Parameters in Inline Functions

Kotlin has a limitation where type parameters are erased at runtime (type erasure). However, using reified type parameters in inline functions allows you to access the actual type at runtime.

inline fun <reified T> isTypeMatch(value: Any): Boolean {
    return value is T
}

println(isTypeMatch<String>("Kotlin")) // Output: true
println(isTypeMatch<Int>("Kotlin")) // Output: false

This is especially useful when working with reflection, type-checking, or factory methods.

Conclusion

Understanding Generic Type Parameters in Kotlin is key to writing flexible and type-safe code. By using generics, you can create reusable functions and classes while ensuring compile-time safety. Whether it’s defining generic classes, enforcing type constraints, or handling variance, generics make Kotlin a powerful and expressive language.

Kotlin makes object-oriented programming simple and powerful with its inheritance system. If you’re coming from Java or another OOP language, understanding Kotlin inheritance will help you write smarter, reusable code with fewer lines and more efficiency.

In this guide, we’ll break down Kotlin inheritance step by step, making it easy to grasp and apply in real-world scenarios.

What Is Kotlin Inheritance?

Inheritance is a fundamental concept in object-oriented programming (OOP). It allows a class to acquire the properties and behaviors of another class, reducing code duplication and improving maintainability.

In Kotlin, inheritance works by creating a base class (parent class) and allowing other classes (child classes) to derive from it.

By default, all Kotlin classes are final (cannot be inherited). To make a class inheritable, you must explicitly use the open keyword.

// Parent class
open class Animal {
    fun eat() {
        println("This animal is eating")
    }
}

// Child class inheriting from Animal
class Dog : Animal() {
    fun bark() {
        println("The dog is barking")
    }
}
fun main() {
    val myDog = Dog()
    myDog.eat() // Inherited method
    myDog.bark() // Child class method
}

Here,

• The Animal class is open, making it inheritable.
• The Dog class extends Animal using the : symbol.
• The Dog class gets access to the eat() function from Animal.
• The bark() function is specific to Dog.

Primary Constructor in Kotlin Inheritance

When a child class inherits from a parent class that has a constructor, it must initialize it. Here’s how it works:

open class Animal(val name: String) {
    fun eat() {
        println("$name is eating")
    }
}

class Dog(name: String) : Animal(name) {
    fun bark() {
        println("$name is barking")
    }
}
fun main() {
    val myDog = Dog("Buddy")
    myDog.eat()
    myDog.bark()
}

What’s Happening Here?

• The Animal class has a primary constructor with a name parameter.
• The Dog class calls the Animal constructor using : Animal(name).
• When we create a Dog object, we pass a name that is used in both eat() and bark().

Overriding Methods in Kotlin

Kotlin allows child classes to modify or override methods from the parent class using the override keyword.

open class Animal {
    open fun makeSound() {
        println("Animal makes a sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("Dog barks")
    }
}
fun main() {
    val myDog = Dog()
    myDog.makeSound()
}

Here,

• The makeSound() function in Animal is open, allowing it to be overridden.
• Dog provides its own implementation using override.
• Now, when makeSound() is called on Dog, it prints “Dog barks” instead of “Animal makes a sound”.

If we remove open from the method but keep the class open, will it affect our code? Yes, we will get the following compile-time error:

'makeSound' in 'Animal' is final and cannot be overridden.

Using Superclass Methods

Sometimes, you want to modify a method but still call the original method from the parent class. You can do this using super.

open class Animal {
    open fun makeSound() {
        println("Animal makes a sound")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        super.makeSound()
        println("Dog barks")
    }
}
fun main() {
    val myDog = Dog()
    myDog.makeSound()
}

Here, super.makeSound() calls the parent class method before executing the child class implementation.

Abstract Classes in Kotlin Inheritance

An abstract class cannot be instantiated and may contain abstract methods that must be implemented by child classes.

abstract class Animal {
    abstract fun makeSound()
}

class Dog : Animal() {
    override fun makeSound() {
        println("Dog barks")
    }
}
fun main() {
    val myDog = Dog()
    myDog.makeSound()
}

Why Use Abstract Classes?

• They define a template for subclasses.
• They ensure that all child classes implement necessary methods.

Interfaces vs. Inheritance in Kotlin

Kotlin also supports interfaces, which are similar to abstract classes but allow multiple implementations.

interface Animal {
    fun makeSound()
}

class Dog : Animal {
    override fun makeSound() {
        println("Dog barks")
    }
}
fun main() {
    val myDog = Dog()
    myDog.makeSound()
}

Key Differences:

• A class can inherit only one superclass but implement multiple interfaces.
• Interfaces cannot store state (i.e., no instance variables), while abstract classes can.

Conclusion

Kotlin inheritance is a powerful feature that helps you write smarter, reusable code. By using open classes, overriding methods, abstract classes, and interfaces, you can structure your code efficiently.

Here’s a quick recap:

• Use open to make a class inheritable.
• Override methods with override.
• Use super to call the parent method.
• Use abstract for mandatory implementations.

By mastering Kotlin inheritance, you can build scalable, maintainable, and clean applications.