skip to content
Objects first with Java : a practical introduction using BlueJ Preview this item
ClosePreview this item

Objects first with Java : a practical introduction using BlueJ

Author: David J Barnes; Michael Kölling
Publisher: Harlow [u.a.]: Pearson, 2006.
Edition/Format:   Print book : English : 3. edView all editions and formats
The book has a very clear identity. It takes a truly objects first approach to teaching problem solving using Java. These are complicated concepts so the book uses the development environment BlueJ to help the student's understanding. BlueJ has a strong emphasis on visualization and interaction techniques, and allows the students to manipulate objects and call methods as a first exercise. BlueJ is free and freely  Read more...

(not yet rated) 0 with reviews - Be the first.

More like this


Find a copy online

Links to this item

Find a copy in the library

&AllPage.SpinnerRetrieving; Finding libraries that hold this item...


Material Type: Internet resource
Document Type: Book, Internet Resource
All Authors / Contributors: David J Barnes; Michael Kölling
ISBN: 013197629X 9780131976290
OCLC Number: 255147677
Notes: Includes index.
Previous ed.: 2005.
Description: XXX1, 480 S : Ill., graph. Darst + CD-ROM (12 cm)
Contents: Contents Foreword Preface to the instructor List of projects discussed in detail in this book Acknowledgements 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 Index
Responsibility: David J. Barnes and Michael Kölling.


BlueJ has a strong emphasis on visualization and interaction techniques, and allows the students to manipulate objects and call methods as a first exercise. This book teaches problem solving using  Read more...


User-contributed reviews
Retrieving GoodReads reviews...
Retrieving DOGObooks reviews...


Be the first.
Confirm this request

You may have already requested this item. Please select Ok if you would like to proceed with this request anyway.

Linked Data

schema:name"Object-oriented programming (Computer science)"
schema:bookEdition"3. ed."
schema:description"The book has a very clear identity. It takes a truly objects first approach to teaching problem solving using Java. These are complicated concepts so the book uses the development environment BlueJ to help the student's understanding. BlueJ has a strong emphasis on visualization and interaction techniques, and allows the students to manipulate objects and call methods as a first exercise. BlueJ is free and freely available, and has been developed specifically for teaching. The book is loaded with projects so that the student can really get a grip on actually solving problems; and it takes a spiral approach , introducing a topic in a simple context early on, then revisiting it later in the book to deepen understanding. It also comes with a CD containing JDK, BlueJ, a BlueJ tutorial and code for all the projects. The website contains style guide for all examples, PowerPoints for lecturers and also a Solutions Manual."
schema:name"Objects first with Java : a practical introduction using BlueJ"

Content-negotiable representations

Close Window

Please sign in to WorldCat 

Don't have an account? You can easily create a free account.