Java how to program. Early objects (Harvey Deitel, Paul Deitel)（Z-Library）

# Java How to Program, Early Objects — Reading Guide ## 【One-Line Pitch】 A comprehensive, example-driven Java textbook that takes you from your first "Hello World" through object-oriented programming, data structures, and GUI development—ideal for beginners in university courses or self-study who want a thorough, exercise-rich foundation in Java. ## 【Book Arc】 - **Opening (~0%–4%)**: Covers JDK installation, PATH configuration, and the compile-and-run cycle (javac/java), then moves into basic syntax—printing output, escape sequences, and simple program structure. - **Early (~4%–19%)**: Introduces control flow fundamentals: sequential execution, selection (if/else), iteration (while, for), and the classic class-average problem with type casting. Methods with multiple parameters and method overloading are also covered here. - **Early (~19%–33%)**: Dives into arrays (including ragged 2D arrays), pass-by-value vs. pass-by-reference semantics, the `this` reference, and object-oriented basics like encapsulation with validation in constructors and setters. - **Middle (~33%–44%)**: Explores inheritance hierarchies, `protected` members, polymorphism, abstract classes, interfaces, and exception handling—including how catch blocks match exception types and the "first match wins" rule. - **Middle (~44%–52%)**: Introduces JavaFX GUI development with Scene Builder and FXML, then shifts to string manipulation—`String.valueOf`, tokenizing with `split`, and regular expressions. - **Late (~52%+)**: Covers file I/O, streams, NIO, and XML serialization, including the challenge of variable-length records in sequential files. ## 【Key Takeaways】 - **Control structures are the backbone of all programs** (Early): The book emphasizes that sequence, selection, and iteration are the only three structures needed—a foundational insight that makes complex programs feel manageable. - **Type casting is essential for numeric precision** (Early): The `(double)` cast operator and implicit promotion explain why integer division truncates and how to get accurate floating-point results—critical for any calculation-heavy code. - **Method overloading requires distinct parameter lists** (Early): Return type alone cannot distinguish overloaded methods; identical parameter lists cause compilation errors regardless of return type—a common pitfall for beginners. - **Java is strictly pass-by-value** (Early): Even though object references are copied, methods can still modify referenced objects—understanding this distinction prevents confusion when writing methods that manipulate arrays or objects. - **Validation belongs in constructors and setters** (Early): Throwing `IllegalArgumentException` for invalid input (like negative gross sales) demonstrates defensive programming—a practice that prevents bugs before they propagate. - **Polymorphism makes systems extensible** (Middle): Processing objects of different subclasses through a common superclass reference, combined with abstract classes and interfaces, allows you to add new types without rewriting existing code. - **BigDecimal is mandatory for financial calculations** (Early): The book explicitly warns that `double` values are approximate, making `BigDecimal` (with `NumberFormat` for locale-specific output) the right choice for monetary applications. - **Exception handling follows a first-match-wins rule** (Middle): When multiple catch blocks could match, only the first executes—and catching the same type twice is a compilation error, so order your catch blocks from most specific to most general. ## 【Reading Tips】 - **Skim the JDK setup sections** (~0%–4%) if you've installed Java before; the PATH troubleshooting advice is useful only if you encounter the "'java' is not recognized" error. - **Deep-read the control flow and method chapters** (~4%–19%): These are the conceptual core. Work through the class-average and compound-interest examples line by line, and do the exercises at chapter ends—they're where the learning sticks. - **Pay special attention to the pass-by-value discussion** (~19%–26%): This is a notoriously confusing topic for Java beginners. Read it twice if needed, and trace through the array examples with pen and paper. - **The JavaFX chapters (~44%–52%) can be skimmed** if your goal is core language mastery; they're practical but less conceptually foundational. Focus on the FXML/controller pattern rather than every layout container. - **Use the book as a reference for string and file operations** (~52%+): You don't need to memorize every `String` method or I/O class—just know what's available and return when you need it. ## 【Coverage Limits】 The excerpts cover roughly the first half of the book (through file I/O and XML serialization). Later chapters on data structures, generics, collections, concurrency, and networking are not represented in this guide. ##