Java Essentials Volume 2 Object-Oriented Programming and Beyond (Lawrence G. Decamora III)（Z-Library）

【One-Line Pitch】 A classroom-tested bridge from "I can write Java" to "I can design Java," turning procedural habits into object-oriented thinking and ending with a working Swing desktop app. Best for students in a second Java course, self-taught programmers finishing the basics, and instructors who want a ready-made syllabus skeleton. 【Book Arc】 - **Opening (~0%–15%)**: A bridge chapter that deliberately re-walks Volume 1 territory — variables, control flow, loops, strings, arrays — then reframes it: the problem it solves is the mental switch from procedures to objects, and it previews why OOP matters as programs grow. - **Early (~15%–35%)**: Reference data types and the object model. You learn what a reference actually holds versus a primitive, how `this` and local variables behave, then move into classes vs objects, instantiation, encapsulation, constructors, and the instance/static method split. Also here: source-file layout, modules, JARs, manifests, and reading the Java API docs. - **Middle (~35%–60%)**: The inheritance-and-polymorphism core. Superclasses and subclasses, the "is-a" test, access modifiers, overriding rules, `super`, overloading rules, constructor chaining, and the `Object` class — then virtual method invocation, heterogeneous arrays, polymorphic arguments, `instanceof`, and object casting. - **Late (~60%–80%)**: Class features beyond the basics — `static` revisited, `Math`/`System`, static imports, wrapper classes, `final`, `record`, `enum`, `abstract`, interfaces and default methods — plus exception handling, assertions, and the Collections and Generics framework. - **Ending (~80%–100%)**: GUI work. AWT fundamentals, layout managers, event handling, then converting the AWT app to Swing, common Swing components, and packaging the finished desktop application into a JAR. 【Key Takeaways】 - **The hardest chapter is the bridge, not the syntax** (Opening): the book's real work is replacing procedural instincts with object modeling, which is why it spends a whole chapter looking backward before moving forward. - **References are the conceptual hinge of everything after** (Early): once you separate "the value" from "the address pointing at the object," constructors, `this`, and later polymorphism stop feeling like magic. - **Inheritance is taught as a contract with rules, not a shortcut** (Middle): overriding rules, access modifiers, `super`, and constructor chaining are presented as constraints you must respect, which is what separates working code from maintainable code. - **Polymorphism is where the design pays off** (Middle): virtual method invocation, heterogeneous arrays, and polymorphic arguments show why you'd bother with supertypes at all — one call site, many behaviors. - **Modern Java features are folded into the class-design chapter** (Late): `record`, `enum`, `abstract`, interfaces with default methods, and lambdas/functional interfaces appear as design tools rather than trivia. - **Exceptions and Collections are framed as professional necessities** (Late): handling runtime errors and manipulating data with generics are positioned as the tools you cannot skip once programs get real. - **The book ends by shipping something** (Ending): AWT → layout managers → event handling → Swing → JAR packaging is a deliberate arc from "draw a window" to "hand someone an application." - **Structure is pedagogical by design** (throughout): chapter summaries, multiple-choice reviews, coding tasks, and real-world analogies recur, so the book doubles as a course outline. 【Reading Tips】 - Read Chapter 0 even if you think you know it — it is the book's thesis statement, not filler, and it sets up the reference-type vocabulary used everywhere later. - Deep-read the inheritance and polymorphism chapters; skim the `Math`/`System`/static-import material if you already use those daily. - Do the coding tasks and quizzes rather than reading past them; the book explicitly warns that reading without coding will not build the skill. - When you reach the GUI section, build the SimpleCalculator app yourself before the Swing conversion — the AWT-to-Swing transition is where layout and event concepts actually click. - Keep the Java API documentation habit from the early chapters; the book treats doc-reading as a skill, not a footnote. 【Coverage Limits】 The excerpts cover the front matter, table of contents, preface, and Chapter 0 in detail, plus chapter titles through the Swing project; the interior of the inheritance, polymorphism, collections, exception, and GUI chapters is not shown, so specific examples and code walkthroughs there are not summarized here.