Objects First With Java

Objects First With Java : A Practical Introduction Using BlueJ: United States Edition

3.58 (150 ratings by Goodreads)
By (author)  , By (author) 

List price: US$101.99

Currently unavailable

Add to wishlist

AbeBooks may have this title (opens in new window).

Try AbeBooks

Description

For introductory courses in Java/Introduction to Programming and Object-Oriented Programming.

With its emphasis on visualization and interaction techniques, teaching students objects from day one is now possible with Objects First with Java, 4/E. It uses BlueJ to get students started on object-oriented programming from day one unlike most texts, which delay coverage so that students don't have to switch thought processes midstream. Barnes and Kolling strategically do not cover traditional topics like control structures, preserving their goal of teaching object-oriented principles.

The authors incorporate a "spiral approach" throughout the text. This introduces a topic in a simple context early on, then revisits it later to increase student comprehension. This enables the understanding of many topics while broadening knowledge. Loaded with projects, the book is organized around software development tasks versus the language features to promote good problem solving skills. The number of interesting examples provides student with lots of applications
show more

Product details

  • Mixed media product | 560 pages
  • 191 x 235 x 30.48mm | 9,070g
  • Pearson
  • United States
  • English
  • 4th edition
  • ill
  • 0136060862
  • 9780136060864
  • 745,736

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 naive 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 naive 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
show more

About David J. Barnes

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 Koelling 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.
show more

Rating details

150 ratings
3.58 out of 5 stars
5 29% (44)
4 27% (41)
3 23% (35)
2 13% (19)
1 7% (11)
Book ratings by Goodreads
Goodreads is the world's largest site for readers with over 50 million reviews. We're featuring millions of their reader ratings on our book pages to help you find your new favourite book. Close X