Bluej answers to exercises

(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.