Objects First with Java
A Practical Introduction Using BlueJ
This item is unavailable.
We will email you if this item comes back into stock.
|Format:||Mixed media product, 560 pages, 4th International ed Edition|
|Other Information: ||Illustrations (some col.)|
|Published In: ||United States, 01 August 2008|
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 Please Note If you are using the U.S. Edition of this book, you can download instructor resources from http://www.pearsonhighered.com/educator/product/Objects-First-With-Java-A-Practical-Introduction-Using-BlueJ/9780136060864.page Use your IRC login and password from website to log in.
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
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 Kolling 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.
|Publisher: ||Pearson Education (US)|
|Dimensions: ||23.0 x 20.0 x 2.0 centimeters (0.96 kg)|