On Java 中文版 基础卷 (Bruce Eckel)（Z-Library）

【One-Line Pitch】 A modern, example-driven rewrite of the classic Java introduction, rebuilt around Java 8/11/17 LTS features, for developers who want to understand not just Java syntax but the design reasoning behind it. Best suited to programmers moving from another language into Java, or intermediate Java developers who want to fill in conceptual gaps and avoid common traps. 【Book Arc】 - **Opening (~0%–10%)**: Frames programming languages as ways of thinking and introduces the object model — objects, references, classes, interfaces, upcasting, and why Java is a "purer" OOP language than C++. - **Early (~10%–32%)**: Covers the mechanics of day-to-day Java: operators (including ternary and string `+`/`+=`), control flow, constructors and initialization/cleanup, arrays, access control and packages, reuse via inheritance/composition/delegation, polymorphism, and interfaces (including Java 8 `default` methods). - **Middle (~32%–48%)**: Moves into inner classes (anonymous classes, closures, the Greenhouse controller/Command-pattern example), then collections — printing, `Arrays.asList` inference, `Stack`, `PriorityQueue`, `Comparator`, and the `Collection`/`Iterator` relationship. - **Late (~48%+)**: Introduces functional programming as a paradigm — abstracting behavior vs. data, immutability and side-effect-free functions, and the `java.util.function` target types that underpin lambdas and streams. - **Ending**: The excerpts do not cover the closing chapters (exceptions, code validation, files, strings, generics are listed in the blurb but not shown in the sampled material). 【Key Takeaways】 - **Java is deliberately a "pure" OOP language** (Opening): unlike C++, it expects you to think in objects from the start, and the book builds that mental model before syntax. - **Upcasting is the mechanism behind polymorphism** (Opening): treating a subclass as its base type lets you write code like `doSomething(Shape)` that stays correct and extensible as new subclasses appear. - **Constructors guarantee initialization, but calling overridable methods inside them is dangerous** (Early): the `Glyph`/`RoundGlyph` example shows a base constructor invoking an overridden `draw()` before the subclass fields are set — a classic silent bug. - **Access control and packages are namespace management, not just style** (Early): `public`, package-private, and `import` rules exist to prevent class-name collisions and to separate interface from implementation. - **Prefer composition/delegation over inheritance when the "is-a" relationship isn't real** (Early): the `SpaceShipControls` example shows delegation exposing only the methods you choose. - **Interfaces gained `default` methods in Java 8** (Early): this lets you add methods to an interface without breaking existing implementers — a key evolution the book highlights. - **Inner and anonymous classes enable closures and multiple-inheritance-like designs** (Middle): the Greenhouse controller demonstrates the Command pattern built from inner-class events. - **Functional programming abstracts behavior, not data** (Late): immutability and side-effect-free functions eliminate shared-mutable-state bugs, which is why FP matters for concurrency. 【Reading Tips】 - **Deep-read the object model and initialization chapters** (Opening–Early): the constructor-ordering trap is the single most valuable "avoid this bug" lesson in the sampled material. - **Skim operator/control-flow chapters if you already know C-family syntax**, but read the string `+`/`+=` and ternary discussions for Java-specific gotchas. - **Treat the collections and inner-class chapters as reference material** — the examples (printing collections, `PriorityQueue`, anonymous classes) reward hands-on typing rather than passive reading. - **Read the functional programming chapter slowly** even if you're not doing FP yet; it reframes why immutability matters for parallel code. - **Keep the LTS-version framing in mind**: the book targets Java 8/11/17, so preview/incubating features are flagged and should be treated as optional. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (through functional programming); later chapters on exceptions, files, strings, and generics are named in the blurb but not represented in the sampled material.