Android Development with Kotlin (Marcin Moskala)（Z-Library）

# Android Development with Kotlin — Reading Guide ## 【One-Line Pitch】 A practical, example-driven guide for Java-experienced Android developers who want to leverage Kotlin's modern features—null safety, extensions, lambdas, and smart casts—to write cleaner, more concise, and more robust Android applications. ## 【Book Arc】 - **Opening (~0%–9%)**: Introduces Kotlin's value proposition for Android developers, showcasing "awesome examples" of idiomatic Kotlin—type inference, string templates, null safety, ranges, and lambdas—to demonstrate what makes the language more expressive than Java. - **Early (~9%–28%)**: Covers project setup and tooling, including configuring Kotlin in Android Studio (both 2.x and 3.0+), Gradle build script modifications, and how Kotlin compiles to Java/Dalvik bytecode. Also introduces core language foundations: functions with expression bodies, default and named arguments, data classes, and extensions. - **Early (~25%–34%)**: Delves into Kotlin's type system, focusing on null safety—safe call operators, the Elvis operator, and how Kotlin handles nullability annotations from Java libraries. Explains platform types and the developer's responsibility in deciding nullability for Java-interop code. - **Middle (~38%–47%)**: Explores smart casts in depth—how the compiler automatically casts types after checks, including scope limitations and lazy evaluation in conditional expressions. Covers basic types like Char and String, including escape sequences and standard library extensions. - **Middle (~47%–53%)**: Introduces collections and the `when` expression, showing how Kotlin simplifies multiway branching with comma-separated conditions, type checks, and smart casts within branch blocks. ## 【Key Takeaways】 - **Null safety is Kotlin's killer feature for Android** (Early): By explicitly marking nullable types with `?` and using safe call operators (`?.`), you eliminate most NullPointerException risks at compile time. This is especially valuable in Android where `savedInstanceState` and `findViewById` results are often nullable. - **Platform types require developer judgment** (Middle): Types coming from Java (like `View!` from `findViewById`) have relaxed null checks—the compiler can't determine nullability. You must decide whether to treat them as nullable or non-nullable based on your knowledge of the codebase and layout configurations. - **Smart casts eliminate redundant casting** (Middle): After a type check like `if (animal is Fish)`, the compiler automatically casts the variable within that scope. This works with early returns (`if (animal !is Fish) return`) and lazy conditional evaluation, making code cleaner and safer. - **Data classes and `copy()` simplify immutable models** (Early): The `data` modifier generates `toString()`, `equals()`, `hashCode()`, and `copy()` automatically. Combined with `copy(size = 3)`, this makes working with immutable objects practical and concise—a boon for Android's state management. - **Extensions add behavior without modifying classes** (Early): You can add methods or properties to existing classes (even Java classes like `String`) without changing their implementation. This enables idiomatic Android code like `str.takeLast(2)` or custom view helpers. - **Default and named arguments improve API design** (Early): Functions can define default values for parameters, and callers can use named arguments like `printMessage("oranges", name = "Bill")`. This reduces overload boilerplate and increases readability for functions with many parameters. - **The `when` expression replaces complex `if-else` chains** (Middle): It supports multiple conditions per branch (`"Car", "Bike" ->`), type checks with smart casts, and exhaustive coverage—making Android UI logic (e.g., handling different view states) much more readable. ## 【Reading Tips】 - **Skim the "Awesome Kotlin examples" section** (Opening): It's a teaser of what's possible, not a tutorial. Don't worry if you don't fully understand every example—return to it after finishing the book to appreciate how far you've come. - **Deep-read the null safety and platform types chapters** (Early–Middle): This is where Kotlin differs most from Java and where Android developers make the most mistakes. Pay special attention to how Kotlin handles Java SDK types and when you should treat platform types as nullable. - **Practice the smart cast examples** (Middle): The scope rules (if-block vs. early return vs. lazy evaluation) are subtle. Write your own examples to internalize when the compiler can and cannot guarantee a type. - **Skip the Gradle configuration details if you're on modern Android Studio** (Early): The build script examples reference pre-release versions. The key takeaway is the concept—Kotlin plugin and dependencies—not the exact version numbers. - **Use the book as a reference for language features** (Throughout): Chapters on strings, collections, and `when` are best consulted when you need a specific feature, not read cover-to-cover. ## 【Coverage Limits】 The excerpts cover roughly the first half of the book (up to ~53%), focusing on language fundamentals, null safety, smart casts, and basic types. Later chapters on extension functions in depth, functional programming with collections, coroutines, and Android-specific patterns (e.g., Anko, RxKotlin) are not covered in this guide. ##