Kotlin Quick Start Guide (Marko Devcic)（Z-Library）

# Kotlin Quick Start Guide — Reading Guide ## 【One-Line Pitch】 A practical, fast-paced introduction to Kotlin for developers with Java or other JVM experience, covering everything from basic syntax to object-oriented programming so you can start building real applications quickly. Ideal for Android developers and backend engineers who want to learn Kotlin's modern features without wading through a 500-page reference. ## 【Book Arc】 - **Opening (~0%–9%)**: Book setup, code downloads, and the compilation model — how Kotlin source (.kt files) compiles to Java bytecode (.class files), runs on the JVM, and why the ~800 KB standard library must be bundled with your app. - **Early (~9%–34%)**: Core language fundamentals — variables (val/var), number types, strings with templating, null safety operators (safe call `?.`, Elvis `?:`, non-null assertion `!!`), if-else as expressions, for loops over ranges, and exception handling without checked exceptions. - **Middle (~34%–53%)**: Object-oriented programming — properties with get/set accessors (C#-inspired), `lateinit` for deferred initialization, primary and secondary constructors, enum classes with `values()` and `valueOf()`, and member overriding. - **Late (~53%–100%)**: Advanced OOP topics and practical application — the excerpts cover up to overriding members, with the remainder of the book presumably covering inheritance, interfaces, and building complete applications (not fully covered in the sample). ## 【Key Takeaways】 - **Kotlin compiles to Java bytecode and runs on the JVM** (Early): Source files with `.kt` extension produce `.class` files identical to Java's, and the compiler bundles the standard library automatically with `-include-runtime`. This means you can run Kotlin apps exactly like Java apps, with minimal overhead. - **Prefer `val` (immutable) over `var` (mutable) for variables** (Early): The compiler even warns when you declare a mutable variable but only assign it once. This aligns with functional programming best practices and reduces bugs from accidental reassignment. - **Null safety is built into the type system** (Early): The safe call operator `?.` combines null checks with member access, the Elvis operator `?:` provides defaults for null values, and `!!` is an explicit non-null assertion that throws `KotlinNullPointerException` if violated. You should prefer safe calls over assertions. - **Kotlin's `if-else` and `throw` are expressions, not statements** (Early): They return values, so you can initialize variables directly from conditionals — `val str = if (num < 10) "Lower" else "Higher"` — eliminating verbose ternary-style code. - **For loops iterate over anything `Iterable`, not indices** (Early): The `..` operator creates an `IntRange` that implements `Iterable`, and the `in` keyword works both for iteration and membership checks (`if (5 in 1..10)`). There are no traditional index-based for loops. - **Properties replace getters/setters while preserving encapsulation** (Middle): Kotlin properties look like public fields to callers but internally use get/set accessors with a private backing field. You can make properties read-only, write-only, or public-with-private-set, giving you fine-grained control. - **`lateinit` solves the dependency injection problem** (Middle): When a property's value is known only after class initialization (e.g., injected by an IoC container), `lateinit` lets you declare a non-null reference type without initializing it — avoiding null-safety operators on fields you know are never null. Use `isInitialized` to check before access. - **Secondary constructors must delegate to the primary one** (Middle): You can have multiple secondary constructors declared in the class body, but each must call the primary constructor with `: this(...)`. Primary constructors can have properties; secondary ones only have parameters. ## 【Reading Tips】 - **Skim the opening chapters (0–9%)** if you're already comfortable with JVM concepts — the compilation model is useful but the setup instructions and publisher boilerplate can be skipped. - **Deep-read the null safety section (~25–28%)** — this is Kotlin's biggest differentiator from Java and the source of most beginner confusion. Work through the examples of `?.`, `?:`, and `!!` until you can predict which operator to use in any situation. - **Pay special attention to properties (~38–44%)** — understanding get/set accessors, `val` vs. `var` properties, and `lateinit` is essential for writing idiomatic Kotlin classes. This is where Kotlin diverges most from Java conventions. - **Practice the expression-oriented syntax** (if-else, throw, try) — these feel unnatural to Java developers at first but become second nature quickly. Write small functions that use expressions to initialize values. - **If you're an Android developer**, note that the book focuses on JVM Kotlin but states most concepts apply to Kotlin/JS and Kotlin/Native — the core language skills transfer directly. ## 【Coverage Limits】 This guide covers the book's opening through the middle sections (~53% of the book), including language fundamentals and object-oriented programming basics. The excerpts do not cover later chapters on inheritance hierarchies, interfaces, functional programming features, or building complete applications — the sample ends at member overriding. ##