Amol Pawar

In Effective Java by Joshua Bloch (Addison-Wesley, 2008), one of the best-known books on good Java programming style, recommends that you “design and document for inheritance or else prohibit it.” This means all classes and methods that aren’t specifically intended to be overridden in subclasses ought to be explicitly marked as final. Kotlin follows the same philosophy. Whereas Java’s classes and methods are open by default, Kotlin’s are final by default.

Kotlin Open Keyword

Kotlin’s “design and document for inheritance or else prohibit it” philosophy is aimed at making code more robust and less error-prone. By default, classes and methods in Kotlin are final and cannot be inherited or overridden, which means that developers must explicitly declare a class or method as open in order to allow inheritance or overriding.

This approach differs from Java, where classes and methods are open by default, and must be explicitly marked as final to prohibit inheritance or overriding. While this default openness in Java allows for greater flexibility and extensibility, it can also lead to potential errors and security vulnerabilities if classes or methods are unintentionally overridden or inherited.

Kotlin’s approach is designed to encourage developers to carefully consider whether inheritance or overriding is necessary for a given class or method, and to document their intentions clearly. This can help prevent unintentional errors and make code more maintainable over time.

That being said, Kotlin recognizes that there are cases where inheritance and overriding are necessary or desirable. This is why the open keyword exists – to explicitly allow for classes and methods to be inherited or overridden when needed. By requiring developers to explicitly declare a class or method as open, Kotlin ensures that these features are used deliberately and with intention.

So, in summary, Kotlin’s approach to inheritance and overriding is designed to encourage careful consideration and documentation, while still allowing for these features when needed. The open keyword provides a way to explicitly allow for inheritance and overriding, while still maintaining Kotlin’s default “design and document for inheritance or else prohibit it” philosophy.

I hope this helps clarify why Kotlin chose to introduce the open keyword, despite its overall philosophy of limiting inheritance and overriding by default!

Kotlin is a modern, concise and powerful programming language that has gained a lot of popularity among developers in recent years. One of the features that makes Kotlin stand out is its powerful when expression, which is a more expressive version of the traditional switch statement in Java. In this article, we will dive deep into the power of when expressions in Kotlin.

Syntax of When Expressions in Kotlin

The syntax of the when expression is straightforward and intuitive. It consists of a keyword “when”, followed by a variable or expression in parentheses, and then a series of cases separated by commas. Each case is defined by a value or a range of values, followed by the arrow operator (->) and the block of code to execute. Finally, there is an optional else block, which executes when none of the cases match.

when (variable) {<br>    case1Value -> {<br>        // Code to execute when case1Value matches the variable<br>    }<br>    case2Value, case3Value -> {<br>        // Code to execute when case2Value or case3Value matches the variable<br>    }<br>    in case4Value..case6Value -> {<br>        // Code to execute when the variable is in the range from case4Value to case6Value<br>    }<br>    else -> {<br>        // Code to execute when none of the above cases match<br>    }<br>}

Examples

Here are some simple examples that demonstrate the power of when expressions in Kotlin:

Matching on Types:

When expressions in kotlin can be used to match on types of objects. For example, the following code matches on a variable x and executes different blocks of code depending on whether x is an Int, a String, or a Boolean:

when (x) {
    is Int -> {
        // Code to execute when x is an integer
    }
    is String -> {
        // Code to execute when x is a string
    }
    is Boolean -> {
        // Code to execute when x is a boolean
    }
    else -> {
        // Code to execute when x is none of the above types
    }
}

Matching on Values:

When expressions in kotlin can also be used to match on specific values. For example, the following code matches on a variable x and executes different blocks of code depending on whether x is 1, 2, 3 or none of the above:

when (x) {
    1 -> {
        // Code to execute when x is 1
    }
    2 -> {
        // Code to execute when x is 2
    }
    3 -> {
        // Code to execute when x is 3
    }
    else -> {
        // Code to execute when x is none of the above values
    }
}

Matching on Ranges:

When expressions in kotlin can also match on ranges of values. For example, the following code matches on a variable x and executes a block of code if x is in the range from 1 to 10:

when (x) {
    in 1..10 -> {
        // Code to execute when x is in the range from 1 to 10
    }
    else -> {
        // Code to execute when x is not in the range from 1 to 10
    }
}

Multiple Conditions:

When expressions in kotlin can match on multiple conditions. For example, the following code matches on a variable x and executes a block of code if x is greater than 10 and less than 20:

when (x) {
    in 11..19 -> {
        // Code to execute when x is in the range from 11 to 19
    }
    else -> {
        // Code to execute when x is not in the range from 11 to 19
    }
}

Smart Casting:

When expressions in kotlin can be used to cast an object to a specific type. For example, the following code matches on a variable x and casts it to an Int if possible, then executes a block of code that uses the casted Int:

when (x) {
    is String -> {
        val length = x.length
        // Code to execute using the length of the string
    }
    is Int -> {
        val value = x
        // Code to execute using the integer value of x
    }
    else -> {
        // Code to execute when x is neither a String nor an Int
    }
}

Returning Values:

When expressions in kotlin can return values, which can be useful in functional programming. For example, the following code matches on a variable x and returns a corresponding value depending on whether x is 1, 2, or none of the above:

val result = when (x) {
    1 -> "One"
    2 -> "Two"
    else -> "Other"
}

It’s worth noting that when expressions in kotlin are often used in conjunction with other Kotlin features, such as enum, extension functions, lambdas, and sealed classes, to provide even more powerful and expressive code.

Now let’s see some cool ways to deal with other Kotlin features

Using “when” to deal with enum classes:

Kotlin’s “enum” class is a powerful and flexible way to represent a fixed set of values. When expressions in kotlin can be particularly useful for dealing with enum classes, as they can handle each value in a concise and readable way. For example:

enum class Color {
    RED, ORANGE, YELLOW, GREEN, BLUE, INDIGO, VIOLET
}

fun getColorName(color: Color) = when (color) {
    Color.RED -> "Red"
    Color.ORANGE -> "Orange"
    Color.YELLOW -> "Yellow"
    Color.GREEN -> "Green"
    Color.BLUE -> "Blue"
    Color.INDIGO -> "Indigo"
    Color.VIOLET -> "Violet"
}

Here, the “when” expression takes in a value of type “Color” and matches each possible value of the enum with a corresponding string. This makes the code more concise and easier to read than a series of “if-else” statements.

Using “when” with arbitrary objects:

In addition to using “when” expressions with enum classes, Kotlin also allows developers to use “when” with arbitrary objects. This can be useful for handling multiple types of objects in a concise and readable way. For example:

fun describeObject(obj: Any): String = when (obj) {
    is String -> "String with length ${obj.length}"
    is Int -> "Integer with value $obj"
    is Long -> "Long integer with value $obj"
    else -> "Unknown object"
}

Here, the “when” expression takes in an arbitrary object of type “Any” and matches it against each possible type using “is” checks. This allows the function to provide a concise and readable description of any object that is passed in.

Using “When” with extension functions:

Kotlin also allows developers to use “when” with extention functions in Kotlin, Here’s an example:

fun Int.isEven(): Boolean = this % 2 == 0

fun Int.isOdd(): Boolean = this % 2 == 1

fun Int.classify(): String {
    return when {
        this.isEven() -> "Even"
        this.isOdd() -> "Odd"
        else -> "Unknown"
    }
}

fun main() {
    println(2.classify())  // Output: Even
    println(3.classify())  // Output: Odd
    println(4.classify())  // Output: Even
    println(5.classify())  // Output: Odd
}

In this example, we define two extension functions called isEven and isOdd that can be called on integer values. We then define another extension function called classify that uses a “when” expression to classify integer values as “Even”, “Odd”, or “Unknown”. The “when” expression is called on the integer value using the this keyword.

Using “When” with Sealed Classes

Using “when” expressions with sealed classes is a powerful feature in Kotlin that allows for concise and type-safe pattern matching.

sealed class AppState {
    object Loading : AppState()
    data class Success(val data: List<Item>) : AppState()
    data class Error(val message: String) : AppState()
}

fun renderState(state: AppState) {
    when (state) {
        is AppState.Loading -> showLoadingScreen()
        is AppState.Success -> showItems(state.data)
        is AppState.Error -> showErrorScreen(state.message)
    }
}

// Usage:
val state = AppState.Loading
renderState(state)

val data = listOf(Item("Item 1"), Item("Item 2"))
val state = AppState.Success(data)
renderState(state)

val error = "An error occurred"
val state = AppState.Error(error)
renderState(state)

In this example, we define a sealed class called AppState, which represents the state of an app screen. It has three possible subclasses: Loading, Success, and Error. The Success subclass contains a list of Item objects, while the Error subclass contains an error message.

We then define a function called renderState that takes an AppState instance as a parameter and uses a “when” expression to pattern match on the possible subclasses. Depending on the subclass, it calls different functions to render the appropriate screen.

Using “when” expressions with sealed classes in this way allows for more readable and maintainable code, as the pattern matching is type-safe and localized to a single function. It also allows for easy extensibility of the AppState hierarchy, as new subclasses can be added to represent different states of the app screen.

Using “When” with Lambda

Here’s a simple example of using a “when” expression with a lambda in Kotlin to filter a list of numbers:

val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

val evenNumbers = numbers.filter { number ->
    when (number % 2) {
        0 -> true // The number is even, so include it in the filtered list
        else -> false // The number is odd, so exclude it from the filtered list
    }
}

println(evenNumbers) // Prints: [2, 4, 6, 8, 10]

In this example, we start with a list of numbers and use the “filter” function to create a new list that only includes the even numbers. We pass a lambda expression to the “filter” function, which takes each number in the list and applies the “when” expression to determine if it should be included in the filtered list.

The “when” expression checks if the number is divisible by 2 (i.e., if it’s even) and returns true if it is, and false if it’s not. This lambda expression is concise and easy to read, and demonstrates how “when” expressions can be used in practical scenarios to create more expressive and flexible code.

Pattern Matching: To Regex or Custom Type

Here’s an example of how “when” expressions can be used for pattern matching:

fun checkType(obj: Any) {
    when(obj) {
        is Int -> println("Integer: $obj")
        is String -> println("String: $obj")
        is List<*> -> println("List: $obj")
        else -> println("Unknown Type")
    }
}

fun main() {
    checkType(1)
    checkType("hello")
    checkType(listOf(1, 2, 3))
    checkType(1.0)
}

In this example, we define a function called checkType that takes an arbitrary object as its input and uses a “when” expression to perform pattern matching on the object. The expression checks whether the object is an integer, a string, or a list of any type of element, and then prints a message indicating the type of the object.

Note that “when” expressions are not limited to simple type checks, but can also be used for more complex pattern-matching scenarios involving regular expressions or custom types. However, this example demonstrates the basic pattern-matching functionality of “when” expressions.

Lets see couple of examples of how “when” expressions can be used for more complex pattern matching scenarios in Kotlin.

1. Matching against regular expressions:

val input = "Hello123"
val pattern = "d+".toRegex()

val result = when (input) {
    pattern.matches(input) -> "Input matches pattern"
    else -> "Input does not match pattern"
}

println(result)

In this example, we are using a “when” expression to match the input string against the regular expression pattern \\d+, which matches one or more digits. If the input matches the pattern, we print “Input matches pattern”. If it does not match the pattern, we print “Input does not match pattern”.

2. Matching against custom types:

sealed class Animal {
    object Dog : Animal()
    object Cat : Animal()
    object Fish : Animal()
}

fun describeAnimal(animal: Animal) = when (animal) {
    is Animal.Dog -> "This is a dog."
    is Animal.Cat -> "This is a cat."
    is Animal.Fish -> "This is a fish."
}

val myPet = Animal.Dog
println(describeAnimal(myPet))

In this example, we have a sealed class Animal with three objects: Dog, Cat, and Fish. We then define a function describeAnimal that takes in an Animal object and uses a “when” expression to match against the three possible cases of the sealed class. Depending on which case matches, the function returns a description of the animal.

Finally, we create an instance of Animal.Dog and pass it to describeAnimal, which prints “This is a dog.” to the console.

Smart casts: combining type checks and casts

You might have an idea about smart casts, as we saw in the previous smart casting example. In Kotlin, “smart casts” are a feature that allows developers to combine type checks and casts in a single operation. This can make code more concise and less error-prone. For example:

fun processString(str: Any) {
    if (str is String) {
        println(str.toUpperCase())
    }
}

Here, the “is” check ensures that the variable “str” is of type “String”, and the subsequent call to “toUpperCase()” can be made without casting “str” explicitly.

This same functionality can be achieved using a “when” expression, like so:

fun processString(str: Any) = when (str) {
    is String -> str.toUpperCase()
    else -> ""
}

Here, the “when” expression combines the “is” check and the call to “toUpperCase()” in a single operation. If the variable “str” is not a string, the expression returns an empty string.

Refactoring: replacing “if” with “when”:

Kotlin’s “when” expression can be a useful tool for refactoring existing “if-else” code. In many cases, “if-else” statements can be replaced with a “when” expression, which can make the code more concise and easier to read. For example:

fun getMessage(isValid: Boolean): String {
    return if (isValid) {
        "Valid"
    } else {
        "Invalid"
    }
}

This can be refactored into a “when” expression like so:

fun getMessage(isValid: Boolean): String = when (isValid) {
    true -> "Valid"
    false -> "Invalid"
}

Here, the “when” expression replaces the “if-else” statement, resulting in more concise and readable code.

Blocks as branches of “if” and “when”:

Kotlin’s “if” and “when” expressions can also be used to evaluate blocks of code, rather than just simple expressions. This can be useful for handling complex logic or multiple statements. For example:

fun evaluateGrade(score: Int): String = when {
    score < 60 -> {
        "Failing grade"
    }
    score < 70 -> {
        "D"
    }
    score < 80 -> {
        "C"
    }
    score < 90 -> {
        "B"
    }
    else -> {
        "A"
    }
}

Here, each branch of the “when” expression contains a block of code, allowing for more complex logic to be evaluated. This can make the code more readable and easier to maintain.

Real-world examples in Android Code

Let’s see some real-world examples of where when expressions in kotlin can be used in Android app code:

Handling different button clicks: In an app with multiple buttons, “when” expressions can be used to handle the click events for each button. For example:

button.setOnClickListener { view ->
    when (view.id) {
        R.id.button1 -> {
            // Handle button1 click event
        }
        R.id.button2 -> {
            // Handle button2 click event
        }
        // Handle other button click events
    }
}

Displaying different views: In a complex app with many different screens, “when” expressions can be used to display the appropriate view for each screen. For example:

when (screen) {
    Screen.Home -> {
        // Display the home screen view
    }
    Screen.Profile -> {
        // Display the profile screen view
    }
    // Handle other screen views
}

Handling different data types: In an app that deals with different data types, “when” expressions can be used to handle each data type appropriately. For example:

when (data) {
    is String -> {
        // Handle string data type
    }
    is Int -> {
        // Handle integer data type
    }
    // Handle other data types
}

Handling different API responses: In an app that communicates with an API, “when” expressions can be used to handle the different responses from the API. For example:

when (response) {
    is Success -> {
        // Handle successful API response
    }
    is Error -> {
        // Handle API error response
    }
    // Handle other API responses
}

When expression in Extention Function: Here’s an example of using “when” expressions with extension functions in an Android app:

fun TextView.setTextColorByStatus(status: String) {
    val colorRes = when (status) {
        "OK" -> R.color.green
        "WARNING" -> R.color.yellow
        "ERROR" -> R.color.red
        else -> R.color.black
    }
    this.setTextColor(ContextCompat.getColor(context, colorRes))
}

// usage:
textView.setTextColorByStatus("OK")

When expression in Lambda expression: Lambda expressions are often used in conjunction with “when” expressions in Android. Here’s an example:

val sharedPreferences = getSharedPreferences("MyPrefs", Context.MODE_PRIVATE)

val isDarkModeEnabled = sharedPreferences.getBoolean("isDarkModeEnabled", false)

val statusBarColor = when {
    isDarkModeEnabled -> Color.BLACK
    else -> Color.WHITE
}

window.statusBarColor = statusBarColor

Let’s see some benefits and limitations of “when” expressions in Kotlin:

Benefits:

1. Concise and expressive: “when” expressions can help make your code more concise and expressive, which can improve readability and maintainability.
2. More flexible than switch statements: “when” expressions are more flexible than traditional switch statements, as they can handle a wider range of conditions and types.
3. Smart casting: “when” expressions can be used to perform smart casting, which can help eliminate the need for explicit type casting in your code.
4. Works with enums and arbitrary objects: “when” expressions can be used with enums and arbitrary objects, which can help simplify your code.
5. Supports functional programming: “when” expressions can be used with lambda functions, which makes them well-suited to functional programming approaches.

Limitations:

1. Limited readability in complex scenarios: “when” expressions can become difficult to read and understand in more complex scenarios, especially when there are nested conditions or multiple actions associated with each condition.
2. No fall-through behavior: Unlike switch statements, “when” expressions do not support fall-through behavior. This means that you cannot execute multiple actions for a single condition without using additional code.
3. Limited to simple pattern matching: “when” expressions are limited to simple pattern matching, and cannot be used for more complex operations such as complex regular expressions.
4. Limited backward compatibility: “when” expressions were introduced in Kotlin 1.1 and are not available in earlier versions of the language.

In Kotlin, default parameters are a feature that allows developers to define default values for function parameters. This means that if a function is called with fewer arguments than expected, the default values will be used instead. Default parameters can help simplify function calls and reduce the amount of code you need to write.

Defining Default Parameters

To define default parameters in Kotlin, you simply specify a default value for a parameter in the function declaration. Here’s an example:

fun sayHello(name: String = "softAai") {
    println("Hello, $name!")
}

sayHello()      // prints "Hello, softAai!"
sayHello("amol") // prints "Hello, amol!"

In this example, the sayHello function has a default parameter name with a default value of \"softAai\". When called with no arguments, the function will print \”Hello, softAai!\”. When called with an argument, such as \"amol\", the function will print \”Hello, amol!\”.

Using Default Parameters in Functions

Default parameters can be useful when writing functions that have many optional parameters or when you want to provide a default value for a parameter that is commonly used. Here’s an example of a function that uses default parameters to simplify its signature:

fun sendResumeEmail(to: String, subject: String = "", body: String = "") {
    // send email with given parameters and attached resume 
}

sendResumeEmail("[email protected]")                     // sends resume email with empty subject and body
sendResumeEmail("[email protected]", "Resume")            // sends resume email with "Resume" as subject and empty body
sendResumeEmail("[email protected]", "Resume", "PFA!")  // sends resume email with "Resume" as subject and "PFA!" as body

In this example, the sendResumeEmail function has two optional parameters, subject and body, with default values of \"\". This allows the function to be called with just a to parameter, which will send an email with an empty subject and body, or with both subject and body parameters, which will send a resume email with the specified subject and body.

Using Default Parameters with Named Parameters

Default parameters can also be used with named parameters to make the function call more readable and self-documenting. Here’s an example:

fun calculateInterest(principal: Double, rate: Double = 0.05, years: Int = 1): Double {
    val interest = principal * rate * years
    return interest
}

val interest1 = calculateInterest(principal = 1000.0, rate = 0.06, years = 2)
val interest2 = calculateInterest(principal = 500.0, rate = 0.07)
val interest3 = calculateInterest(principal = 2000.0)

println("Interest 1: $interest1") // prints "Interest 1: 120.0"
println("Interest 2: $interest2") // prints "Interest 2: 17.5"
println("Interest 3: $interest3") // prints "Interest 3: 100.0"

In this example, the calculateInterest function has three parameters, principal, rate, and years, with default values of 0.05 and 1, respectively. By using named parameters, we can specify only the parameters we care about and use the default values for the others. This makes the function call more readable and reduces the amount of boilerplate code needed.

Using Default Parameters with Extension Functions

Default parameters can also be used with extension functions in Kotlin. When defining an extension function with default parameters, you can specify default values for any optional parameters. Here’s an example:

fun String.format(separator: String = ", ", prefix: String = "[", suffix: String = "]"): String {
    return "$prefix${this.split(",").joinToString(separator)}$suffix"
}

In this example, we define an extension function on the String class called format. The format function takes three optional parameters: separator, prefix, and suffix. Each parameter has a default value, making them optional. The format function splits the string by commas and joins the resulting list with the specified separator, prefix, and suffix.

Using Default Parameters with Java Interoperability

Default parameters can also be used with Java interoperability in Kotlin. When a Kotlin function with default parameters is called from Java code, the default values are automatically generated as overloaded methods. Here’s an example:

@JvmOverloads
fun greet(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

In this example, we use the @JvmOverloads annotation to tell the Kotlin compiler to generate overloaded methods for each combination of parameters, including the default parameters. This allows Java code to call the greet function with either one or two parameters, using the default value for the second parameter if it is not specified.

Using Default Parameters in Function Overloading

Default parameters can also be used in function overloading in Kotlin. When defining overloaded functions with default parameters, you can specify different default values for each function. Here’s an example:

fun multiply(x: Int, y: Int = 1) = x * y

fun multiply(x: Double, y: Double = 1.0) = x * y

In this example, we define two overloaded functions called multiply. The first function takes two integers and multiplies them together, with a default value of 1 for the second parameter. The second function takes two doubles and multiplies them together, with a default value of 1.0 for the second parameter. This allows callers to use either function with different types of parameters, while still providing default values for the optional parameters.

One more thing to note about default parameters in Kotlin is that they can only be defined for parameters that come after all non-default parameters. In other words, if a function has a mix of parameters with default and non-default values, the non-default parameters must come first in the parameter list, followed by the parameters with default values.

For example, this is a valid function with default parameters in Kotlin:

fun sayHello(name: String, greeting: String = "Hello") {
    println("$greeting, $name!")
}

In this example, the name parameter is a required parameter, while the greeting parameter has a default value of \”Hello\”. If we were to call the function without providing a value for greeting, the default value would be used:

sayHello("softAai") // Prints "Hello, softAai!"

However, if we were to define the function with the parameters in the opposite order, it would not be valid:

// This is not valid!
fun sayHello(greeting: String = "Hello", name: String) {
    println("$greeting, $name!")
}

This is because the greeting parameter with the default value comes before the required name parameter. Defining default parameters in this way would result in a compilation error.

So in Kotlin, when defining a function with default parameters, the parameters with default values must come after all the parameters without default values in the function declaration. If this order is not followed, the code will not compile and the Kotlin compiler will generate an error message. This is a design decision made in the Kotlin language to prevent potential errors and to ensure clarity and consistency in the way functions with default parameters are defined.

Benefits of default parameters in Kotlin:

1. Default parameters allow developers to define function parameters with default values, which can be used if a value is not provided by the caller. This can simplify function calls by reducing the number of parameters that need to be specified.
2. Default parameters can help improve code readability, as developers can define a function with fewer parameters, making it easier to read and understand.
3. Default parameters can also simplify function overloading, as developers can define multiple versions of a function with different default parameter values, reducing the need for separate functions with different parameter lists.
4. Default parameters can help improve code maintenance, as developers can change the default parameter values in a function without having to modify all the callers of that function.

Limitations of default parameters in Kotlin:

1. One of the limitations of default parameters is that they can only be defined for function parameters, not for properties or other types of variables.
2. Default parameters can also make it more difficult to understand the behavior of a function, as callers may not be aware of the default parameter values and may not explicitly provide all necessary parameters.
3. Default parameters can also lead to ambiguous function calls if there are multiple functions with similar parameter lists and default values.
4. Default parameters can also have a negative impact on performance if a function is called with default parameter values frequently, as the function may need to execute additional logic to handle the default values.

Overall, default parameters in Kotlin can provide benefits in terms of code readability, maintenance, and simplifying function calls, but they should be used carefully and with consideration for their limitations.