Spice Up Android Apps: How Kotlin’s ‘Flavorful’ Features Transform Development

The WeChat Subscription Assistant Android app project was the first large‑scale use of Kotlin (483 .kt files, about 38 000 lines of code). After a few days of forced adoption, the author reflects on Kotlin’s unique flavor.

Preparation

Android – the main platform (framework, APIs, etc.)

Kotlin – the primary language, offering extension functions, overloads, and lambdas

Java – a small amount, used only as a bridge for Kotlin

IDE: Android Studio or Eclipse

Libraries: Kotlin Android Extensions, Android KTX, AndroidX, Anko

Reference URLs:

https://developers.google.com/android

https://kotlinlang.org/docs/reference

https://www.oracle.com/java

Cooking Process

Start with a little oil.

Add Android components first.

Introduce a small amount of Java (bytecode and tooling).

Lay the Kotlin code pieces over Android, covering it.

Simmer for 3–5 minutes, observing the transformation.

Kotlin gradually releases Android’s flavor, resulting in a richer aroma than Android + Java alone.

Kotlin and Java blend; too much Java weakens the cohesion and may cause NPEs.

Turn off the heat and let it rest.

Key Flavors

Safety (Null‑Safety)

Kotlin enforces null‑safety at compile time, preventing many runtime crashes.

var output: String
output = null   // Compilation error

val name: String? = null   // Nullable type
println(name.length())      // Compilation error

This example, from the official documentation, shows how mismatched nullability stops compilation, raising the overall safety of the codebase.

Freshness (Extension Functions)

Extension functions let you add utilities directly to existing classes, avoiding the need to remember separate utility class names.

fun String.toIntSafely(defaultValue: Int = 0): Int {
    return try {
        this.toInt()
    } catch (e: Exception) {
        defaultValue
    }
}

fun main(args: Array<String>) {
    println("1".toIntSafely())
}

In Java the same logic would require a static method in a utility class:

public final class StringUtil {
    private StringUtil() {}
    public static int stringToInt(String string, int defaultValue) {
        // implementation omitted
    }
}

StringUtil.stringToInt("1", 0);

No need to remember utility class names; developers can call myString.toIntSafely() directly.

The function’s belonging to String makes its purpose obvious.

Defining such extensions requires careful consideration of where they belong.

Aroma (Overloads)

Kotlin’s default arguments provide a compact way to achieve multiple overloads.

fun showDialog(title: String = "标题", message: String = "内容") {
    // TODO
}

This single definition covers four possible calls:

showDialog()
showDialog("新标题")
showDialog(message = "新内容")
showDialog("新标题", "新内容")

The result is cleaner code and fewer overload methods.

Sweetness (Functions & Lambdas)

Kotlin treats functions and lambdas as first‑class citizens, allowing concise syntax.

fun f(x: Int): Any {
    return Any()
}
val y = f(1)

fun f() = { x: Int -> Any() }
val y = f()(1)

val f = { x: Int -> Any() }
val y = f(1)

Lambdas reduce the need for many callback interfaces, simplifying asynchronous code.

Understanding Lambdas

From a mathematical perspective, a lambda { x: Int -> x + 1 } represents a function y = f(x). Kotlin lets you pass such functions as parameters and return them, enabling higher‑order programming.

fun f(x: (Int) -> Int): (Int) -> Int {
    return { it -> x(it) }
}
val result = f { it + 10 }(1) // result == 11

How to Deepen Your Kotlin Knowledge

Since Kotlin compiles to JVM bytecode, decompiling the generated .class files with Android Studio’s tools helps understand the underlying mechanics.

Conclusion

The author hopes readers will enjoy the “flavors” Kotlin brings to Android development.

References

https://kotlinlang.org