Learning Java (Marc Loy, Patrick Niemeyer Daniel Leuck)（Z-Library）

【One-Line Pitch】 A thorough, hands-on introduction to modern Java for programmers who want to move from "hello world" to real applications—covering the language, the toolchain, and the runtime that makes Java portable and fast. Best for developers with some prior programming experience who want a practical, example-driven path into Java. 【Book Arc】 - **Opening (~0%–10%)**: Frames Java as a modern, portable language and explains the JVM, bytecode, and JIT/HotSpot compilation—establishing why Java runs fast and securely across platforms. - **Early (~10%–32%)**: Gets you writing and running real code: setting up an IDE or command line, building a first Swing application, and learning classes, packages, and the compile/run workflow. - **Middle (~32%–50%)**: Deepens the language core—tools like JARs and manifests, annotations, variables vs. constants, references, and control flow such as loops—while reinforcing good project structure. - **Late (~50%–75%)**: Moves into object-oriented design and the standard library: class design, the java.lang.Math utilities, big/precise numbers, and date/time handling. - **Ending (~75%–100%)**: Tackles concurrency—threads, the Runnable interface, synchronization, scheduling, and the newer virtual threads—plus review questions and code exercises to consolidate learning. 【Key Takeaways】 - **Java's speed comes from adaptive compilation** (Early): HotSpot profiles running code and JIT-compiles only the hot paths, so Java can rival native code while staying portable. - **The toolchain is part of the language** (Early–Middle): Understanding javac, the classpath, JARs, and manifest files is essential for packaging and running real applications. - **Packages provide structure and scalability** (Early): They group classes, control visibility, and keep growing applications from becoming a "bird's nest." - **Variables vs. constants is a foundational distinction** (Middle): Reusable mutable state and fixed values shape how you write readable, maintainable code. - **References, not objects, are passed** (Middle): A method can mutate an object's state through a reference but cannot repoint the caller's reference—a subtle but critical mental model. - **Threads are core to mastering Java** (Ending): Even if you rarely write multithreaded code, understanding threads, synchronization, and scheduling is expected of a competent Java developer. - **Virtual threads change the concurrency calculus** (Ending): Project Loom's virtual threads (preview in Java 19) enable massive thread counts with better performance for scalable applications. - **Practice is built into the book** (Throughout): End-of-chapter questions and code exercises (with solutions on GitHub) turn reading into hands-on skill. 【Reading Tips】 - **Skim the JVM/JIT theory early** if you already know Java basics, but deep-read the toolchain chapters—they're where beginners stumble. - **Type out every example**: The book builds progressively (HelloJava → HelloJava2 → GoodbyeJava), and muscle memory with javac/java or an IDE pays off. - **Don't skip the exercises**: They're designed to force you back into the chapter as a reference, which is exactly how you'll use Java docs later. - **Treat the concurrency chapter as a milestone**: Read it slowly, especially synchronization and virtual threads, since these are the hardest concepts and the most interview-relevant. - **Use the date/time and Math sections as a reference**: Skim on first pass, then return when you need them in real code. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book in detail, with lighter coverage of later chapters (threads, utilities). Specific chapter titles, advanced class design, and full library coverage are only partially represented in the excerpts.