Bluej exercise solutions chapter 6

Java Programming

This lab continues the Zuul project.Make a copy of your Lab 1 Zuul project folder (e.g., the folder named LastName-zuul1) and save it as LastName-zuul, using your last name, e.g., Smith-zuul.
Set up a Git repository for your Zuul project by following the instructions Set Up a Repository for a Project. (Start following along at 0:25 in the video since you already have an existing project.)
In Git, create a branch called 'zuul2-refactoring' and move onto the branch. You will do all your work for this lab on this branch, committing after each exercise.git branch zuul2-refactoring git checkout zuul2-refactoring
Complete Exercises 6e: 8.5, 8.6, 8.7, 8.8, 8.11 .
After each exercise:
Test your program. The changes you make in these exercises are refactorings and should not change the behavior of the game. After each step make sure everything still works as it did before.
Don't forget to document your changes.
For any changed classes, be sure your name is in the @author list and update the version.
As you add and update methods make sure each method has a comment header that correctly describes its behavior using javadoc, including @param and @return tags.
When an exercise is complete, commit your changes in Git with a commit message indicating the exercise you just completed as well as a brief description of the changes you made. For example:git add . git commit -m"Completed exercise 8.5 - extracted method printLocationInfo"
It is critical that you commit after each exercise so that all exercises can be graded. Later exercises change the code from earlier exercises, and the instructor will be able to grade the early exercises by looking back in your commit history.
When you have completed all the exercises, make sure your branch is clean. (When you do 'git status' it should say "On branch zuul2-refactoring. nothing to commit, working tree clean")
Merge your branch into the master:git checkout master git merge zuul2-refactoring
Create a zip file of your entire project folder, and name it LastName-zuul2.zip

Home>Computer Science homework help>java programming
(Objects First with Java_ A Practical Introduction Using BlueJ 6th Edition) David J. Barnes & Michael Kölling - Objects First with Java_ A Practical Introduction Using BlueJ. 6-Pearson (2016).pdf
David J. Barnes and Michael Kölling

University of Kent

Sixth Edition

Objects First with Java™

A Practical Introduction Using BlueJ

Boston Columbus Indianapolis New York San Francisco Hoboken Amsterdam Cape Town Dubai London Madrid Milan Munich Paris Montreal Toronto

Delhi Mexico City Sao Paulo Sydney Hong Kong Seoul Singapore Taipei Tokyo

A01_BARN7367_06_SE_FM.indd 1 4/15/16 6:10 PM

Byron
Vice President, Editorial Director, ECS: Marcia Horton Executive Editor: Tracy Johnson Editorial Assistant: Kristy Alaura Vice President of Marketing: Christy Lesko Director of Field Marketing: Tim Galligan Field Marketing Manager: Demetrius Hall Marketing Assistant: Jon Bryant Director of Product Management: Erin Gregg Team Lead, Program and Project Management: Scott Disanno Program Manager: Carole Snyder Project Manager: Camille Trentacoste Senior Specialist, Program Planning and Support: Maura Zaldivar-Garcia Cover Designer: Marta Samsel Cover Art: brm1949/Fotolia Inventory Manager: Ann Lam Media Project Manager: Leslie Sumrall Full-Service Project Management, Composition, and Art: Chandrasekar Subramanian, SPi Global Printer/Bindery: R.R. Donnelley/Crawfordsville Cover printer: Phoenix Color/Hagerstown

Copyright © 2017, 2012, 2009, 2006, 2005, 2003 by Pearson Education. All rights reserved. Manufactured in the United States of America. This publication is protected by Copyright, and permission should be obtained from the publisher prior to any prohibited reproduction, storage in a retrieval system, or transmission in any form or by any means, electronic, mechanical, photocopying, record- ing, or likewise. For information regarding permissions, request forms and the appropriate contacts within the Pearson Education Global Rights & Permissions department, please visit www.pearsoned.com/permissions/.

PEARSON, and ALWAYS LEARNING are exclusive trademarks in the U.S. and/or other countries owned by Pearson Education, Inc. or its affiliates.

Unless otherwise indicated herein, any third-party trademarks that may appear in this work are the property of their respective own- ers and any references to third-party trademarks, logos or other trade dress are for demonstrative or descriptive purposes only. Such references are not intended to imply any sponsorship, endorsement, authorization, or promotion of Pearson’s products by the owners of such marks, or any relationship between the owner and Pearson Education, Inc. or its affiliates, authors, licensees or distributors.

The programs and applications presented in this book have been included for their instructional value. They have been tested with care, but are not guaranteed for any particular purpose. The publisher does not offer any warranties or representations, nor does it accept any liabilities with respect to the programs or applications.

Library of Congress Cataloging-in-Publication Data

Names: Barnes, David J. (David John), 1959 June 7- author. | Kolling, Michael, author. Title: Objects first with Java : a practical introduction using BlueJ / David J. Barnes and Michael Kolling, University of Kent. Description: Sixth edition. | Boston : Pearson Education Inc., [2017] Identifiers: LCCN 2016009911| ISBN 9780134477367 | ISBN 0134477367 Subjects: LCSH: Object-oriented programming (Computer science) | Java (Computer program language) | Computer science—Study and teaching. Classification: LCC QA76.64 .B385 2017 | DDC 005.1/17—dc23 LC record available at http://lccn.loc.gov/2016009911

10 9 8 7 6 5 4 3 2 1

ISBN-10: 0-13-447736-7 ISBN-13: 978-0-13-447736-7

A01_BARN7367_06_SE_FM.indd 2 4/15/16 6:10 PM

http://www.pearsoned.com/permissions
http://lccn.loc.gov/2016009911
To my wife Helen,

djb

To K.W.

mk

A01_BARN7367_06_SE_FM.indd 3 4/15/16 6:10 PM

This page intentionally left blank

Foreword 14 Preface 15 List of Projects Discussed in Detail in This Book 25 Acknowledgments 28

Part 1 Foundations of Object Orientation 29

Chapter 1 Objects and Classes 31

1.1 Objects and classes 31 1.2 Creating objects 32 1.3 Calling methods 33 1.4 Parameters 34 1.5 Data types 35 1.6 Multiple instances 36 1.7 State 37 1.8 What is in an object? 38 1.9 Java code 39 1.10 Object interaction 40 1.11 Source code 41 1.12 Another example 43 1.13 Return values 43 1.14 Objects as parameters 44 1.15 Summary 45

Chapter 2 Understanding Class Definitions 49

2.1 Ticket machines 49 2.2 Examining a class definition 51 2.3 The class header 53 2.4 Fields, constructors, and methods 54 2.5 Parameters: receiving data 60 2.6 Assignment 62

Contents

A01_BARN7367_06_SE_FM.indd 5 4/15/16 6:10 PM

6 | Contents

2.7 Methods 63 2.8 Accessor and mutator methods 64 2.9 Printing from methods 67 2.10 Method summary 70 2.11 Summary of the naíve ticket machine 70 2.12 Reflecting on the design of the ticket machine 71 2.13 Making choices: the conditional statement 73 2.14 A further conditional-statement example 75 2.15 Scope highlighting 76 2.16 Local variables 77 2.17 Fields, parameters, and local variables 79 2.18 Summary of the better ticket machine 81 2.19 Self-review exercises 81 2.20 Reviewing a familiar example 83 2.21 Calling methods 85 2.22 Experimenting with expressions: the Code Pad 87 2.23 Summary 89

Chapter 3 Object Interaction 95

3.1 The clock example 95 3.2 Abstraction and modularization 96 3.3 Abstraction in software 97 3.4 Modularization in the clock example 97 3.5 Implementing the clock display 98 3.6 Class diagrams versus object diagrams 99 3.7 Primitive types and object types 100 3.8 The NumberDisplay class 100 3.9 The ClockDisplay class 108 3.10 Objects creating objects 111 3.11 Multiple constructors 112 3.12 Method calls 112 3.13 Another example of object interaction 116 3.14 Using a debugger 120 3.15 Method calling revisited 124 3.16 Summary 125

Chapter 4 Grouping Objects 129

4.1 Building on themes from Chapter 3 129 4.2 The collection abstraction 130

A01_BARN7367_06_SE_FM.indd 6 4/15/16 6:10 PM

Contents | 7

4.3 An organizer for music files 131 4.4 Using a library class 132 4.5 Object structures with collections 135 4.6 Generic classes 137 4.7 Numbering within collections 138 4.8 Playing the music files 141 4.9 Processing a whole collection 143 4.10 Indefinite iteration 148 4.11 Improving structure—the Track class 156 4.12 The Iterator type 159 4.13 Summary of the music-organizer project 163 4.14 Another example: an auction system 165 4.15 Summary 175

Chapter 5 Functional Processing of Collections (Advanced) 177

5.1 An alternative look at themes from Chapter 4 177 5.2 Monitoring animal populations 178 5.3 A first look at lambdas 182 5.4 The forEach method of collections 184 5.5 Streams 186 5.6 Summary 196

Chapter 6 More-Sophisticated Behavior 199

6.1 Documentation for library classes 200 6.2 The TechSupport system 201 6.3 Reading class documentation 206 6.4 Adding random behavior 211 6.5 Packages and import 217 6.6 Using maps for associations 218 6.7 Using sets 223 6.8 Dividing strings 223 6.9 Finishing the TechSupport system 225 6.10 Autoboxing and wrapper classes 227 6.11 Writing class documentation 229 6.12 Public versus private 232 6.13 Learning about classes from their interfaces 234 6.14 Class variables and constants 239 6.15 Class methods 242 6.16 Executing without BlueJ 244

A01_BARN7367_06_SE_FM.indd 7 4/15/16 6:10 PM

8 | Contents

6.17 Further advanced material 244 6.18 Summary 248

Chapter 7 Fixed-Size Collections—Arrays 251

7.1 Fixed-size collections 251 7.2 Arrays 252 7.3 A log-file analyzer 252 7.4 The for loop 258 7.5 The automaton project 264 7.6 Arrays of more than one dimension (advanced) 272 7.7 Arrays and streams (advanced) 279 7.8 Summary 280

Chapter 8 Designing Classes 283

8.1 Introduction 284 8.2 The world-of-zuul game example 285 8.3 Introduction to coupling and cohesion 287 8.4 Code duplication 288 8.5 Making extensions 291 8.6 Coupling 294 8.7 Responsibility-driven design 298 8.8 Localizing change 301 8.9 Implicit coupling 302 8.10 Thinking ahead 305 8.11 Cohesion 306 8.12 Refactoring 310 8.13 Refactoring for language independence 314 8.14 Design guidelines 319 8.15 Summary 320

Chapter 9 Well-Behaved Objects 323

9.1 Introduction 323 9.2 Testing and debugging 324 9.3 Unit testing within BlueJ 325 9.4 Test automation 332 9.5 Refactoring to use streams (advanced) 339 9.6 Debugging 340 9.7 Commenting and style 342 9.8 Manual walkthroughs 343

A01_BARN7367_06_SE_FM.indd 8 4/15/16 6:10 PM

Contents | 9

9.9 Print statements 348 9.10 Debuggers 352 9.11 Debugging streams (advanced) 353 9.12 Choosing a debugging strategy 354 9.13 Putting the techniques into practice 355 9.14 Summary 355

Part 2 Application Structures 357

Chapter 10 Improving Structure with Inheritance 359

10.1 The network example 359 10.2 Using inheritance 371 10.3 Inheritance hierarchies 373 10.4 Inheritance in Java 374 10.5 Network: adding other post types 377 10.6 Advantages of inheritance (so far) 379 10.7 Subtyping 380 10.8 The Object class 386 10.9 The collection hierarchy 387 10.10 Summary 388

Chapter 11 More about Inheritance 391

11.1 The problem: network’s display method 391 11.2 Static type and dynamic type 393 11.3 Overriding 396 11.4 Dynamic method lookup 398 11.5 super call in methods 401 11.6 Method polymorphism 402 11.7 Object methods: toString 402 11.8 Object equality: equals and hashCode 405 11.9 Protected access 407 11.10 The instanceof operator 409 11.11 Another example of inheritance with overriding 410 11.12 Summary 413

Chapter 12 Further Abstraction Techniques 417

12.1 Simulations 417 12.2 The foxes-and-rabbits simulation 418 12.3 Abstract classes 433

A01_BARN7367_06_SE_FM.indd 9 4/15/16 6:10 PM

10 | Contents

12.4 More abstract methods 440 12.5 Multiple inheritance 442 12.6 Interfaces 445 12.7 A further example of interfaces 453 12.8 The Class class 455 12.9 Abstract class or interface? 455 12.10 Event-driven simulations 456 12.11 Summary of inheritance 457 12.12 Summary 458

Chapter 13 Building Graphical User Interfaces 461

13.1 Introduction 461 13.2 Components, layout, and event handling 462 13.3 AWT and Swing 463 13.4 The ImageViewer example 463 13.5 ImageViewer 1.0: the first complete version 475 13.6 ImageViewer 2.0: improving program structure 489 13.7 ImageViewer 3.0: more interface components 495 13.8 Inner classes 499 13.9 Further extensions 504 13.10 Another example: MusicPlayer 506 13.11 Summary 509

Chapter 14 Handling Errors 511

14.1 The address-book project 512 14.2 Defensive programming 516 14.3 Server error reporting 519 14.4 Exception-throwing principles 523 14.5 Exception handling 529 14.6 Defining new exception classes 536 14.7 Using assertions 538 14.8 Error recovery and avoidance 541 14.9 File-based input/output 544 14.10 Summary 555

Chapter 15 Designing Applications 557

15.1 Analysis and design 557 15.2 Class design 564 15.3 Documentation 566

A01_BARN7367_06_SE_FM.indd 10 4/15/16 6:10 PM

Contents | 11

15.4 Cooperation 567 15.5 Prototyping 567 15.6 Software growth 568 15.7 Using design patterns 570 15.8 Summary 576

Chapter 16 A Case Study 579

16.1 The case study 579 16.2 Analysis and design 580 16.3 Class design 584 16.4 Iterative development 589 16.5 Another example 598 16.6 Taking things further 598

Appendix A: Working with a BlueJ Project 599

A.1 Installing BlueJ 599 A.2 Opening a project 599 A.3 The BlueJ debugger 599 A.4 Configuring BlueJ 599 A.5 Changing the interface language 600 A.6 Using local API documentation 600 A.7 Changing the new class templates 600

Appendix B: Java Data Types 601

B.1 Primitive types 601 B.2 Casting of primitive types 602 B.3 Object types 602 B.4 Wrapper classes 603 B.5 Casting of object types 603

Appendix C: Operators 605

C.1 Arithmetic expressions 605 C.2 Boolean expressions 606 C.3 Short-circuit operators 607

Appendix D: Java Control Structures 609

D.1 Control structures 609 D.2 Selection statements 609

A01_BARN7367_06_SE_FM.indd 11 4/15/16 6:10 PM

12 | Contents

D.3 Loops 611 D.4 Exceptions 613 D.5 Assertions 615

Appendix E: Running Java without BlueJ 617

E.1 Executing without BlueJ 617 E.2 Creating executable .jar files 619 E.3 Developing without BlueJ 619

Appendix F: Using the Debugger 621

F.1 Breakpoints 622 F.2 The control buttons 622 F.3 The variable displays 623 F.4 The Call Sequence display 624 F.5 The Threads display 624

Appendix G: JUnit Unit-Testing Tools 625

G.1 Enabling unit-testing functionality 625 G.2 Creating a test class 625 G.3 Creating a test method 625 G.4 Test assertions 626 G.5 Running tests 626 G.6 Fixtures 626

Appendix H: Teamwork Tools 627

H.1 Server setup 627 H.2 Enabling teamwork functionality 627 H.3 Sharing a project 627 H.4 Using a shared project 627 H.5 Update and commit 628 H.6 More information 628

Appendix I: Javadoc 629

I.1 Documentation comments 629 I.2 BlueJ support for javadoc 631

Appendix J: Program Style Guide 633

J.1 Naming 633 J.2 Layout 633

A01_BARN7367_06_SE_FM.indd 12 4/15/16 6:10 PM

J.3 Documentation 634 J.4 Language-use restrictions 635 J.5 Code idioms 636

Appendix K: Important Library Classes 637

K.1 The java.lang package 637 K.2 The java.util package 638 K.3 The java.io and java.nio.file packages 639 K.4 The java.util.function package 640 K.5 The java.net package 640 K.6 Other important packages 641

Appendix L: Concept Glossary 643

Index 649

Contents | 13

A01_BARN7367_06_SE_FM.indd 13 4/15/16 6:10 PM

Foreword

by James Gosling, creator of Java

Watching my daughter Kate and her middle-school classmates struggle through a Java course using a commercial IDE was a painful experience. The sophistication of the tool added significant complexity to the task of learning. I wish that I had understood earlier what was happening. As it was, I wasn’t able to talk to the instructor about the problem until it was too late. This is exactly the sort of situation for which BlueJ is a perfect fit.

BlueJ is an interactive development environment with a mission: it is designed to be used by students who are learning how to program. It was designed by instructors who have been in the classroom facing this problem every day. It’s been refreshing to talk to the folks who developed BlueJ: they have a very clear idea of what their target is. Discussions tended to focus more on what to leave out, than what to throw in. BlueJ is very clean and very targeting.

Nonetheless, this book isn’t about BlueJ. It is about programming.

In Java.

Over the past several years Java has become widely used in the teaching of programming. This is for a number of reasons. One is that Java has many characteristics that make it easy to teach: it has a relatively clean definition; extensive static analysis by the compiler informs students of problems early on; and it has a very robust memory model that eliminates most “mysterious” errors that arise when object boundaries or the type system are compromised. Another is that Java has become commercially very important.

This book confronts head-on the hardest concept to teach: objects. It takes students from their very first steps all the way through to some very sophisticated concepts.

It manages to solve one of the stickiest questions in writing a book about programming: how to deal with the mechanics of actually typing in and running a program. Most books silently skip over the issue, or touch it lightly, leaving the instructor with the burden of figuring out how to relate the book’s material to the actual steps that students have to go through to solve the exercises. Instead, this book assumes the use of BlueJ and is able to integrate the tasks of understanding the concepts with the mechanics of how students can explore them.

I wish it had been around for my daughter last year. Maybe next year . . .

A01_BARN7367_06_SE_FM.indd 14 4/15/16 6:10 PM

Preface

New to the sixth edition This is the sixth edition of this book, and—as always with a new edition—the content has been adapted to the latest developments in object-oriented programs. Many of the changes this time can, on the surface, be attributed to a new version of Java: Java 8. This version was released in 2014 and is now very widely used in practice. In fact, it is the fastest adoption of any new Java version ever released; so it is time also to change the way we teach novice students. The changes are, however, more than merely the addition of a few new language constructs. The most significant new aspects in Java 8 center around new constructs to support a (partial) functional programming style. And it is the growing popularity of functional programming that is driving this change. The difference is much deeper, and much more fundamental, than just adding new syntax. And it is the renaissance of the functional ideas in modern programming generally—not only the existence of Java 8—that makes it timely to cover these aspects in a modern edition of a programming textbook. The ideas and techniques of functional programming, while fairly old and well known in principle, have seen a marked boost of popularity in recent years, with new languages being developed and selected functional techniques being incorporated into existing, traditionally imperative languages. One of the primary reasons for this is the change in computing hardware available, and also the changing nature of problems we wish to tackle. Almost all programming platforms now are concurrent. Even mid-range laptops and mobile phones now have processors with multiple cores, making parallel processing a real possibil- ity on everyday devices. But, in practice this is not happening on a large scale. Writing applications that make optimal use of concurrent processing and multiple proces- sors is very, very difficult. Most applications available today do not exploit current hard- ware to a degree approaching anything that is theoretically possible. This is not going to change much: the opportunity (and challenge) of parallel hardware will remain, and programming these devices with traditional imperative languages will not get any easier. This is where functional programming enters the picture.

A01_BARN7367_06_SE_FM.indd 15 4/15/16 6:10 PM

16 | Preface

With functional language constructs, it is possible to automate some concurrency very efficiently. Programs can potentially make use of multiple cores without much effort on the side of the programmer. Functional constructs have other advantages—more elegant expression for certain problems and often clearer readability—but it is the ability to deal with parallelism that will ensure that functional aspects of programming are going to stay with us for a long time to come. Every teacher who wants to prepare their students for the future should give them some understanding of functional aspects as well. Without it, one will no longer be able to become a master programmer. A novice certainly does not have to master all of functional program- ming, but a basic understanding of what it is—and what we can achieve with it—is rapidly becoming essential. Exactly when functional techniques should be introduced is an interesting question. We do not believe that there is a single right answer for this; various sequences are possible. Functional programming could be covered as an advanced topic at the end of the traditional corpus of this book, or it could be addressed when we first encounter the topics where it is applicable, as an alternative to the imperative techniques. It could even be covered first. An additional question is how to treat the traditional style of programming in those areas where functional constructs are now available: should they be replaced, or do both need to be covered? For this book, we recognize that different teachers will have different constraints and preferences. Therefore, we have designed a structure that—we hope—allows different approaches, depending on the preference of the learner or teacher.

■ We have not replaced the “old-style” techniques. We cover the new, functional approach in addition to the existing material. Functional constructs in Java are most prominent when working with collections of objects, and the mastering traditional approach—using loops and explicit iteration—is still essential for any programmer. Not only are there millions of lines of code out there that are written in this style—and will be continued to be written in this style—but there are also specific cases where it is necessary to use these techniques even if one generally favors the new functional constructs. Mastering both is the goal.

■ We present the new functional-construct-oriented material in the book where we discuss the problems that these constructs address. For example, we address functional collection processing as soon as we encounter collections.

■ Chapters and sections covering this new material are, however, clearly marked as “advanced,” and are structured in a manner that they can safely be skipped on first read- ing (or left out altogether).

■ The previous two points enable different approaches to studying this book: if time per- mits, it can be read in the sequence it is presented, covering the full scope of material— including functional approaches as alternatives to imperative ones—as the problems are encountered which they address. If time is short, these advanced sections can be skipped, and emphasis can be placed on a thorough grounding in imperative, object-oriented programming. (We should emphasize that functional is not a contradiction to object- oriented: whether the functional material is included in the study, or the course emphasis

A01_BARN7367_06_SE_FM.indd 16 4/15/16 6:10 PM

Preface | 17

is largely on imperative techniques, every reader of this book will emerge with a good understanding of object orientation!) Yet another way to approach the material is to skip the advanced sections initially, and cover them as a separate unit at a later time. They present alternative approaches to other constructs and can be covered independently.

We hope this makes clear that this book provides flexibility where readers want it, but also guidance where a reader has no clear preference: just read it in the sequence it is written. Apart from the major changes described so far, this edition also presents numerous minor improvements. The overall structure, tone, and approach of the book is unchanged; it has worked very well in the past, and there is no reason to deviate from it. However, we continuously re-evaluate and seek to improve where we see opportunities. We now have almost 15 years of continuous experience teaching with this book, and this is reflected in the many minor improvements throughout. This book 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 engineer- ing perspective. While the first chapters are written for students with no programming experience, later chapters are suitable for more advanced or professional programmers as well. In particular, programmers with experience in a non-object-oriented language who wish to migrate their skills into object orientation should also be able to benefit from the book. We use two tools throughout the book to enable the concepts introduced to be put into prac- tice: the Java programming language and the Java development environment BlueJ.

Java Java was chosen because of both its language design and its popularity. The Java programming language itself provides a clean implementation of most of the important object-oriented concepts, and serves well as an introductory teaching language. Its popularity ensures an immense pool of support resources. In any subject area, having a variety of sources of information available is very helpful, for teachers and students alike. For Java in particular, countless books, tutorials, exercises, compilers, environments, and quizzes already exist, in many different kinds and styles. Many of them are online and many are available free of charge. The huge amount of high quality support material makes Java an excellent choice as an introduction to object-oriented programming. With so much Java material already available, is there still room for more to be said about it? We think there is, and the second tool we use is one of the reasons . . .

BlueJ BlueJ deserves much comment. This book is unique in its completely integrated use of the BlueJ environment. BlueJ is a Java development environment that is being developed and maintained by the Computing Education Research Group at the University of Kent in Canterbury, UK,

A01_BARN7367_06_SE_FM.indd 17 4/15/16 6:10 PM

18 | Preface

explicitly as an environment for teaching introductory object-oriented programming. It is better suited to introductory teaching than other environments for a variety of reasons:

■ The user interface is much simpler. Beginning students can typically use the BlueJ environment in a competent manner after 20 minutes of introduction. From then on, instruction can concentrate on the important concepts at hand—object orientation and Java—and no time needs to be wasted talking about environments, file systems, class paths, or DLL conflicts.

■ The environment supports important teaching tools not available in other environments. One of them is visualization of class structure. BlueJ automatically displays a UML-like diagram representing the classes and relationships in a project. Visualizing these impor- tant concepts is a great help to both teachers and students. It is hard to grasp the concept of an object when all you ever see on the screen is lines of code! The diagram notation is a simple subset of UML, tailored to the needs of beginning students. This makes it easy to understand, but also allows migration to full UML in later courses.

■ One of the most important strengths of the BlueJ environment is the user’s ability to directly create objects of any class, and then to interact with their methods. This creates the opportunity for direct experimentation with objects, with little overhead in the envi- ronment. Students can almost “feel” what it means to create an object, call a method, pass a parameter, or receive a return value. They can try out a method immediately after it has been written, without the need to write test drivers. This facility is an invaluable aid in understanding the underlying concepts and language details.

■ BlueJ includes numerous other tools and characteristics that are specifically designed for students of software development. Some are aimed at helping with understanding fundamental concepts (such as the scope highlighting in the editor), some are designed to introduce additional tools and techniques, such as integrated testing using JUnit, or teamwork using a version control system, such as Subversion, once the students are ready. Several of these features are unique to the BlueJ environment.

BlueJ is a full Java environment. It is not a cut-down, simplified version of Java for teach- ing. It runs on top of Oracle’s Java Development Kit, and makes use of the standard com- piler and virtual machine. This ensures that it always conforms to the official and most up-to-date Java specification. The authors of this book have many years of teaching experience with the BlueJ environ- ment (and many more years without it before that). We both have experienced how the use of BlueJ has increased the involvement, understanding, and activity of students in our courses. One of the authors is also the development lead of the BlueJ system.

Real objects first One of the reasons for choosing BlueJ was that it allows an approach where teachers truly deal with the important concepts first. “Objects first” has been a battle cry for many text- book authors and teachers for some time. Unfortunately, the Java language does not make this noble goal very easy. Numerous hurdles of syntax and detail have to be overcome before

A01_BARN7367_06_SE_FM.indd 18 4/15/16 6:10 PM

Preface | 19

the first experience with a living object arises. The minimal Java program to create and call an object typically includes

■ writing a class;

■ writing a main method, including concepts such as static methods, parameters, and arrays in the signature;

■ a statement to create the object (“new”);

■ an assignment to a variable;

■ the variable declaration, including variable type;

■ a method call, using dot notation;

■ possibly a parameter list.

As a result, most textbooks typically either

■ have to work their way through this forbidding list, and only reach objects somewhere around the fourth chapter; or

■ use a “Hello, world”-style program with a single static main method as the first example, thus not creating any objects at all.

With BlueJ, this is not a problem. A student can create an object and call its methods as the very first activity! Because users can create and interact with objects directly, con- cepts such as classes, objects, methods, and parameters can easily be discussed in a con- crete manner before looking at the first line of Java syntax. Instead of explaining more about this here, we suggest that the curious reader dip into Chapter 1—things will quickly become clear then.

An iterative approach Another important aspect of this book is that it follows an iterative style. In the computing education community, a well-known educational design pattern exists that states that impor- tant concepts should be taught early and often.1 It is very tempting for textbook authors to try and say everything about a topic at the point where it is introduced. For example, it is common, when introducing types, to give a full list of built-in data types, or to discuss all available kinds of loop when introducing the concept of a loop. These two approaches conflict: we cannot concentrate on discussing important concepts first, and at the same time provide complete coverage of all topics encountered. Our experi- ence with textbooks is that much of the detail is initially distracting, and has the effect of drowning the important points, thus making them harder to grasp.

1 The “Early Bird” pattern, in J. Bergin: “Fourteen Pedagogical Patterns for Teaching Computer Science,” Proceedings of the Fifth European Conference on Pattern Languages of Programs (EuroPLop 2000), Irsee, Germany, July 2000.

A01_BARN7367_06_SE_FM.indd 19 4/15/16 6:10 PM

20 | Preface

In this book we touch on all of the important topics several times, both within the same chapter and across different chapters. Concepts are usually introduced at a level of detail necessary for understanding and applying to the task at hand. They are revisited later in a different context, and understanding deepens as the reader continues through the chap- ters. This approach also helps to deal with the frequent occurrence of mutual dependencies between concepts. Some teachers may not be familiar with the iterative approach. Looking at the first few chapters, teachers used to a more sequential introduction will be surprised about the number of concepts touched on this early. It may seem like a steep learning curve. It is important to understand that this is not the end of the story. Students are not expected to understand everything about these concepts immediately. Instead, these fundamental concepts will be revisited again and again throughout the book, allowing students to get a deeper understanding over time. Since their knowledge level changes as they work their way forward, revisiting important topics later allows them to gain a deeper understanding overall. We have tried this approach with students many times. Sometimes students have fewer problems dealing with it than some long-time teachers. And remember: a steep learning curve is not a problem as long as you ensure that your students can climb it!

No complete language coverage Related to our iterative approach is the decision not to try to provide complete coverage of the Java language within the book. The main focus of this book is to convey object-oriented programming principles in general, not Java language details in particular. Students studying with this book may be working as software professionals for the next 30 or 40 years of their life—it is a fairly safe bet that the majority of their work will not be in Java. Every serious textbook must attempt to prepare them for something more fundamental than the language flavor of the day. On the other hand, many Java details are essential to actually doing practical programming work. In this book we cover Java constructs in as much detail as is necessary to illustrate the concepts at hand and implement the practical work. Some constructs specific to Java have been deliberately left out of the discussion. We are aware that some instructors will choose to cover some topics that we do not discuss in detail. However, instead of trying to cover every possible topic ourselves (and thus blowing the size of this book out to 1500 pages), we deal with it using hooks. Hooks are pointers, often in the form of questions that raise the topic and give references to an appendix or outside material. These hooks ensure that a relevant topic is brought up at an appropriate time, and leave it up to the reader or the teacher to decide to what level of detail that topic should be covered. Thus, hooks serve as a reminder of the existence of the topic, and as a placeholder indicating a point in the sequence where discussion can be inserted. Individual teachers can decide to use the book as it is, following our suggested sequence, or to branch out into sidetracks suggested by the hooks in the text.

A01_BARN7367_06_SE_FM.indd 20 4/15/16 6:10 PM

Preface | 21

Chapters also often include several questions suggesting discussion material related to the topic, but not discussed in this book. We fully expect teachers to discuss some of these ques- tions in class, or students to research the answers as homework exercises.

Project-driven approach The introduction of material in the book is project driven. The book discusses numerous programming projects and provides many exercises. Instead of introducing a new construct and then providing an exercise to apply this construct to solve a task, we first provide a goal and a problem. Analyzing the problem at hand determines what kinds of solutions we need. As a consequence, language constructs are introduced as they are needed to solve the problems before us. Early chapters provide at least two discussion examples. These are projects that are dis- cussed in detail to illustrate the important concepts of each chapter. Using two very different examples supports the iterative approach: each concept is revisited in a different context after it is introduced. In designing this book we have tried to use a lot of different example projects. This will hopefully serve to capture the reader’s interest, and also illustrate the variety of different contexts in which the concepts can be applied. We hope that our projects serve to give teachers good starting points and many ideas for a wide variety of interesting assignments. The implementation for all our projects is written very carefully, so that many peripheral issues may be studied by reading the projects’ source code. We are strong believers in learn- ing by reading and imitating good examples. For this to work, however, it’s important that the examples are well written and worth imitating. We have tried to create great examples. All projects are designed as open-ended problems. While one or more versions of each problem are discussed in detail in the book, the projects are designed so that further extensions and improvements can be done as student projects. Complete source code for all projects is included. A list of projects discussed in this book is provided on page xxv.

Concept sequence rather than language constructs One other aspect that distinguishes this book from many others is that it is structured along fundamental software development tasks, not necessarily according to the particular Java language constructs. One indicator of this is the chapter headings. In this book you will not find traditional chapter titles such as “Primitive data types” or “Control structures.” Structuring by fundamental development tasks allows us to present a more general introduc- tion that is not driven by intricacies of the particular programming language utilized. We also believe that it is easier for students to follow the motivation of the introduction, and that it makes much more interesting reading. As a result of this approach, it is less straightforward to use the book as a reference book. Introductory textbooks and reference books have different, partly competing, goals. To a

A01_BARN7367_06_SE_FM.indd 21 4/15/16 6:10 PM

22 | Preface

certain extent a book can try to be both, but compromises have to be made at certain points. Our book is clearly designed as a textbook, and wherever a conflict occurred, the textbook style took precedence over its use as a reference book. We have, however, provided support for use as a reference book by listing the Java con- structs introduced in each chapter in the chapter introduction.

Chapter sequence Chapter 1 deals with the most fundamental concepts of object orientation: objects, classes, and methods. It gives a solid, hands-on introduction to these concepts without going into the details of Java syntax. We briefly introduce the concept of abstraction. This will be a thread that runs through many chapters. Chapter 1 also gives a first look at some source code. We do this by using an example of graphical shapes that can be interactively drawn, and a second example of a simple laboratory class enrollment system. Chapter 2 opens up class definitions and investigates how Java source code is written to cre- ate behavior of objects. We discuss how to define fields and implement methods, and point out the crucial role of the constructor in setting up an object’s state as embodied in its fields. Here, we also introduce the first types of statement. The main example is an implementation of a ticket machine. We also investigate the laboratory class example from Chapter 1 a bit further. Chapter 3 then enlarges the picture to discuss interaction of multiple objects. We see how objects can collaborate by invoking each other’s methods to perform a common task. We also discuss how one object can create other objects. A digital alarm clock display is dis- cussed that uses two number display objects to show hours and minutes. A version of the project that includes a GUI picks up on a running theme of the book—that we often provide additional code for the interested and able student to explore, without covering it in detail in the text. As a second major example, we examine a simulation of an email system in which messages can be sent between mail clients. In Chapter 4 we continue by building more extensive structures of objects and pick up again on the themes of abstraction and object interaction from the preceding chapters. Most importantly, we start using collections of objects. We implement an organizer for music files and an auction system to introduce collections. At the same time, we discuss iteration over collections, and have a first look at the for-each and while loops. The first collection being used is an ArrayList. Chapter 5 presents the first advanced section (a section that can be skipped if time is short): It is an introduction to functional programming constructs. The functional constructs pre- sent an alternative to the imperative collection processing discussed in Chapter 4. The same problems can be solved without these techniques, but functional constructs open some more elegant ways to achieve our goals. This chapter gives an introduction to the functional approach in general, and introduces a few of Java’s language constructs. Chapter 6 deals with libraries and interfaces. We introduce the Java library and discuss some important library classes. More importantly, we explain how to read and understand the library documentation. The importance of writing documentation in software development

A01_BARN7367_06_SE_FM.indd 22 4/15/16 6:10 PM

Preface | 23

projects is discussed, and we end by practicing how to write suitable documentation for our own classes. Random, Set, and Map are examples of classes that we encounter in this chapter. We implement an Eliza-like dialog system and a graphical simulation of a bouncing ball to apply these classes. Chapter 7 concentrates on one specific—but very special—type of collection: arrays. Arrays processing and the associated types of loops are discussed in detail. In Chapter 8 we discuss more formally the issues of dividing a problem domain into classes for implementation. We introduce issues of good class design, including concepts such as responsibility-driven design, coupling, cohesion, and refactoring. An interactive, text-based adventure game (World of Zuul) is used for this discussion. We go through several iterations of improving the internal class structure of the game and extending its functionality, and end with a long list of proposals for extensions that may be done as student projects. Chapter 9 deals with a whole group of issues connected to producing correct, understandable, and maintainable classes. It covers issues ranging from writing clear code (including style and commenting) to testing and debugging. Test strategies are introduced, including formalized regression testing using JUnit, and a number of debugging methods are discussed in detail. We use an example of an online shop and an implementation of an electronic calculator to discuss these topics. Chapters 10 and 11 introduce inheritance and polymorphism, with many of the related detailed issues. We discuss a part of a social network to illustrate the concepts. Issues of code inheritance, subtyping, polymorphic method calls, and overriding are discussed in detail. In Chapter 12 we implement a predator/prey simulation. This serves to discuss additional abstraction mechanisms based on inheritance, namely interfaces and abstract classes. Chapter 13 develops an image viewer and a graphical user interface for the music organizer (first encountered in Chapter 4). Both examples serve to discuss how to build graphical user interfaces (GUIs). Chapter 14 then picks up the difficult issue of how to deal with errors. Several possible problems and solutions are discussed, and Java’s exception-handling mechanism is discussed in detail. We extend and improve an address book application to illustrate the concepts. Input/output is used as a case study where error-handling is an essential requirement. Chapter 15 discusses in more detail the next level of abstraction: How to structure a vaguely described problem into classes and methods. In previous chapters we have assumed that large parts of the application structure already exist, and we have made improvements. Now it is time to discuss how we can get started from a clean slate. This involves detailed discussion of what the classes should be that implement our application, how they interact, and how respon- sibilities should be distributed. We use Class/Responsibilities/Collaborators (CRC) cards to approach this problem, while designing a cinema booking system. In Chapter 16 we to bring everything together and integrate topics from the previous chapters of the book. It is a complete case study, starting with the application design, through design of the class interfaces, down to discussing many important functional and non-functional characteristics and implementation details. Concepts discussed in earlier chapters (such as reliability, data structures, class design, testing, and extendibility) are applied again in a new context.

A01_BARN7367_06_SE_FM.indd 23 4/15/16 6:10 PM

24 | Preface

Supplements VideoNotes: VideoNotes are Pearson’s visual tool designed to teach students key program- ming concepts and techniques. These short step-by-step videos demonstrate how to solve problems from design through coding. VideoNotes allow for self-paced instruction with easy navigation including the ability to select, play, rewind, fast-forward, and stop within each VideoNote exercise. VideoNotes are located at www.pearsonhighered.com/cs-resources. Twelve months of prepaid access are included with the purchase of a new textbook. If the access code has already been revealed, it may no longer be valid. If this is the case, you can purchase a sub- scription by going to www.pearsonhighered.com/cs-resources and following the on-screen instructions. Book website: All projects used as discussion examples and exercises in this book are avail- able for download on the book’s website, at http://www.bluej.org/objects-first/. The website also provides links to download BlueJ, and other resources. Premium Website for students: The following resources are available to all readers of this book at its Premium Website, located at www.pearsonhighered.com/cs-resources:

■ Program style guide for all examples in the book

■ Links to further material of interest

■ Complete source code for all projects

Instructor resources: The following supplements are available to qualified instructors only:

■ Solutions to end-of-chapter exercises

■ PowerPoint slides

Visit the Pearson Instructor Resource Center at www.pearsonhighered.com/irc to register for access or contact your local Pearson representative.

The Blueroom Perhaps more important than the static web site resources is a very active community forum that exists for instructors who teach with BlueJ and this book. It is called the Blueroom and can be found at

http://blueroom.bluej.org

The Blueroom contains a resource collection with many teaching resources shared by other teachers, as well as a discussion forum where instructors can ask questions, discuss issues, and stay up-to-date with the latest developments. Many other teachers, as well as developers of BlueJ and the authors of this book, can be contacted in the Blueroom.

A01_BARN7367_06_SE_FM.indd 24 4/15/16 6:10 PM

http://www.pearsonhighered.com/cs-resources
http://www.pearsonhighered.com/cs-resources
http://www.bluej.org/objects-first
http://www.pearsonhighered.com/cs-resources:
http://www.pearsonhighered.com/irc
http://blueroom.bluej.org
List of Projects Discussed in Detail in This Book

Figures (Chapter 1) Simple drawing with some geometrical shapes; illustrates creation of objects, method calling, and parameters.

House (Chapter 1) An example using shape objects to draw a picture; introduces source code, Java syntax, and compilation.

Lab-classes (Chapter 1, 2, 10) A simple example with classes of students; illustrates objects, fields, and methods. Used again in Chapter 10 to add inheritance.

Ticket-machine (Chapter 2) A simulation of a ticket vending machine for train tickets; introduces more about fields, constructors, accessor and mutator methods, parameters, and some simple statements.

Book-exercise (Chapter 2) Storing details of a book. Reinforcing the constructs used in the ticket-machine example.