Objects First With Java: A Practical Introduction Using BlueJ: International Edition

For introductory courses in Java/Introduction to Programming and Object-Oriented Programming.   Its close integration with the BlueJ development environment allows this book to focus on key aspects of object-oriented software development from day one. 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. Language features are introduced as a response to the problems to be solved. A large number of different, interesting projects are used to provide variety and avoid the monotony of a running problem. The authors avoid the dangers of trying to teach all there is to know about each topic by using a spiral approach - introducing topics in a simple context early on and then revisiting later to deepen understanding. Throughout, the emphasis is on developing a practical approach to programming, with students encouraged to add code to existing programs rather than working with an intimidating sheet of blank paper.   Supplements:   Author's Companion Website: http://www.bluej.org/objects-first/ Includes Java Resource Links, Book Projects, Code Style Guide,  Student Activities and more!   Instructor-only Resources (Registration required): Power Point lecture slides Solutions to exercises Click on the "Resources" Tab above to view these downloadable files

Table of Contents:
Part 1 FOUNDATIONS OF OBJECT ORIENTATION   Chapter 1 Objects and classes   1.1 Objects and classes   1.2 Creating objects   1.3 Calling methods   1.4 Parameters   1.5 Data types   1.6 Multiple instances   1.7 State   1.8 What is in an object?   1.9 Object interaction   1.10 Source code   1.11 Another example   1.12 Return values   1.13 Objects as parameters   1.14 Summary       Chapter 2 Understanding class definitions   2.1 Ticket machines   2.1.1 Exploring the behavior of a naïve ticket machine   2.2 Examining a class definition   2.3 Fields, constructors, and methods   2.3.1 Fields   2.3.2 Constructors   2.4 Passing data via parameters   2.5 Assignment   2.6 Accessor methods    2.7 Mutator methods   2.8 Printing from methods    2.9 Summary of the naïve ticket machine   2.10 Reflecting on the design of the ticket machine   2.11 Making choices: the conditional statement   2.12 A further conditional-statement example   2.13 Local variables   2.14 Fields, parameters, and local variables   2.15 Summary of the better ticket machine   2.16 Self-review exercises   2.17 Reviewing a familiar example   2.18 Summary       Chapter 3 Object interaction   3.1 The clock example   3.2 Abstraction and modularization   3.3 Abstraction in software   3.4 Modularization in the clock example   3.5 Implementing the clock display   3.6 Class diagrams versus object diagrams   3.7 Primitive types and object types   3.8 The ClockDisplay source code   3.8.1 Class NumberDisplay   3.8.2 String concatenation   3.8.3 The modulo operator   3.8.4 Class ClockDisplay   3.9 Objects creating objects   3.10 Multiple constructors   3.11 Method calls   3.11.1 Internal method calls   3.11.2 External method calls   3.11.3 Summary of the clock display   3.12 Another example of object interaction   3.12.1 The mail system example   3.12.2 The this keyword   3.13 Using a debugger   3.13.1 Setting breakpoints   3.13.2 Single stepping   3.13.3 Stepping into methods   3.14 Method calling revisited   3.15 Summary       Chapter 4 Grouping objects   4.1 Grouping objects in flexible-size collections   4.2 A personal notebook   4.3 A first look at library classes   4.3.1 An example of using a library   4.4 Object structures with collections   4.5 Generic classes   4.6 Numbering within collections   4.7 Removing an item from a collection   4.8 Processing a whole collection   4.8.1 The for-each loop   4.8.2 The while loop   4.8.3 Iterating over a collection   4.8.4 Index access versus iterators   4.9 Summary of the notebook example   4.10 Another example: an auction system   4.10.1 The Lot class   4.10.2 The Auction class   4.10.3 Anonymous objects   4.10.4 Using collections   4.11 Flexible collection summary   4.12 Fixed-size collections   4.12.1 A log-file analyzer   4.12.2 Declaring array variables   4.12.3 Creating array objects   4.12.4 Using array objects   4.12.5 Analyzing the log file   4.12.6 The for loop   4.13 Summary       Chapter 5 More sophisticated behavior   5.1 Documentation for library classes   5.2 The TechSupport system   5.2.1 Exploring the TechSupport system   5.2.2 Reading the code   5.3 Reading class documentation   5.3.1 Interfaces versus implementation   5.3.2 Using library-class methods   5.3.3 Checking string equality   5.4 Adding random behavior   5.4.1 The Random class   5.4.2 Random numbers with limited range   5.4.3 Generating random responses   5.4.4 Reading documentation for parameterized classes   5.5 Packages and import   5.6 Using maps for associations   5.6.1 The concept of a map   5.6.2 Using a HashMap   5.6.3 Using a map for the TechSupport system   5.7 Using sets   5.8 Dividing strings   5.9 Finishing the TechSupport system   5.10 Writing class documentation   5.10.1 Using javadoc in BlueJ   5.10.2 Elements of class documentation   5.11 Public versus private   5.11.1 Information hiding   5.11.2 Private methods and public fields   5.12 Learning about classes from their interfaces   5.13 Class variables and constants   5.13.1 The static key word   5.13.2 Constants   5.14 Summary       Chapter 6 Well-behaved objects   6.1 Introduction   6.2 Testing and debugging   6.3 Unit testing within BlueJ   6.3.1 Using inspectors   6.3.2 Positive versus negative testing   6.4 Test automation   6.4.1 Regression testing   6.4.2 Automated checking of test results   6.4.3 Recording a test   6.4.4 Fixtures   6.5 Modularization and interfaces   6.6 A debugging scenario   6.7 Commenting and style   6.8 Manual walkthroughs   6.8.1 A high-level walkthrough   6.8.2 Checking state with a walkthrough   6.8.3 Verbal walkthroughs   6.9 Print statements   6.9.1 Turning debugging information on or off   6.10 Choosing a test strategy   6.11 Debuggers   6.12 Putting the techniques into practice   6.13 Summary       Chapter 7 Designing classes   7.1 Introduction   7.2 The world-of-zuul game example   7.3 Introduction to coupling and cohesion   7.4 Code duplication   7.5 Making extensions   7.5.1 The task   7.5.2 Finding the relevant source code   7.6 Coupling   7.6.1 Using encapsulation to reduce coupling   7.7 Responsibility-driven design   7.7.1 Responsibilities and coupling   7.8 Localizing change   7.9 Implicit coupling   7.10 Thinking ahead   7.11 Cohesion   7.11.1 Cohesion of methods   7.11.2 Cohesion of classes   7.11.3 Cohesion for readability   7.11.4 Cohesion for reuse   7.12 Refactoring   7.12.1 Refactoring and testing   7.12.2 An example of refactoring   7.13 Refactoring for language independence   7.13.1 Enumerated types   7.13.2 Further decoupling of the command interface   7.14 Design guidelines   7.15 Executing without BlueJ   7.15.1 Class methods   7.15.2 The main method   7.15.3 Limitations of class methods   7.16 Summary       Part 2 APPLICATION STRUCTURES       Chapter 8 Improving structure with inheritance   8.1 The DoME example   8.1.1 DoME classes and objects   8.1.2 DoME source code   8.1.3 Discussion of the DoME application   8.2 Using inheritance   8.3 Inheritance hierarchies   8.4 Inheritance in Java   8.4.1 Inheritance and access rights   8.4.2 Inheritance and initialization   8.5 DoME: adding other item types   8.6 Advantages of inheritance (so far)   8.7 Subtyping   8.7.1 Subclasses and subtypes   8.7.2 Subtyping and assignment   8.7.3 Subtyping and parameter passing   8.7.4 Polymorphic variables   8.7.5 Casting   8.8 The Object class   8.9 Autoboxing and Wrapper classes   8.10 The collection hierarchy   8.11 Summary       Chapter 9 More about inheritance   9.1 The problem: DoME’s print method   9.2 Static type and dynamic type   9.2.1 Calling print from Database   9.3 Overriding   9.4 Dynamic method lookup   9.5 Super call in methods   9.6 Method polymorphism   9.7 Object methods: toString   9.8 Protected access   9.9 Another example of inheritance with overriding   9.10 Summary       Chapter 10 Further abstraction techniques   10.1 Simulations   10.2 The foxes-and-rabbits simulation   10.2.1 The foxes-and-rabbits project   10.2.2 The Rabbit class   10.2.3 The Fox class   10.2.4 The Simulator class: setup   10.2.5 The Simulator class: a simulation step   10.2.6 Taking steps to improve the simulation   10.3 Abstract classes   10.3.1 The Animal superclass   10.3.2 Abstract methods   10.3.3 Abstract classes   10.4 More abstract methods   10.5 Multiple inheritance   10.5.1 An Actor class   10.5.2 Flexibility through abstraction   10.5.3 Selective drawing   10.5.4 Drawable actors: multiple inheritance   10.6 Interfaces   10.6.1 An Actor interface   10.6.2 Multiple inheritance of interfaces   10.6.3 Interfaces as types   10.6.4 Interfaces as specifications   10.6.5 A further example of interfaces   10.6.6 Abstract class or interface?   10.7 Summary of inheritance   10.8 Summary       Chapter 11 Building graphical user interfaces   11.1 Introduction   11.2 Components, layout, and event handling   11.3 AWT and Swing   11.4 The ImageViewer example   11.4.1 First experiments: creating a frame   11.4.2 Adding simple components   11.4.3 Adding menus   11.4.4 Event handling   11.4.5 Centralized receipt of events   11.4.6 Inner classes   11.4.7 Anonymous inner classes   11.5 ImageViewer 1.0: the first complete version   11.5.1 Image-processing classes   11.5.2 Adding the image   11.5.3 Layout   11.5.4 Nested containers   11.5.5 Image filters   11.5.6 Dialogs   11.6 ImageViewer 2.0: improving program structure   11.7 ImageViewer 3.0: more interface components   11.7.1 Buttons   11.7.2 Borders   11.8 Further extensions   11.9 Another example: SoundPlayer338   11.10 Summary       Chapter 12 Handling errors   12.1 The address-book project   12.2 Defensive programming   12.2.1 Client—server interaction   12.2.2 Argument checking   12.3 Server error reporting   12.3.1 Notifying the user   12.3.2 Notifying the client object   12.4 Exception-throwing principles   12.4.1 Throwing an exception   12.4.2 Exception classes   12.4.3 The effect of an exception   12.4.4 Unchecked exceptions   12.4.5 Preventing object creation   12.5 Exception handling   12.5.1 Checked exceptions: the throws clause   12.5.2 Catching exceptions: the try statement   12.5.3 Throwing and catching multiple exceptions   12.5.4 Propagating an exception   12.5.5 The finally clause   12.6 Defining new exception classes   12.7 Using assertions   12.7.1 Internal consistency checks   12.7.2 The assert statement   12.7.3 Guidelines for using assertions   12.7.4 Assertions and the BlueJ unit testing framework   12.8 Error recovery and avoidance   12.8.1 Error recovery   12.8.2 Error avoidance   12.9 Case study: text input/output   12.9.1 Readers, writers, and streams   12.9.2 The address-book-io project   12.9.3 Text output with FileWriter   12.9.4 Text input with FileReader   12.9.5 Scanner: reading input from the terminal   12.9.6 Object serialization   12.10 Summary       Chapter 13 Designing applications   13.1 Analysis and design   13.1.1 The verb/noun method   13.1.2 The cinema booking example   13.1.3 Discovering classes   13.1.4 Using CRC cards   13.1.5 Scenarios   13.2 Class design   13.2.1 Designing class interfaces   13.2.2 User interface design   13.3 Documentation   13.4 Cooperation   13.5 Prototyping   13.6 Software growth   13.6.1 Waterfall model   13.6.2 Iterative development   13.7 Using design patterns   13.7.1 Structure of a pattern   13.7.2 Decorator   13.7.3 Singleton   13.7.4 Factory method   13.7.5 Observer   13.7.6 Pattern summary   13.8 Summary       Chapter 14 A case study   14.1 The case study   14.1.1 The problem description   14.2 Analysis and design   14.2.1 Discovering classes   14.2.2 Using CRC cards   14.2.3 Scenarios   14.3 Class design   14.3.1 Designing class interfaces   14.3.2 Collaborators   14.3.3 The outline implementation   14.3.4 Testing   14.3.5 Some remaining issues   14.4 Iterative development   14.4.1 Development steps   14.4.2 A first stage   14.4.3 Testing the first stage   14.4.4 A later stage of development   14.4.5 Further ideas for development   14.4.6 Reuse   14.5 Another example   14.6 Taking things further       Appendices   A Working with a BlueJ project   B Java data types   C Java control structures   D Operators   E Running Java without BlueJ   F Configuring BlueJ   G Using the debugger   H JUnit unit-testing tools   I Javadoc   J Program style guide   K Important library classes  

About the Author :
David Barnes is a Lecturer in Computer Science at the University of Kent, in Canterbury, England. He has been teaching introductory programming for over 25 years, and has practical experience of a wide range of programming languages. He has been teaching object-oriented programming in Java for over 10 years. David is passionate about the excitement that is inherent in computer science and is actively involved in promoting it as a subject area to high-school children. In addition to computing education, his main research is in the area of software engineering.   Michael Kölling is a Senior Lecturer at the Computing Laboratory, University of Kent, in Canterbury, England. He holds a PhD in computer science from Sydney University, and has worked in Australia, Denmark and the UK. Michael’s research interests are in the areas of object-oriented systems, programming languages, software tools, computing education. He has published numerous papers on object-orientation and computing education topics. Michael is one of the developers of BlueJ and, more recently, the Greenfoot platform.