BOOK
Objects First with Java: A Practical Introduction Using BlueJ, Global Edition
(2016)
Additional Information
Book Details
Abstract
A Modern Approach to Functional Programming
Objects First with Java: A Practical Introduction is an introduction to object-oriented programming for beginners. The main focus of the book is general object-oriented and programming concepts from a software engineering perspective.
The first chapters are written for students with no programming experience with later chapters being more suitable for advanced or professional programmers. The Java programming language and BlueJ–the Java development environment – are the two tools used throughout the book. BlueJ's clear visualization of classes and objects means that students can immediately appreciate the differences between them and gain a much better understanding of the nature of an object than they would from simply reading source code. Unlike traditional textbooks, the chapters are not ordered by language features but by software development concepts.
The Sixth Edition goes beyond just adding the new language constructs of Java 8. The book’s exploration of this new language demonstrates a renaissance of functional ideas in modern programming. While functional programming isn’t new in principle, it’s seen a boost in popularity based on the current computer hardware available and the changing nature of projects programmers wish to tackle. Functional language constructs make it possible to efficiently automate currency, make use of multiple cores without much effort on the side of the programmer, are both more elegant and readable, and offer great potential in solving the issue of parallel hardware. Functional programming has become an essential part of the field, and Objects First with Java gives students a basic understanding of an area they’ll need to master in order to succeed in the future.
Table of Contents
| Section Title | Page | Action | Price |
|---|---|---|---|
| Cover | Cover | ||
| Title Page | i | ||
| Copyright Page | ii | ||
| Contents | v | ||
| Foreword | xiv | ||
| Preface | xv | ||
| List of Projects Discussed in Detail in This Book | xxv | ||
| Acknowledgments | xxviii | ||
| Part 1 \rFoundations of Object Orientation | 1 | ||
| Chapter 1 Objects and Classes | 3 | ||
| 1.1 Objects and classes | 3 | ||
| 1.2 Creating objects | 4 | ||
| 1.3 Calling methods | 5 | ||
| 1.4 Parameters | 6 | ||
| 1.5 Data types | 7 | ||
| 1.6 Multiple instances | 8 | ||
| 1.7 State | 9 | ||
| 1.8 What is in an object? | 10 | ||
| 1.9 Java code | 11 | ||
| 1.10 Object interaction | 12 | ||
| 1.11 Source code | 13 | ||
| 1.12 Another example | 15 | ||
| 1.13 Return values | 15 | ||
| 1.14 Objects as parameters | 16 | ||
| 1.15 Summary | 17 | ||
| Chapter 2 Understanding Class Definitions | 21 | ||
| 2.1 Ticket machines | 21 | ||
| 2.2 Examining a class definition | 23 | ||
| 2.3 The class header | 25 | ||
| 2.4 Fields, constructors, and methods | 26 | ||
| 2.5 Parameters: receiving data | 32 | ||
| 2.6 Assignment | 34 | ||
| 2.7 Methods | 35 | ||
| 2.8 Accessor and mutator methods | 36 | ||
| 2.9 Printing from methods | 39 | ||
| 2.10 Method summary | 42 | ||
| 2.11 Summary of the naíve ticket machine | 42 | ||
| 2.12 Reflecting on the design of the ticket machine | 43 | ||
| 2.13 Making choices: the conditional statement | 45 | ||
| 2.14 A further conditional-statement example | 47 | ||
| 2.15 Scope highlighting | 48 | ||
| 2.16 Local variables | 49 | ||
| 2.17 Fields, parameters, and local variables | 51 | ||
| 2.18 Summary of the better ticket machine | 53 | ||
| 2.19 Self-review exercises | 53 | ||
| 2.20 Reviewing a familiar example | 55 | ||
| 2.21 Calling methods | 57 | ||
| 2.22 Experimenting with expressions: the Code Pad | 59 | ||
| 2.23 Summary | 61 | ||
| Chapter 3 Object Interaction | 67 | ||
| 3.1 The clock example | 67 | ||
| 3.2 Abstraction and modularization | 68 | ||
| 3.3 Abstraction in software | 69 | ||
| 3.4 Modularization in the clock example | 69 | ||
| 3.5 Implementing the clock display | 70 | ||
| 3.6 Class diagrams versus object diagrams | 71 | ||
| 3.7 Primitive types and object types | 72 | ||
| 3.8 The NumberDisplay class | 72 | ||
| 3.9 The ClockDisplay class | 80 | ||
| 3.10 Objects creating objects | 83 | ||
| 3.11 Multiple constructors | 84 | ||
| 3.12 Method calls | 84 | ||
| 3.13 Another example of object interaction | 88 | ||
| 3.14 Using a debugger | 92 | ||
| 3.15 Method calling revisited | 96 | ||
| 3.16 Summary | 97 | ||
| Chapter 4 Grouping Objects | 101 | ||
| 4.1 Building on themes from Chapter 3 | 101 | ||
| 4.2 The collection abstraction | 102 | ||
| 4.3 An organizer for music files | 103 | ||
| 4.4 Using a library class | 104 | ||
| 4.5 Object structures with collections | 107 | ||
| 4.6 Generic classes | 109 | ||
| 4.7 Numbering within collections | 110 | ||
| 4.8 Playing the music files | 113 | ||
| 4.9 Processing a whole collection | 115 | ||
| 4.10 Indefinite iteration | 120 | ||
| 4.11 Improving structure—the Track class | 128 | ||
| 4.12 The Iterator type | 131 | ||
| 4.13 Summary of the music-organizer project | 135 | ||
| 4.14 Another example: an auction system | 137 | ||
| 4.15 Summary | 147 | ||
| Chapter 5 Functional Processing of Collections (Advanced) | 149 | ||
| 5.1 An alternative look at themes from Chapter 4 | 149 | ||
| 5.2 Monitoring animal populations | 150 | ||
| 5.3 A first look at lambdas | 154 | ||
| 5.4 The forEach method of collections | 156 | ||
| 5.5 Streams | 158 | ||
| 5.6 Summary | 168 | ||
| Chapter 6 More-Sophisticated Behavior | 171 | ||
| 6.1 Documentation for library classes | 172 | ||
| 6.2 The TechSupport system | 173 | ||
| 6.3 Reading class documentation | 178 | ||
| 6.4 Adding random behavior | 183 | ||
| 6.5 Packages and import | 189 | ||
| 6.6 Using maps for associations | 190 | ||
| 6.7 Using sets | 195 | ||
| 6.8 Dividing strings | 195 | ||
| 6.9 Finishing the TechSupport system | 197 | ||
| 6.10 Autoboxing and wrapper classes | 199 | ||
| 6.11 Writing class documentation | 201 | ||
| 6.12 Public versus private | 204 | ||
| 6.13 Learning about classes from their interfaces | 206 | ||
| 6.14 Class variables and constants | 211 | ||
| 6.15 Class methods | 214 | ||
| 6.16 Executing without BlueJ | 216 | ||
| 6.17 Further advanced material | 216 | ||
| 6.18 Summary | 220 | ||
| Chapter 7 Fixed-Size Collections—Arrays | 223 | ||
| 7.1 Fixed-size collections | 223 | ||
| 7.2 Arrays | 224 | ||
| 7.3 A log-file analyzer | 224 | ||
| 7.4 The for loop | 230 | ||
| 7.5 The automaton project | 236 | ||
| 7.6 Arrays of more than one dimension (advanced) | 244 | ||
| 7.7 Arrays and streams (advanced) | 251 | ||
| 7.8 Summary | 252 | ||
| Chapter 8 Designing Classes | 255 | ||
| 8.1 Introduction | 256 | ||
| 8.2 The world-of-zuul game example | 257 | ||
| 8.3 Introduction to coupling and cohesion | 259 | ||
| 8.4 Code duplication | 260 | ||
| 8.5 Making extensions | 263 | ||
| 8.6 Coupling | 266 | ||
| 8.7 Responsibility-driven design | 270 | ||
| 8.8 Localizing change | 273 | ||
| 8.9 Implicit coupling | 274 | ||
| 8.10 Thinking ahead | 277 | ||
| 8.11 Cohesion | 278 | ||
| 8.12 Refactoring | 282 | ||
| 8.13 Refactoring for language independence | 286 | ||
| 8.14 Design guidelines | 291 | ||
| 8.15 Summary | 292 | ||
| Chapter 9 Well-Behaved Objects | 295 | ||
| 9.1 Introduction | 295 | ||
| 9.2 Testing and debugging | 296 | ||
| 9.3 Unit testing within BlueJ | 297 | ||
| 9.4 Test automation | 304 | ||
| 9.5 Refactoring to use with streams (advanced) | 311 | ||
| 9.6 Debugging | 312 | ||
| 9.7 Commenting and style | 314 | ||
| 9.8 Manual walkthroughs | 315 | ||
| 9.9 Print statements | 320 | ||
| 9.10 Debuggers | 324 | ||
| 9.11 Debugging streams (advanced) | 325 | ||
| 9.12 Choosing a debugging strategy | 326 | ||
| 9.13 Putting the techniques into practice | 327 | ||
| 9.14 Summary | 327 | ||
| Part 2 Application Structures | 329 | ||
| Chapter 10 Improving Structure with Inheritance | 331 | ||
| 10.1 The network example | 331 | ||
| 10.2 Using inheritance | 343 | ||
| 10.3 Inheritance hierarchies | 345 | ||
| 10.4 Inheritance in Java | 346 | ||
| 10.5 Network: adding other post types | 349 | ||
| 10.6 Advantages of inheritance (so far) | 351 | ||
| 10.7 Subtyping | 352 | ||
| 10.8 The Object class | 358 | ||
| 10.9 The collection hierarchy | 359 | ||
| 10.10 Summary | 360 | ||
| Chapter 11 More about Inheritance | 363 | ||
| 11.1 The problem: network’s display method | 363 | ||
| 11.2 Static type and dynamic type | 365 | ||
| 11.3 Overriding | 368 | ||
| 11.4 Dynamic method lookup | 370 | ||
| 11.5 super call in methods | 373 | ||
| 11.6 Method polymorphism | 374 | ||
| 11.7 Object methods: toString | 374 | ||
| 11.8 Object equality: equals and hashCode | 377 | ||
| 11.9 Protected access | 379 | ||
| 11.10 The instanceof operator | 381 | ||
| 11.11 Another example of inheritance with overriding | 382 | ||
| 11.12 Summary | 385 | ||
| Chapter 12 Further Abstraction Techniques | 389 | ||
| 12.1 Simulations | 389 | ||
| 12.2 The foxes-and-rabbits simulation | 390 | ||
| 12.3 Abstract classes | 405 | ||
| 12.4 More abstract methods | 412 | ||
| 12.5 Multiple inheritance | 414 | ||
| 12.6 Interfaces | 417 | ||
| 12.7 A further example of interfaces | 425 | ||
| 12.8 The Class class | 427 | ||
| 12.9 Abstract class or interface? | 427 | ||
| 12.10 Event-driven simulations | 428 | ||
| 12.11 Summary of inheritance | 429 | ||
| 12.12 Summary | 430 | ||
| Chapter 13 Building Graphical User Interfaces | 433 | ||
| 13.1 Introduction | 433 | ||
| 13.2 Components, layout, and event handling | 434 | ||
| 13.3 AWT and Swing | 435 | ||
| 13.4 The ImageViewer example | 435 | ||
| 13.5 ImageViewer 1.0: the first complete version | 447 | ||
| 13.6 ImageViewer 2.0: improving program structure | 461 | ||
| 13.7 ImageViewer 3.0: more interface components | 467 | ||
| 13.8 Inner classes | 471 | ||
| 13.9 Further extensions | 476 | ||
| 13.10 Another example: MusicPlayer | 478 | ||
| 13.11 Summary | 481 | ||
| Chapter 14 Handling Errors | 483 | ||
| 14.1 The address-book project | 484 | ||
| 14.2 Defensive programming | 488 | ||
| 14.3 Server error reporting | 491 | ||
| 14.4 Exception-throwing principles | 495 | ||
| 14.5 Exception handling | 501 | ||
| 14.6 Defining new exception classes | 508 | ||
| 14.7 Using assertions | 510 | ||
| 14.8 Error recovery and avoidance | 513 | ||
| 14.9 File-based input/output | 516 | ||
| 14.10 Summary | 527 | ||
| Chapter 15 Designing Applications | 529 | ||
| 15.1 Analysis and design | 529 | ||
| 15.2 Class design | 536 | ||
| 15.3 Documentation | 538 | ||
| 15.4 Cooperation | 539 | ||
| 15.5 Prototyping | 539 | ||
| 15.6 Software growth | 540 | ||
| 15.7 Using design patterns | 542 | ||
| 15.8 Summary | 548 | ||
| Chapter 16 A Case Study | 551 | ||
| 16.1 The case study | 551 | ||
| 16.2 Analysis and design | 552 | ||
| 16.3 Class design | 556 | ||
| 16.4 Iterative development | 561 | ||
| 16.5 Another example | 570 | ||
| 16.6 Taking things further | 570 | ||
| Appendix A: Working with a BlueJ Project | 571 | ||
| A.1 Installing BlueJ | 571 | ||
| A.2 Opening a project | 571 | ||
| A.3 The BlueJ debugger | 571 | ||
| A.4 Configuring BlueJ | 571 | ||
| A.5 Changing the interface language | 572 | ||
| A.6 Using local API documentation | 572 | ||
| A.7 Changing the new class templates | 572 | ||
| Appendix B: Java Data Types | 573 | ||
| B.1 Primitive types | 573 | ||
| B.2 Casting of primitive types | 574 | ||
| B.3 Object types | 574 | ||
| B.4 Wrapper classes | 575 | ||
| B.5 Casting of object types | 575 | ||
| Appendix C: Operators | 577 | ||
| C.1 Arithmetic expressions | 577 | ||
| C.2 Boolean expressions | 578 | ||
| C.3 Short-circuit operators | 579 | ||
| Appendix D: Java Control Structures | 581 | ||
| D.1 Control structures | 581 | ||
| D.2 Selection statements | 581 | ||
| D.3 Loops | 583 | ||
| D.4 Exceptions | 585 | ||
| D.5 Assertions | 587 | ||
| Appendix E: Running Java without BlueJ | 589 | ||
| E.1 Executing without BlueJ | 589 | ||
| E.2 Creating executable .jar files | 591 | ||
| E.3 Developing without BlueJ | 591 | ||
| Appendix F: Using the Debugger | 593 | ||
| F.1 Breakpoints | 594 | ||
| F.2 The control buttons | 594 | ||
| F.3 The variable displays | 595 | ||
| F.4 The Call Sequence display | 596 | ||
| F.5 The Threads display | 596 | ||
| Appendix G: JUnit Unit-Testing Tools | 597 | ||
| G.1 Enabling unit-testing functionality | 597 | ||
| G.2 Creating a test class | 597 | ||
| G.3 Creating a test method | 597 | ||
| G.4 Test assertions | 598 | ||
| G.5 Running tests | 598 | ||
| G.6 Fixtures | 598 | ||
| Appendix H: Teamwork Tools | 599 | ||
| H.1 Server setup | 599 | ||
| H.2 Enabling teamwork functionality | 599 | ||
| H.3 Sharing a project | 599 | ||
| H.4 Using a shared project | 599 | ||
| H.5 Update and commit | 600 | ||
| H.6 More information | 600 | ||
| Appendix I: Javadoc | 601 | ||
| I.1 Documentation comments | 601 | ||
| I.2 BlueJ support for javadoc | 603 | ||
| Appendix J: Program Style Guide | 605 | ||
| J.1 Naming | 605 | ||
| J.2 Layout | 605 | ||
| J.3 Documentation | 606 | ||
| J.4 Language-use restrictions | 607 | ||
| J.5 Code idioms | 608 | ||
| Appendix K: Important Library Classes | 609 | ||
| K.1 The java.lang package | 609 | ||
| K.2 The java.util package | 610 | ||
| K.3 The java.io and java.nio.file packages | 611 | ||
| K.4 The java.util.function package | 612 | ||
| K.5 The java.net package | 612 | ||
| K.6 Other important packages | 613 | ||
| Index | 615 | ||
| A | 615 | ||
| B | 616 | ||
| C | 617 | ||
| D | 619 | ||
| E | 619 | ||
| F | 620 | ||
| G | 621 | ||
| H | 621 | ||
| I | 621 | ||
| J | 623 | ||
| K | 623 | ||
| L | 623 | ||
| M | 624 | ||
| N | 625 | ||
| O | 625 | ||
| P | 626 | ||
| R | 627 | ||
| S | 627 | ||
| T | 629 | ||
| U | 629 | ||
| V | 630 | ||
| W | 630 |