Programmer avec Java - Concepts fondamentaux et mise en oeuvre par lexemple - collection OReilly (Ben EVANS, David FLANAGAN)（Z-Library）

【One-Line Pitch】 A practical, example-driven tour of modern Java for developers who want to move beyond syntax and understand the language, the JVM, and the platform as a working system. Best suited to programmers with some prior coding experience who are targeting Java 11 (with notes on Java 8–10 features). 【Book Arc】 - **Opening (~0%–10%)**: Frames the book as a Java 11 / OpenJDK guide, explains its structure, typographic conventions, and the shift to six-month release cycles after Java 9. - **Early (~10%–30%)**: Introduces the Java language and platform: history, the JVM, bytecode and class files, the Java ecosystem, standardization, and the distinction between language, virtual machine, and libraries. - **Middle (~30%–55%)**: Covers core language mechanics and object-oriented programming, then moves into the type system, generics, enums, annotations, and lambdas, with design patterns and OO design techniques. - **Late (~55%–85%)**: Expands into platform APIs and advanced topics such as networking, class loading, reflection, method handles, and the Java Platform Module System introduced in Java 9. - **Ending (~85%–100%)**: Closes with platform tooling — the JDK, compiler, interpreter, jshell, modular tools — plus an appendix on Nashorn and pointers to downloadable example source code. 【Key Takeaways】 - **Java is more than syntax** (Early): The book stresses that modern Java developers must understand concurrency, OO design, memory management, and typing, not just APIs. - **The JVM is a runtime environment, not a simple interpreter** (Middle): It executes bytecode, supports threads, manages memory, and uses JIT compilation to optimize hot methods for near-native performance. - **Java 8 and 9 are the pivotal modern releases** (Early): Lambdas and collection rewrites changed how Java is written; JPMS modularity changed how applications are structured. - **The ecosystem is a major reason for Java’s enterprise adoption** (Middle): Standardization, portability, libraries, connectors, and broad integration options make Java a safe long-term investment. - **Object-oriented design is treated as an engineering skill** (Middle): The book moves from classes and objects to design patterns and robust OO program construction. - **The type system is central to advanced Java** (Middle): Generics, enums, annotations, and lambdas are presented as connected parts of a broader type-oriented view. - **Metaprogramming and modularity are advanced but practical topics** (Late): Reflection, class loading, method handles, and JPMS are introduced with examples rather than pure theory. - **Tooling matters** (Ending): The JDK toolchain, jshell, and modular development tools are part of learning Java properly, not optional extras. 【Reading Tips】 - Read the first six chapters carefully; the book explicitly treats them as essential foundations. - Skim historical notes if you already know Java’s evolution, but slow down on JVM behavior, bytecode, and JIT concepts. - Use the book as both tutorial and reference: beginners can follow it linearly, while experienced Java programmers can jump to type system, modules, reflection, and tooling chapters. - Pay attention to the example code and download the ZIP archive from the publisher’s page; the book is designed around implementation by example. - Treat Java 8–10 notes as migration context if you are moving from older Java versions to Java 11. 【Coverage Limits】 The excerpts cover the book’s structure, Java platform fundamentals, JVM behavior, ecosystem, and major topic areas, but do not provide detailed chapter-by-chapter technical content for every section. Specific code examples, API details, and later chapter arguments are only partially represented.