Kotlin Illustrated Guide (Dave Leeds)（Z-Library）

【One-Line Pitch】 A visual, example-first introduction to Kotlin that turns core language ideas—expressions, functions, classes, null safety, collections, and lambdas—into approachable mental models. Best for beginners and self-taught programmers who want a friendly on-ramp before tackling Kotlin’s more advanced type system. 【Book Arc】 - **Opening (~0%–10%)**: Establishes the book’s illustrated, concept-by-concept teaching style and begins with the absolute basics: values, variables, expressions vs. statements, and why duplicated code is a problem worth solving. - **Early (~10%–32%)**: Builds the first practical toolkit—functions, parameters and arguments, default values, expression vs. block bodies, `Unit`, `main()`, string interpolation, conditionals with `when`/`if`, classes and objects, packages/imports, and enum classes with built-in `ordinal`/`name`. - **Middle (~32%–48%)**: Moves into Kotlin’s distinctive safety and flexibility features: nullable types and null safety, safe-call “train” expressions, function references, type inference, lambdas, higher-order functions, and the beginnings of collections with `listOf` and indexed access. - **Late (~48% onward)**: The excerpts thin out here, but the table of contents signals advanced object modeling—inheritance, abstract/open classes, visibility modifiers, data classes, destructuring, `equals()`/`hashCode()`/`toString()`, and delegation. - **Ending**: The excerpts do not cover the final chapters in detail; based on the TOC, the book closes with more advanced class design and conflict management rather than a separate capstone project. 【Key Takeaways】 - **Expressions are the atoms of Kotlin code** (Opening): If you can assign it to a variable, it’s an expression; otherwise it’s a statement. This distinction underpins functions, conditionals, and lambdas later. - **Functions exist to remove duplication** (Early): The book frames functions as reusable “machines” that turn inputs into outputs, then layers on positional/named arguments, defaults, and expression bodies. - **`when` is order-sensitive** (Early): The first true branch wins, so branch order changes behavior—an easy trap for beginners coming from languages with different switch semantics. - **Classes describe concepts; objects are instances** (Early): Properties, member functions, UML diagrams, single-instance objects, packages, and imports form the vocabulary for all later object-oriented chapters. - **Enum classes constrain choices productively** (Early): Entries carry custom properties and functions, plus automatic `ordinal` (zero-based) and `name`—a gentle introduction to zero-based indexing before collections. - **Null safety is modeled as present vs. absent** (Middle): Nullable variables are “buckets” that may be empty; safe-call chains (`?.`) let you hop from car to car and bail out with `null` when needed. - **Functions are values** (Middle): Function references (`::name`, `object::method`) and lambdas enable higher-order functions, with type inference smoothing the syntax. - **Collections start with indexed access** (Middle): `listOf` and `get(index)` introduce lists, with explicit warnings about out-of-bounds indexes and the historical reason indexes start at zero. 【Reading Tips】 - **Deep-read the early chapters even if you know another language**: The expression/statement rule and the duplication-to-function progression are the book’s conceptual spine. - **Skim the TOC-heavy opening pages**: They are mostly navigation; the real teaching starts with expressions and functions. - **Pause on null safety and function references**: These are the two biggest conceptual jumps in the sampled middle section; the “train” metaphor is worth internalizing. - **Use the summaries at chapter ends as checklists**: They list exactly what you should be able to do before moving on. - **Expect the later chapters to be denser**: Inheritance, abstract/open classes, and data classes are where the illustrated style has to carry more abstract material. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book; the later chapters on inheritance, abstract/open classes, data classes, destructuring, and delegation are only visible through the table of contents and are not summarized in detail here.