Core Java, Volume I (Cay S. Horstmann)（Z-Library）

【One-Line Pitch】 A rigorous, example-driven tour of the Java language and core APIs for programmers who already code in something else and want depth rather than hand-holding. If you need to understand *why* Java behaves the way it does—from `final` semantics to pattern matching in `switch`—this is the reference to keep within arm's reach. 【Book Arc】 - **Opening (~0%–10%)**: Orients you to the book's philosophy and the modern Java release cadence—six-month version cycles, preview features, and the long road to the module system—before any code appears. - **Early (~10%–32%)**: Builds the language floor: comments and documentation conventions, constants and enumerated types, strings and `StringBuilder`, control flow, `BigInteger`/`BigDecimal`, arrays, and the `java.time` date API, then moves into writing real "workhorse" classes with fields, constructors, and methods. - **Middle (~32%–55%)**: The object-oriented core—inheritance, method overriding, `Object` contracts (`equals`, `hashCode`, `toString`), wrapper classes and boxing, sealed/final class hierarchies, and the newer pattern-matching forms of `switch`. - **Late (~55%–80%)**: Interfaces and their properties, comparison contracts (`Comparable`/`compareTo` across subclasses), reflection-based array access, and the collections and generics machinery that underpins everyday Java code. - **Ending (~80%–100%)**: Consolidation around the standard library and practical packaging—JAR files, manifests, executable JARs, and deployment behaviors across operating systems. (Excerpts thin out here; exact closing chapters are not fully covered.) 【Key Takeaways】 - **Java's release model shapes how you learn it** (Opening): Since 2018, versions ship every six months and features may preview repeatedly—pattern matching for `switch` previewed four times before finalizing in Java 21. Knowing this explains why the book flags "preview" features separately. - **Comments are three distinct tools, not one** (Early): Line, block, and `/**` documentation comments serve different purposes; block comments don't nest, so you can't reliably comment out code that already contains them. - **`final` is Java's constant mechanism, not `const`** (Early): `const` is a reserved-but-unused keyword; constants are `static final`, and their visibility (class-level vs. local) is a deliberate design choice. - **Enumerated types prevent invalid states** (Early): Encoding sizes as `1,2,3,4` or `S,M,L,X` invites errors; a proper `enum` restricts a variable to a finite set of named values. - **Strings are Unicode sequences with real encoding subtleties** (Early): UTF-8 source files let you paste characters directly, while `StringBuilder` handles mutation, chaining, and reversal that `String` cannot. - **`equals`, `hashCode`, and `toString` are contracts you must honor** (Middle): Overriding them correctly—often via `Objects.hash` and `super` calls—is essential for collections and debugging to behave sanely. - **Wrapper classes are immutable, which limits them** (Middle): You cannot write a method that modifies a numeric parameter via `Integer`; boxing is convenient but not a substitute for mutable state. - **Sealing a hierarchy encodes closed-world assumptions** (Middle): Marking subclasses `final` and using exhaustive `instanceof`/`switch` patterns documents that you know every variant—useful for fixed formats like JSON. - **Interfaces are types, not classes** (Late): You can declare interface variables and test with `instanceof`, but never instantiate an interface; comparison logic across subclasses needs a deliberate `compareTo` strategy. 【Reading Tips】 - **Skim the opening history and acknowledgments** (~0%–10%) for context on Java's evolution, but don't linger—the value starts with the language chapters. - **Deep-read the object contract sections** (`equals`/`hashCode`/`toString`, inheritance, interfaces). These are where experienced programmers most often carry over bad habits from other languages. - **Treat API tables as reference, not prose.** The excerpted `BigInteger`, `LocalDate`, and `Integer` method listings are lookup material; read them once, then return as needed. - **Watch the "Caution" and "C++ Note" callouts.** They flag genuine traps—non-nesting comments, manifest newlines, `finalize` misuse—that cost real debugging time. - **Run the sample programs.** The book's examples are designed as starting points for your own code, so typing them out beats reading them passively. 【Coverage Limits】 This guide is synthesized from stratified excerpts covering roughly the first half of the book in detail, with the later sections (collections, generics, and deployment) represented only thinly. Chapter-level structure beyond the excerpted material is not asserted here.