Find the Roots of a Quadratic Equation

bj4_fm.fm Page iv Saturday, November 7, 2009 12:01 PM

• Students achieve concept mastery in a rich, structured environment that’s available 24/7

From multiple study paths, to self-assessment, to a wealth of interactive

visual and audio resources, WileyPLUS gives you everything you need to

personalize the teaching and learning experience.

With WileyPLUS:

» F i n d o u t h ow t o M a k e I t Yo u r S »

This online teaching and learning environment integrates the entire digital textbook with the most effective instructor and student resources to fit every learning style.

• Instructors personalize and manage their course more effectively with assessment, assignments, grade tracking, and more

• manage time better

• study smarter

• save money

www.wileyplus.com

WP5_FM_8x10.indd 1 8/7/09 11:36 AM

Make It YourS!

aLL The heLP, reSoUrceS, and PerSonaL SUPPorT yoU and yoUr STUdenTS need!

technical Support 24/7 FaQs, online chat, and phone support

www.wileyplus.com/suppor t

Student support from an experienced student user

ask your local representative for details!

Your WileyPLUS account Manager

training and implementation support www.wileyplus.com/accountmanager

Collaborate with your colleagues, find a mentor, attend virtual and live

events, and view resources www.WhereFacultyconnect.com

Pre-loaded, ready-to-use assignments and presentations

www.wiley.com/college/quickstar t

2-Minute tutorials and all of the resources you & your students need to get started

www.wileyplus.com/firstday

WP5_FM_8x10.indd 2 8/7/09 11:36 AM

th edition 4

Big Java

bj4_fm.fm Page iii Saturday, November 7, 2009 12:01 PM

bj4_fm.fm Page iv Saturday, November 7, 2009 12:01 PM

th edition 4

Big Java

Cay Horstmann

SAN JOSE STATE UNIVERSITY

JOHN WILEY & SONS, INC.

bj4_fm.fm Page v Saturday, November 7, 2009 12:01 PM

VICE PRESIDENT AND EXECUTIVE PUBLISHER Donald Fowley EXECUTIVE EDITOR Beth Lang Golub EDITORIAL ASSISTANT Michael Berlin PRODUCTION SERVICES MANAGER Dorothy Sinclair PRODUCTION EDITOR Janet Foxman EXECUTIVE MARKETING MANAGER Christopher Ruel CREATIVE DIRECTOR Harry Nolan SENIOR DESIGNER Madelyn Lesure PHOTO EDITOR Lisa Gee MEDIA EDITOR Lauren Sapira PRODUCTION SERVICES Cindy Johnson COVER DESIGNER Howard Grossman COVER ILLUSTRATION Susan Cyr

This book was set in Stempel Garamond by Publishing Services, and printed and bound by RRD Jefferson City. The cover was printed by RRD Jefferson City.

This book is printed on acid-free paper.

∞

Copyright © 2010, 2008, 2006, 2002 John Wiley & Sons, Inc. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, Inc., 222 Rosewood Drive, Danvers, MA 01923, website

www.copyright.com.

Requests to the Publisher for per- mission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030-5774, (201) 748-6011, fax (201) 748-6008, website

www.wiley.com/go/permissions.

Evaluation copies are provided to qualified academics and professionals for review purposes only, for use in their courses during the next academic year. These copies are licensed and may not be sold or transferred to a third party. Upon completion of the review period, please return the evaluation copy to Wiley. Return instructions and a free of charge return shipping label are available at

www.wiley.com/go/returnlabel.

Outside of the United States, please contact your local representative.

Library of Congress Cataloging-in-Publication Data:

Horstmann, Cay S., 1959– Big Java : compatible with Java 5, 6 and 7 / Cay Horstmann. -- 4th ed. p. cm. Includes index. ISBN 978-0-470-50948-7 (pbk. : alk. paper) 1. Java (Computer program language) I. Title. QA76.73.J38H674 2010 005.13'3--dc22 2009042604 ISBN 978-0-470-50948-7

Printed in the United States of America

10 9 8 7 6 5 4 3 2 1

bj4_fm.fm Page vi Saturday, November 7, 2009 12:01 PM

PREFACE

vii

This book is an introductory text in computer science, focusing on the principles of programming and software engineering. Here are its key features:

•

Teach objects gradually.

In Chapter 2, students learn how to use objects and classes from the standard library. Chapter 3 shows the mechanics of implementing classes

from a given specification

. Students then use simple objects as they master branches, loops, and arrays. Object-oriented design starts in Chapter 8. This gradual approach allows students to use objects throughout their study of the core algorithmic topics, without teaching bad habits that must be un-learned later.

•

Reinforce sound engineering practices.

A focus on test-driven development encourages students to test their programs systematically. A multitude of useful tips on software quality and common errors encourage the development of good programming habits.

•

Help students with guidance and worked examples.

Beginning programmers often ask “How do I start? Now what do I do?” Of course, an activity as complex as programming cannot be reduced to cookbook- style instructions. However, step-by-step guidance is immensely helpful for building confidence and providing an outline for the task at hand. The book con- tains a large number of “How To” guides for common tasks, with pointers to additional worked examples on the Web.

•

Focus on the essentials while being technically accurate.

An encyclopedic coverage is not helpful for a beginning programmer, but neither is the opposite—reducing the material to a list of simplistic bullet points that give an illusion of knowledge. In this book, the essentials of each subject are presented in digestible chunks, with separate notes that go deeper into good practices or lan- guage features when the reader is ready for the additional information.

•

Use standard Java.

The book teaches the standard Java language—not a specialized “training wheels” environment. The Java language, library, and tools are presented at a depth that is sufficient to solve real-world programming problems. The final chapters of the book cover advanced techniques such as multithreading, database storage, XML, and web programming.

•

Provide an optional graphics track.

Graphical shapes are splendid examples of objects. Many students enjoy writing programs that create drawings or use graphical user interfaces. If desired, these topics can be integrated into the course by using the materials at the end of Chapters 2, 3, 9, and 10.

bj4_fm.fm Page vii Saturday, November 7, 2009 12:01 PM

viii

Preface

This is the fourth edition of

Big Java,

and the book has once again been carefully revised and updated. The new and improved features include:

• The How To sections have been updated and expanded, and four new ones have been added. Fifteen new Worked Examples (on the companion web site and in WileyPLUS) walk students through the steps required for solving complex and interesting problems.

• The treatment of algorithm design, planning, and the use of pseudocode has been enhanced. Students learn to use pseudocode to define the solution algorithm in Chapter 1.

• Chapters have been revised to focus each section on a specific learning objective. These learning objectives also organize the chapter summary to help students assess their progress.

• Syntax diagrams now call out features of typical example code to draw student attention to the key elements of the syntax. Additional annotations point out special cases, common errors, and good practice associated with the syntax.

• New example tables clearly present a variety of typical and special cases in a compact format. Each example is accompanied by a brief note explaining the usage shown and the values that result from it.

• The gradual introduction of objects has been further improved by providing additional examples and insights in the early chapters.

• Features introduced in Java 7 are covered as Special Topics so that students can prepare for them. In this edition, we use Java 5 or 6 for the main discussion.

• The test bank has been greatly expanded and improved. (See page xi.)

• A new set of lab assignments enables students to practice solving complex problems one step at a time.

• The LabRat code evaluation feature, enhanced for this edition, gives students instant feedback on their programming assignments. (See page xvi.)

New in This Edition

More Help for Beginning Programmers

Annotated Examples

Updated for Java 7

More Opportunities for Practice

bj4_fm.fm Page viii Saturday, November 7, 2009 12:01 PM

Preface

ix

The book can be naturally grouped into four parts, as illustrated by Figure 1. The organization of chapters offers the same flexibility as the previous edition; depen- dencies among the chapters are also shown in the figure.

Part A: Fundamentals

(Chapters 1–7)

Chapter 1 contains a brief introduction to computer science and Java programming. Chapter 2 shows how to manipulate objects of predefined classes. In Chapter 3, you will build your own simple classes from given specifications.

Fundamental data types, branches, loops, and arrays are covered in Chapters 4–7.

Part B: Object-Oriented Design (

Chapters 8–12)

Chapter 8 takes up the subject of class design in a systematic fashion, and it intro- duces a very simple subset of the UML notation.

The discussion of polymorphism and inheritance is split into two chapters. Chap- ter 9 covers interfaces and polymorphism, whereas Chapter 10 covers inheritance. Introducing interfaces before inheritance pays off in an important way: Students immediately see polymorphism before getting bogged down with technical details such as superclass construction.

Exception handling and basic file input/output are covered in Chapter 11. The exception hierarchy gives a useful example for inheritance.

Chapter 12 contains an introduction to object-oriented design, including two significant case studies.

Part C: Data Structures and Algorithms

(Chapters 13–17)

Chapters 13 through 17 contain an introduction to algorithms and data structures, covering recursion, sorting and searching, linked lists, binary trees, and hash tables. These topics may be outside the scope of a one-semester course, but can be covered as desired after Chapter 7 (see Figure 1).

Recursion is introduced from an object-oriented point of view: An object that solves a problem recursively constructs another object of the same class that solves a simpler problem. The idea of having the other object do the simpler job is more intuitive than having a function call itself.

Each data structure is presented in the context of the standard Java collections library. You will learn the essential abstractions of the standard library (such as iterators, sets, and maps) as well as the performance characteristics of the various collections. However, a detailed discussion of the implementation of advanced data structures is beyond the scope of this book.

Chapter 17 introduces Java generics. This chapter is suitable for advanced stu- dents who want to implement their own generic classes and methods.

Part D: Advanced Topics

(Chapters 18–24)

Chapters 18 through 24 cover advanced Java programming techniques that defi- nitely go beyond a first course in Java. Although, as already mentioned, a compre- hensive coverage of the Java library would span many volumes, many instructors prefer that a textbook should give students additional reference material valuable beyond their first course. Some institutions also teach a second-semester course that

A Tour of the Book

bj4_fm.fm Page ix Saturday, November 7, 2009 12:01 PM

x

Preface

Figure 1

Chapter Dependencies

4. Fundamental Data Types

5. Decisions

9. Interfaces and Polymorphism

10. Inheritance

11. Input/Output and Exception

Handling

19. Streams and Binary I/O

20. Multithreading

12. Object- Oriented Design

22. Relational Databases

13. Recursion

14. Sorting and Searching

15. Intro to Data Structures

16. Advanced Data Structures

21. Internet Networking

23. XML

24. Web Applications

7. Arrrays and Array Lists

6. Iteration

8. Designing Classes

17. Generic Programming

3. Implementing Classes

1. Introduction

2. Using Objects

Fundamentals

Object-Oriented Design

Data Structures & Algorithms

Advanced Topics

18. Graphical User Interfaces

bj4_fm.fm Page x Saturday, November 7, 2009 12:01 PM

Preface

xi

covers more practical programming aspects such as database and network program- ming, rather than the more traditional in-depth material on data structures and algo- rithms. This book can be used in a two-semester course to give students an introduction to programming fundamentals and broad coverage of applications. Alternatively, the material in the final chapters can be useful for student projects.

The advanced topics include graphical user-interface design, advanced file han- dling, multithreading, and those technologies that are of particular interest to server-side programming: networking, databases, XML, and web applications. The Internet has made it possible to deploy many useful applications on servers, often accessed by nothing more than a browser. This server-centric approach to applica- tion development was in part made possible by the Java language and libraries, and today, much of the industrial use of Java is in server-side programming.

Appendices

Appendix A lists character escape sequences and the Basic Latin and Latin-1 subsets of Unicode. Appendices B and C summarize Java reserved words and operators. Appendix D documents all of the library methods and classes used in this book.

Additional appendices contain quick references on Java syntax, HTML, Java tools, binary numbers, and UML.

Appendix L contains a style guide for use with this book. Many instructors find it highly beneficial to require a consistent style for all assignments. If this style guide conflicts with instructor sentiment or local customs, however, it is available in electronic form so that it can be modified.

Web Resources

This book is complemented by a complete suite of online resources and a robust WileyPLUS course.

Go to

www.wiley.com/college/horstmann

to visit the online companion site, which includes

• Source code for all examples in the book. • Worked Examples that apply the problem-solving steps in the book to other

realistic examples. • Laboratory exercises (and solutions for instructors only). • Lecture presentation slides (in HTML and PowerPoint formats). • Solutions to all review and programming exercises (for instructors only). • A test bank that focuses on skills, not just terminology (for instructors only).

WileyPLUS

is an online teaching and learning environment that integrates the digital textbook with instructor and student resources. See page xvi for details.

• Worked Example How Many Days Have You Been Alive? • Worked Example Working with Pictures • Lab Exercises

Animation Variable Initialization and Assignment Animation Parameter Passing Animation Object References Practice Quiz Code Completion Exercises

Media Resources

www.wiley.com/ college/ horstmann

Web resources are summarized at chapter end for easy reference.

bj4_fm.fm Page xi Saturday, November 7, 2009 12:01 PM

xii

Walkthrough

The pedagogical elements in this book work together to make the book accessible to beginners as well as those learning Java as a second language.

A Walkthrough of the Learning Aids

2.3 The Assignment Operator 39

You can change the value of a variable with the assignment operator (=). For exam- ple, consider the variable declaration

int width = 10;

If you want to change the value of the variable, simply assign the new value: width = 20;

The assignment replaces the original value of the variable (see Figure 1).

It is an error to use a variable that has never had a value assigned to it. For exam- ple, the following assignment statement has an error:

int height; width = height; // ERROR—uninitialized variable height

The compiler will complain about an “uninitialized variable” when you use a vari- able that has never been assigned a value. (See Figure 2.)

2.3 The Assignment Operator Use the assignment operator (=) to change the value of a variable. 1

2

Figure 1 Assigning a New Value to a Variable

width = 10

width = 20

1

2

Figure 2 An Uninitialized Variable

Syntax 2.2 Assignment

height = No value has been assigned.

variableName = value;Syntax

Example double width = 20; . . width = 30;

. . . width = width + 10;

The value of this variable is changed.

The same name

can occur on both sides.

See Figure 3.

The new value of the variable

This is a variable declaration. This is an assignment statement.

Annotations explain required components and point to more information on common errors or best practices associated with the syntax.

Throughout each chapter, margin notes show where new concepts are introduced and provide an outline of key ideas.

Annotated syntax boxes provide a quick, visual overview of new language constructs.

Explain the flow of execution in a loop.

• A while statement executes a block of code repeatedly. A condition controls for how long the loop is executed.

• An off-by-one error is a common error when programming loops. Think through simple test cases to avoid this type of error.

Use for loops to implement counting loops.

• You use a for loop when a variable runs from a starting to an ending value with a constant increment or decrement.

• Make a choice between symmetric and asymmetric loop bounds. • Count the number of iterations to check that your for loop is correct.

Implement loops that process a data set until a sentinel value is encountered.

• Sometimes, the termination condition of a loop can only be evaluated in the middle of a loop. You can introduce a Boolean variable to control such a loop.

Use nested loops to implement multiple levels of iterations.

• When the body of a loop contains another loop, the loops are nested. A typical use of nested loops is printing a table with rows and columns.

Summary of Learning Objectives

Each section corresponds to a learning objective, summarized at chapter end, giving students a roadmap for assessing what they know and what they need to review.

bj4_fm.fm Page xii Saturday, November 7, 2009 12:01 PM

Walkthrough

xiii

180 Decisions

Table 1 Relational Operator Examples

tnemmoCeulaVnoisserpxE

eurt4 =< 3 3 is less than 4; <= tests for “less than or equal”.

3 =< 4 Error The “less than or equal” operator is <=, not =<, with the “less than” symbol first.

eslaf4 > 3 > is the opposite of <=.

eslaf4 < 4 The left-hand side must be strictly smaller than the right-hand side.

eurt4 =< 4 Both sides are equal; <= tests for “less than or equal”.

eurt2 - 5 == 3 == tests for equality.

eurt1 - 5 =! 3 != tests for inequality. It is true that 3 is not 5 – 1.

3 = 6 / 2 Error Use == to test for equality.

1.0 / 3.0 == 0.333333333 false Although the values are very close to one another, they are not exactly equal. See Common Error 4.3.

"10" > 5 Error You cannot compare a string to a number.

"Tomato".substring(0, 3).equals("Tom") true Always use the equals method to check whether two strings have the same contents.

"Tomato".substring(0, 3) == ("Tom") false Never use == to compare strings; it only checks whether the strings are stored in the same location. See Common Error 5.2 on page 180.

"Tom".equalsIgnoreCase("TOM") true Use the equalsIgnoreCase method if you don’t want to distinguish between uppercase and lowercase letters.

We simply want to know which car is the better buy. That is the desired output.

Step 2 Break down the problem into smaller tasks.

For each car, we need to know the total cost of driving it. Let’s do this computation sepa- rately for each car. Once we have the total cost for each car, we can decide which car is the better deal.

The total cost for each car is purchase price + operating cost.

We assume a constant usage and gas price for ten years, so the operating cost depends on the cost of driving the car for one year.

The operating cost is 10 x annual fuel cost. The annual fuel cost is price per gallon x annual fuel consumed.

The annual fuel consumed is annual miles driven / fuel efficiency. For example, if you drive the car for 15,000 miles and the fuel efficiency is 15 miles/gallon, the car consumes 1,000 gallons.

Step 3 Describe each subtask in pseudocode.

In your description, arrange the steps so that any intermediate values are computed before they are needed in other computations. For example, list the step

total cost = purchase price + operating cost

after you have computed operating cost. Here is the algorithm for deciding which car to buy.

For each car, compute the total cost as follows:

annual fuel consumed = annual miles driven / fuel efficiency

annual fuel cost = price per gallon x annual fuel consumed

operating cost = 10 x annual fuel cost

total cost = purchase price + operating cost

If total cost1 < total cost2

Choose car1.

Else

Choose car2.

HOW TO 1.1 Developing and Describing an Algorithm

This is the first of many “How To” sections in this book that give you step-by-step proce- dures for carrying out important tasks in developing computer programs.

Before you are ready to write a program in Java, you need to develop an algorithm—a method for arriving at a solution for a particular problem. Describe the algorithm in pseudocode: a sequence of precise steps formulated in English.

For example, consider this problem: You have the choice of buying two cars. One is more fuel efficient than the other, but also more expensive. You know the price and fuel efficiency (in miles per gallon, mpg) of both cars. You plan to keep the car for ten years. Assume a price of $4 per gallon of gas and usage of 15,000 miles per year. You will pay cash for the car and not worry about financing costs. Which car is the better deal?

Step 1 Determine the inputs and outputs.

In our sample problem, we have these inputs: • purchase price1 and fuel efficiency1, the price and fuel efficiency (in mpg) of the first car. • purchase price2 and fuel efficiency2, the price and fuel efficiency of the second car.

How To guides give step-by-step guidance for common programming tasks, emphasizing planning and testing. They answer the beginner’s question, “Now what do I do?” and integrate key concepts into a problem-solving sequence.

Example tables support beginners with multiple, concrete examples. These tables point out common errors and present another quick reference to the section’s topic.

Worked Examples apply the steps in the How To to a different example, illustrating how they can be used to plan, implement, and test a solution to another programming problem.

Credit Card Processing

This Worked Example uses a loop to remove spaces from a credit card number.

Worked Example 6.1

Writing an Algorithm for Tiling a Floor

This Worked Example shows how to develop an algorithm for laying tile in an alternating pattern of colors.

Worked Example 1.1

bj4_fm.fm Page xiii Saturday, November 7, 2009 12:01 PM

xiv

Walkthrough

Now consider the seemingly analogous code with Rectangle objects (see Figure 21).

Rectangle box = new Rectangle(5, 10, 20, 30); Rectangle box2 = box; box2.translate(15, 25);

Since box and box2 refer to the same rectangle after step , both variables refer to the moved rectangle after the call to the translate method.

You need not worry too much about the difference between objects and object references. Much of the time, you will have the correct intuition when you think of “the object box” rather than the technically more accurate “the object reference stored in box”. The difference between objects and object references only becomes apparent when you have multiple variables that refer to the same object.

25. What is the effect of the assignment String greeting2 = greeting? 26. After calling greeting2.toUpperCase(), what are the contents of greeting and

greeting2?

Figure 21 Copying Object References

box =

box2 = x =

Rectangle

y =

width =

height =

5

10

20

g

30

box =

box2 = x =

Rectangle

y =

width =

height =

20

35

20

g

30

box =

x =

Rectangle

y =

width =

height =

5

10

20

g

30

1

2

3

1 2

3A N I M A T I O N Object References

2

S E L F C H E C K

6.2 for Loops 205

ch06/invest2/Investment.java

1 /** 2 A class to monitor the growth of an investment that 3 accumulates interest at a fixed annual rate. 4 */ 5 public class Investment 6 { 7 private double balance; 8 private double rate; 9 private int years;

10 11 /** 12 Constructs an Investment object from a starting balance and 13 interest rate. 14 @param aBalance the starting balance 15 @param aRate the interest rate in percent 16 */ 17 public Investment(double aBalance, double aRate) 18 { 19 balance = aBalance; 20 rate = aRate; 21 years = 0; 22 } 23 24 /** 25 Keeps accumulating interest until a target balance has 26 been reached. 27 @param targetBalance the desired balance 28 */

Program listings are carefully designed for easy reading, going well beyond simple color coding. Methods are set off by a subtle outline.

4. What is the difference between the following two statements? final double CM_PER_INCH = 2.54;

and public static final double CM_PER_INCH = 2.54;

5. What is wrong with the following statement sequence? double diameter = . . .; double circumference = 3.14 * diameter;

S E L F C H E C K

Figure 4 Execution of a for Loop

for (int i = 1; i <= numberOfYears; i++) { double interest = balance * rate / 100; balance = balance + interest; }

Initialize counter1

for (int i = 1; i <= numberOfYears; i++) { double interest = balance * rate / 100; balance = balance + interest; }

Check condition2

for (int i = 1; i <= numberOfYears; i++) {

double interest = balance * rate / 100; balance = balance + interest; }

Execute loop body3

for (int i = 1; i <= numberOfYears; i++) { double interest = balance * rate / 100; balance = balance + interest; }

Update counter4

for (int i = 1; i <= numberOfYears; i++) { double interest = balance * rate / 100; balance = balance + interest; }

Check condition again5

i = 1

i = 1

i = 1

i = 2

i = 2

Progressive figures trace code segments to help students visualize the program flow. Color is used consistently to make variables and other elements easily recognizable.

Self-check exercises at the end of each section are designed to make students think through the new material—and can spark discussion in lecture.

Students can view animations of key concepts on the Web.

bj4_fm.fm Page xiv Saturday, November 7, 2009 12:01 PM

Walkthrough

xv

Length and Size

Unfortunately, the Java syntax for determining the number of elements in an array, an array list, and a string is not at all consistent. It is a com- mon error to confuse these. You just have to remember the correct syntax for every data type.

Common Error 7.3

Data Type Number of Elements

Array a.length

Array list a.size()

String a.length()

;

Do Not Use Magic Numbers

A magic number is a numeric constant that appears in your code without explanation. For example, consider the following scary example that actually occurs in the Java library source:

h = 31 * h + ch;

Why 31? The number of days in January? One less than the number of bits in an integer? Actually, this code computes a “hash code” from a string—a number that is derived from the characters in such a way that different strings are likely to yield different hash codes. The value 31 turns out to scramble the character values nicely.

A better solution is to use a named constant:

final int HASH_MULTIPLIER = 31; h = HASH_MULTIPLIER * h + ch;

You should never use magic numbers in your code. Any number that is not completely self- explanatory should be declared as a named constant. Even the most reasonable cosmic con- stant is going to change one day. You think there are 365 days in a year? Your customers on Mars are going to be pretty unhappy about your silly prejudice. Make a constant

final int DAYS_PER_YEAR = 365;

By the way, the device

final int THREE_HUNDRED_AND_SIXTY_FIVE = 365;

In the following sections, you will learn how to carry out arithmetic calculations in Java.

Quality Tip 4.1

Arithmetic Operations and Hand-Tracing Loops

In Programming Tip 5.2, you learned about the method of hand tracing. This method is par- ticularly effective for understanding how a loop works.

Consider this example loop. What value is displayed?

int n = 1729; int sum = 0; while (n > 0) { int digit = n % 10; sum = sum + digit; n = n / 10; } System.out.println(sum);

1. There are three variables: n, sum, and digit. The first two variables are initialized with 1729 and 0 before the loop is entered.

2. Because n is positive, enter the loop. 3. The variable digit is set to 9 (the remainder of dividing 1729 by 10). The variable sum is

set to 0 + 9 = 9. Finally, n becomes 172. (Recall that the remainder in the division 1729 / 10 is discarded because both arguments are integers.). Cross out the old values and write the new ones under the old ones.

Productivity Hint 6.1

1

2

3 4 5 6

7

n sum digit

1729 0

n sum digit

1729 0

172 9 9

ArrayList Syntax Enhancements in Java 7

Java 7 introduces several convenient syntax enhancements for array lists. When you declare and construct an array list, you need not repeat the type parameter in

the constructor. That is, you can write

ArrayList<String> names = new ArrayList<>();

instead of

ArrayList<String> names = new ArrayList<String>();

Special Topic 7.2

The First Bug

According to legend, the first bug was one found in 1947 in the Mark II, a huge electro- mechanical computer at Harvard University. It really was caused by a bug—a moth was trapped in a relay switch. Actually, from the note that the operator left in the log book next to the moth (see the figure), it appears as if the term “bug” had already been in active use at the time.

The pioneering computer scientist Maurice Wilkes wrote: “Somehow, at the Moore School and afterwards, one had always assumed there would be no particular difficulty in getting programs right. I can remember the exact instant in time at which it dawned on me

The First Bug

Random Fact 6.1

Common Errors describe the kinds of errors that students often make, with an explanation of why the errors occur, and what to do about them.

Quality Tips explain good programming practices. These notes carefully motivate the reason behind the advice, and explain why the effort will be repaid later.

Productivity Hints teach students how to use their time and tools more effectively. They encourage students to be more productive with tips and techniques such as hand-tracing.

Special Topics present optional topics and provide additional explanation of others. New features of Java 7 are also covered in these notes.

Random Facts provide historical and social information on computing—for interest and to fulfill the “historical and social context” requirements of the ACM/IEEE curriculum guidelines.

bj4_fm.fm Page xv Saturday, November 7, 2009 12:01 PM

xvi

Walkthrough

WileyPLUS is an online environment that supports students and instructors. This book’s WileyPLUS course can complement the printed text or replace it altogether.

For Students

Different learning styles, different levels of proficiency, different levels of prepara- tion—each of your students is unique. WileyPLUS empowers all students to take advantage of their individual strengths.

Integrated, multi-media resources—including audio and visual exhibits and demon- stration problems—encourage active learning and provide multiple study paths to fit each student’s learning preferences.

• Worked Examples apply the problem-solving steps in the book to another realis- tic example.

• Screencast Videos present the author explaining the steps he is taking and show- ing his work as he solves a programming problem.

• Animations of key concepts allow students to replay dynamic explanations that instructors usually provide on a whiteboard.

Self-assessments are linked to relevant portions of the text. Students can take con- trol of their own learning and practice until they master the material.

• Practice quizzes can reveal areas where students need to focus. • Lab exercises can be assigned for self-study or for use in the lab. • “Code completion” questions enable students to practice programming skills by

filling in small code snippets and getting immediate feedback. • LabRat provides instant feedback on student solutions to all programming exer-

cises in the book.

For Instructors

WileyPLUS includes all of the instructor resources found on the companion site, and more.

WileyPLUS gives you tools for identifying those students who are falling behind, allowing you to intervene accordingly, without having to wait for them to come to office hours.

• Practice quizzes for pre-reading assessment, self-quizzing, or additional practice can be used as-is or modified for your course needs.

• Multi-step laboratory exercises can be used in lab or assigned for extra student practice.

WileyPLUS simplifies and automates student performance assessment, making assignments, and scoring student work.

• An extensive set of multiple-choice questions for quizzing and testing have been developed to focus on skills, not just terminology.

• “Code completion” questions can also be added to online quizzes. • LabRat can track student work on all programming exercises in the book, adding

the student solution and a record of completion to the gradebook. • Solutions to all review and programming exercises are provided.

WileyPLUS

bj4_fm.fm Page xvi Saturday, November 7, 2009 12:01 PM

Walkthrough

xvii

Students can read the book online and take advantage of searching and cross-linking.

With WileyPLUS …

Students can practice programming by filling in small code snippets and getting immediate feedback.

Instructors can assign drill-and-practice questions to check that students did their reading and grasp basic concepts.

Students can play and replay dynamic explanations of concepts and program flow.

Students can check that their programming assignments fulfill the specifications.

To order

Big Java

with its WileyPLUS course for your students, use

ISBN

978-0-470-57827-8.

bj4_fm.fm Page xvii Saturday, November 7, 2009 12:01 PM

xviii

Acknowledgments

Many thanks to Beth Golub, Lauren Sapira, Andre Legaspi, Don Fowley, Mike Berlin, Janet Foxman, Lisa Gee, and Bud Peters at John Wiley & Sons, and Vickie Piercey at Publishing Services for their help with this project. An especially deep acknowledgment and thanks goes to Cindy Johnson for her hard work, sound judgment, and amazing attention to detail.

I am grateful to Suzanne Dietrich, Rick Giles, Kathy Liszka, Stephanie Smullen, Julius Dichter, Patricia McDermott-Wells, and David Woolbright, for their work on the supplemental material.

Many thanks to the individuals who reviewed the manuscript for this edition, made valuable suggestions, and brought an embarrassingly large number of errors and omissions to my attention. They include:

Ian Barland,

Radford University

Rick Birney,

Arizona State University

Paul Bladek,

Edmonds Community College

Robert P. Burton,

Brigham Young University

Teresa Cole,

Boise State University

Geoffrey Decker,

Northern Illinois University

Eman El-Sheikh,

University of West Florida

David Freer,

Miami Dade College

Ahmad Ghafarian,

North Georgia College & State University

Norman Jacobson,

University of California, Irvine

Mugdha Khaladkar,

New Jersey Institute of Technology

Hong Lin,

University of Houston, Downtown

Jeanna Matthews,

Clarkson University

Sandeep R. Mitra,

State University of New York, Brockport

Parviz Partow-Navid,

California State University, Los Angeles

Jim Perry,

Ulster County Community College

Kai Qian,

Southern Polytechnic State University

Cyndi Rader,

Colorado School of Mines

Chaman Lal Sabharwal,

Missouri University of Science and Technology

John Santore,

Bridgewater State College

Stephanie Smullen,

University of Tennessee, Chattanooga

Monica Sweat,

Georgia Institute of Technology

Shannon Tauro,

University of California, Irvine

Russell Tessier,

University of Massachusetts, Amherst

Jonathan L. Tolstedt,

North Dakota State University

David Vineyard,

Kettering University

Lea Wittie,

Bucknell University

Acknowledgments

bj4_fm.fm Page xviii Saturday, November 7, 2009 12:01 PM

Acknowledgments

xix

Every new edition builds on the suggestions and experiences of prior reviewers and users. I am grateful for the invaluable contributions these individuals have made to this book:

Tim Andersen, Boise State University Ivan Bajic, San Diego State University Ted Bangay, Sheridan Institute of Technology George Basham, Franklin University Sambit Bhattacharya, Fayetteville State University Joseph Bowbeer, Vizrea Corporation Timothy A. Budd, Oregon State University Frank Butt, IBM Jerry Cain, Stanford University Adam Cannon, Columbia University Nancy Chase, Gonzaga University Archana Chidanandan, Rose-Hulman Institute

of Technology Vincent Cicirello, The Richard Stockton College

of New Jersey Deborah Coleman, Rochester Institute

of Technology Valentino Crespi, California State University,

Los Angeles Jim Cross, Auburn University Russell Deaton, University of Arkansas H. E. Dunsmore, Purdue University Robert Duvall, Duke University Henry A. Etlinger, Rochester Institute

of Technology John Fendrich, Bradley University John Fulton, Franklin University David Geary, Sabreware, Inc. Margaret Geroch, Wheeling Jesuit University Rick Giles, Acadia University Stacey Grasso, College of San Mateo Jianchao Han, California State University,

Dominguez Hills Lisa Hansen, Western New England College Elliotte Harold Eileen Head, Binghamton University Cecily Heiner, University of Utah Brian Howard, Depauw University Lubomir Ivanov, Iona College Curt Jones, Bloomsburg University Aaron Keen, California Polytechnic State

University, San Luis Obispo

Elliot Koffman, Temple University Kathy Liszka, University of Akron Hunter Lloyd, Montana State University Youmin Lu, Bloomsburg University John S. Mallozzi, Iona College John Martin, North Dakota State University Scott McElfresh, Carnegie Mellon University Joan McGrory, Christian Brothers University Carolyn Miller, North Carolina State University Teng Moh, San Jose State University John Moore, The Citadel Faye Navabi, Arizona State University Kevin O’Gorman, California Polytechnic State

University, San Luis Obispo Michael Olan, Richard Stockton College Kevin Parker, Idaho State University Cornel Pokorny, California Polytechnic State

University, San Luis Obispo Roger Priebe, University of Texas, Austin C. Robert Putnam, California State University,

Northridge Neil Rankin, Worcester Polytechnic Institute Brad Rippe, Fullerton College Pedro I. Rivera Vega, University of Puerto Rico,

Mayaguez Daniel Rogers, SUNY Brockport Carolyn Schauble, Colorado State University Christian Shin, SUNY Geneseo Jeffrey Six, University of Delaware Don Slater, Carnegie Mellon University Ken Slonneger, University of Iowa Peter Stanchev, Kettering University Ron Taylor, Wright State University Joseph Vybihal, McGill University Xiaoming Wei, Iona College Todd Whittaker, Franklin University Robert Willhoft, Roberts Wesleyan College David Womack, University of Texas at

San Antonio Catherine Wyman, DeVry University Arthur Yanushka, Christian Brothers University Salih Yurttas, Texas A&M University

bj4_fm.fm Page xix Saturday, November 7, 2009 12:01 PM

bj4_fm.fm Page xx Saturday, November 7, 2009 12:01 PM

CONTENTS

xxi

PREFACE vii

SPECIAL FEATURES xxviii

1.1 What Is Programming? 2

1.2 The Anatomy of a Computer 3

1.3 Translating Human-Readable Programs to Machine Code 7

1.4 The Java Programming Language 9

1.5 The Structure of a Simple Program 11

1.6 Compiling and Running a Java Program 15

1.7 Errors 18

1.8 Algorithms 20

2.1 Types 34

2.2 Variables 36

2.3 The Assignment Operator 39

2.4 Objects, Classes, and Methods 41

2.5 Method Parameters and Return Values 43

2.6 Constructing Objects 46

2.7 Accessor and Mutator Methods 48

2.8 The API Documentation 49

2.9T Implementing a Test Program 52

2.10 Object References 54

2.11G Graphical Applications and Frame Windows 58

2.12G Drawing on a Component 60

2.13G Ellipses, Lines, Text, and Color 66

3.1 Instance Variables 82

3.2 Encapsulation 84

3.3 Specifying the Public Interface of a Class 85

3.4 Commenting the Public Interface 89

3.5 Providing the Class Implementation 92

3.6T Unit Testing 98

CHAPTER 1 INTRODUCTION 1

CHAPTER 2 USING OBJECTS 33

CHAPTER 3 IMPLEMENTING CLASSES 81

bj4_fm.fm Page xxi Saturday, November 7, 2009 12:01 PM

xxii Contents

3.7 Local Variables 100

3.8 Implicit Parameters 102

3.9G Shape Classes 106

4.1 Number Types 128

4.2 Constants 133

4.3 Arithmetic Operations and Mathematical Functions 137

4.4 Calling Static Methods 145

4.5 Strings 149

4.6 Reading Input 155

5.1 The if Statement 172

5.2 Comparing Values 177

5.3 Multiple Alternatives 185

5.4 Using Boolean Expressions 195

5.5T Code Coverage 202

6.1 while Loops 218

6.2 for Loops 228

6.3 Common Loop Algorithms 236

6.4 Nested Loops 247

6.5 Application: Random Numbers and Simulations 250

6.6T Using a Debugger 257

7.1 Arrays 276

7.2 Array Lists 283

7.3 Wrappers and Auto-boxing 289

7.4 The Enhanced for Loop 291

7.5 Partially Filled Arrays 292

7.6 Common Array Algorithms 294

7.7T Regression Testing 306

7.8 Two-Dimensional Arrays 310

CHAPTER 4 FUNDAMENTAL DATA TYPES 127

CHAPTER 5 DECISIONS 171

CHAPTER 6 ITERATION 217

CHAPTER 7 ARRAYS AND ARRAY LISTS 275

bj4_fm.fm Page xxii Saturday, November 7, 2009 12:01 PM

Contents xxiii

8.1 Discovering Classes 328

8.2 Cohesion and Coupling 329

8.3 Immutable Classes 332

8.4 Side Effects 333

8.5 Preconditions and Postconditions 338

8.6 Static Methods 342

8.7 Static Variables 345

8.8 Scope 348

8.9 Packages 352

8.10T Unit Test Frameworks 359

9.1 Using Interfaces for Algorithm Reuse 372

9.2 Converting Between Class and Interface Types 378

9.3 Polymorphism 380

9.4 Using Interfaces for Callbacks 381

9.5 Inner Classes 385

9.6T Mock Objects 389

9.7G Events, Event Sources, and Event Listeners 391

9.8G Using Inner Classes for Listeners 394

9.9G Building Applications with Buttons 396

9.10G Processing Timer Events 400

9.11G Mouse Events 403

10.1 Inheritance Hierarchies 420

10.2 Implementing Subclasses 423

10.3 Overriding Methods 427

10.4 Subclass Construction 430

10.5 Converting Between Subclass and Superclass Types 433

10.6 Polymorphism and Inheritance 435

10.7 Object: The Cosmic Superclass 444

10.8G Using Inheritance to Customize Frames 456

CHAPTER 8 DESIGNING CLASSES 327

CHAPTER 9 INTERFACES AND POLYMORPHISM 371

CHAPTER 10 INHERITANCE 419

bj4_fm.fm Page xxiii Saturday, November 7, 2009 12:01 PM

xxiv Contents

11.1 Reading and Writing Text Files 468

11.2 Reading Text Input 473

11.3 Throwing Exceptions 481

11.4 Checked and Unchecked Exceptions 483

11.5 Catching Exceptions 485

11.6 The finally Clause 488

11.7 Designing Your Own Exception Types 490

11.8 Case Study: A Complete Example 491

12.1 The Software Life Cycle 506

12.2 Discovering Classes 511

12.3 Relationships Between Classes 513

12.4 Case Study: Printing an Invoice 518

12.5 Case Study: An Automatic Teller Machine 529

13.1 Triangle Numbers 558

13.2 Recursive Helper Methods 566

13.3 The Efficiency of Recursion 568

13.4 Permutations 573

13.5 Mutual Recursions 579

14.1 Selection Sort 596

14.2 Profiling the Selection Sort Algorithm 599

14.3 Analyzing the Performance of the Selection Sort Algorithm 602

14.4 Merge Sort 606

14.5 Analyzing the Merge Sort Algorithm 609

14.6 Searching 614

14.7 Binary Search 616

14.8 Sorting Real Data 619

15.1 Using Linked Lists 630

15.2 Implementing Linked Lists 636

15.3 Abstract Data Types 647

15.4 Stacks and Queues 651

CHAPTER 11 INPUT/OUTPUT AND EXCEPTION HANDLING 467

CHAPTER 12 OBJECT-ORIENTED DESIGN 505

CHAPTER 13 RECURSION 557

CHAPTER 14 SORTING AND SEARCHING 595

CHAPTER 15 AN INTRODUCTION TO DATA STRUCTURES 629

bj4_fm.fm Page xxiv Saturday, November 7, 2009 12:01 PM

Contents xxv

16.1 Sets 666

16.2 Maps 670

16.3 Hash Tables 674

16.4 Computing Hash Codes 681

16.5 Binary Search Trees 686

16.6 Binary Tree Traversal 696

16.7 Priority Queues 698

16.8 Heaps 699

16.9 The Heapsort Algorithm 709

17.1 Generic Classes and Type Parameters 724

17.2 Implementing Generic Types 725

17.3 Generic Methods 728

17.4 Constraining Type Parameters 730

17.5 Type Erasure 732

18.1G Processing Text Input 740

18.2G Text Areas 743

18.3G Layout Management 746

18.4G Choices 748

18.5G Menus 758

18.6G Exploring the Swing Documentation 764

19.1 Readers, Writers, and Streams 778

19.2 Binary Input and Output 779

19.3 Random Access 785

19.4 Object Streams 790

20.1 Running Threads 802

20.2 Terminating Threads 807

20.3 Race Conditions 809

20.4 Synchronizing Object Access 815

20.5 Avoiding Deadlocks 818

20.6G Case Study: Algorithm Animation 824

CHAPTER 16 ADVANCED DATA STRUCTURES 665

CHAPTER 17 GENERIC PROGRAMMING 723

CHAPTER 18 GRAPHICAL USER INTERFACES (ADVANCED) 739

CHAPTER 19 STREAMS AND BINARY INPUT/OUTPUT (ADVANCED) 777

CHAPTER 20 MULTITHREADING (ADVANCED) 801

bj4_fm.fm Page xxv Saturday, November 7, 2009 12:01 PM

xxvi Contents

21.1 The Internet Protocol 840

21.2 Application Level Protocols 842

21.3 A Client Program 845

21.4 A Server Program 848

21.5 URL Connections 856

23.1 Organizing Database Information 866

23.2 Queries 873

23.3 Installing a Database 881

23.4 Database Programming in Java 886

23.5 Case Study: A Bank Database 893

25.1 XML Tags and Documents 906

25.2 Parsing XML Documents 914

25.3 Creating XML Documents 923

25.4 Validating XML Documents 929

26.1 The Architecture of a Web Application 948

26.2 The Architecture of a JSF Application 950

26.3 JavaBeans Components 956

26.4 Navigation Between Pages 957

26.5 JSF Components 963

26.6 A Three-Tier Application 965

APPENDIX A THE BASIC LATIN AND LATIN-1 SUBSETS OF UNICODE 979

APPENDIX B JAVA OPERATOR SUMMARY 983

APPENDIX C JAVA RESERVED WORD SUMMARY 985

APPENDIX D THE JAVA LIBRARY 987

APPENDIX E JAVA SYNTAX SUMMARY 1029

APPENDIX F HTML SUMMARY 1040

APPENDIX G TOOL SUMMARY 1045

APPENDIX H JAVADOC SUMMARY 1048

APPENDIX I NUMBER SYSTEMS 1050

APPENDIX J BIT AND SHIFT OPERATIONS 1055

CHAPTER 21 INTERNET NETWORKING (ADVANCED) 839

CHAPTER 22 RELATIONAL DATABASES (ADVANCED) 865

CHAPTER 24 XML (ADVANCED) 905

CHAPTER 26 WEB APPLICATIONS (ADVANCED) 947

APPENDICES

bj4_fm.fm Page xxvi Saturday, November 7, 2009 12:01 PM

Contents xxvii

APPENDIX K UML SUMMARY 1058

APPENDIX L JAVA LANGUAGE CODING GUIDELINES 1061

GLOSSARY 1068

INDEX 1083

ILLUSTRATION CREDITS 1131

Arrays 279 Array Lists 284 Assertion 339 Assignment 39

Calling a Superclass Constructor 431 Calling a Superclass Method 428 Cast 140 Catching Exceptions 486 Class Declaration 88 Comparisons 178 Constant Declaration 134

Declaring a Generic Class 727 Declaring a Generic Method 729 Declaring an Enumeration Type 194 Declaring an Interface 374

Implementing an Interface 375 Importing a Class from a Package 51 Inheritance 424 Instance Variable Declaration 83

Method Call 13 Method Declaration 94

Object Construction 47

Package Specification 353

Static Method Call 146

The finally Clause 488 The “for each” Loop 291 The for Statement 230 The if Statement 174 The instanceof Operator 434 The throws Clause 485 The while Statement 218 Throwing an Exception 481

Variable Declaration 37

ALPHABETICAL LIST OF SYNTAX BOXES

bj4_fm.fm Page xxvii Saturday, November 7, 2009 12:01 PM

xxviii Special Features

Chapter Common Errors

How Tos and Worked Examples

Quality Tips

1 Introduction Omitting Semicolons 14 Misspelling Words 20

Developing and Describing an Algorithm 23

Writing an Algorithm for Tiling a Floor

2 Using Objects Confusing Variable Declaration and Assign- ment Statements 40

Trying to Invoke a Constructor Like a Method 47

How Many Days Have You Been Alive?

Working with Pictures

Choose Descriptive Names for Variables 38

3 Implementing Classes

Declaring a Constructor as void 89

Forgetting to Initialize Object References in a Constructor 101

Implementing a Class 96 Making a Simple Menu Drawing Graphical

Shapes 110

4 Fundamental Data Types

Integer Division 142 Unbalanced

Parentheses 143 Roundoff Errors 144

Carrying Out Computations 146

Computing the Volume and Surface Area of a Pyramid

Extracting Initials

Do Not Use Magic Numbers 137

White Space 144 Factor Out

Common Code 144

5 Decisions A Semicolon After the if Condition 176

Using == to Compare Strings 180

The Dangling else Problem 191

Multiple Relational Operators 199

Confusing && and || Conditions 199

Implementing an if Statement 183

Extracting the Middle

Brace Layout 174 Avoid Conditions with

Side Effects 183 Calculate Sample Data

Manually 203 Prepare Test Cases

Ahead of Time 204

6 Iteration Infinite Loops 223 Off-by-One Errors 226 Forgetting a

Semicolon 233 A Semicolon Too

Many 233

Writing a Loop 241 Credit Card Processing Manipulating the Pixels

in an Image Debugging 260 A Sample Debugging

Session

Use for Loops for Their Intended Purpose 232

Don’t Use != to Test the End of a Range 234

Symmetric and Asymmetric Bounds 235

Count Iterations 235

bj4_fm.fm Page xxviii Saturday, November 7, 2009 12:01 PM

Special Features xxix

Productivity Hints

Special Topics

Random Facts

Understand the File System 17 Have a Backup Strategy 18

Alternative Comment Syntax 14 The ENIAC and the Dawn of Computing 6

Don’t Memorize—Use Online Help 51

Testing Classes in an Interactive Environment 53

Applets 63

Mainframes—When Dinosaurs Ruled the Earth 57

The Evolution of the Internet 69

The javadoc Utility 92 Calling One Constructor from Another 104

Electronic Voting Machines 104 Computer Graphics 114

Reading Exception Reports 152

Big Numbers 130 Binary Numbers 130 Combining Assignment

and Arithmetic 145 Escape Sequences 152 Strings and the char Type 153 Formatting Numbers 158 Using Dialog Boxes for

Input and Output 159

The Pentium Floating-Point Bug 132

International Alphabets 154

Indentation and Tabs 175 Hand-Tracing 192 Make a Schedule and Make

Time for Unexpected Problems 193

The Conditional Operator 176 The switch Statement 187 Enumeration Types 194 Lazy Evaluation of Boolean

Operators 200 De Morgan’s Law 200 Logging 204

Artificial Intelligence 201

Hand-Tracing Loops 223 do Loops 227 Variables Declared

in a for Loop Header 234 The “Loop and a Half”

Problem 245 The break and continue

Statements 246 Loop Invariants 255

The First Bug 262

bj4_fm.fm Page xxix Saturday, November 7, 2009 12:01 PM

xxx Special Features

Chapter Common Errors

How Tos and Worked Examples

Quality Tips

7 Arrays and Array Lists

Bounds Errors 279 Uninitialized and

Unfilled Arrays 280 Length and Size 288 Underestimating the

Size of a Data Set 294

Working with Arrays and Array Lists 304

Rolling the Dice A World Population

Table

Use Arrays for Sequences of Related Values 280

Make Parallel Arrays into Arrays of Objects 280

8 Designing Classes

Trying to Modify Primitive Type Parameters 334

Shadowing 350 Confusing Dots 355

Programming with Packages 356

Consistency 331 Minimize Side Effects 336 Don’t Change Contents of

Parameter Variables 336 Minimize the Use of

Static Methods 344 Minimize Variable

Scope 351

9 Interfaces and Polymorphism

Forgetting to Declare Implementing Methods as Public 377

Trying to Instantiate an Interface 379

Modifying Parameter Types in the Implementing Method 393

Forgetting to Attach a Listener 399

By Default, Components Have Zero Width and Height 400

Forgetting to Repaint 402

Investigating Number Sequences

10 Inheritance Confusing Super- and Subclasses 425

Shadowing Instance Variables 426

Accidental Overloading 429

Failing to Invoke the Superclass Method 430

Overriding Methods to Be Less Accessible 438

Declaring the equals Method with the Wrong Parameter Type 450

Developing an Inheritance Hierarchy 440

Implementing an Employee Hierarchy for Payroll Processing

Supply toString in All Classes 449

Clone Mutable Instance Variables in Accessor Methods 451

bj4_fm.fm Page xxx Saturday, November 7, 2009 12:01 PM

Special Features xxxi

Productivity Hints

Special Topics

Random Facts

Easy Printing of Arrays and Array Lists 303

Batch Files and Shell Scripts 308

Methods with a Variable Number of Parameters 281

ArrayList Syntax Enhancements in Java 7 288

Two-Dimensional Arrays with Variable Row Lengths 313

Multidimensional Arrays 314

An Early Internet Worm 282 The Therac-25 Incidents 309

Call by Value and Call by Reference 337

Class Invariants 341 Static Imports 347 Alternative Forms of

Instance and Static Variable Initialization 347

Package Access 355

The Explosive Growth of Personal Computers 357

Don’t Use a Container as a Listener 399

Constants in Interfaces 377 Anonymous Classes 387 Event Adapters 406

Operating Systems 388 Programming Languages 407

Abstract Classes 437 Final Methods and Classes 438 Protected Access 439 Inheritance and the toString Method 449

Inheritance and the equals Method 450

Implementing the clone Method 452

Enumeration Types Revisited 454 Adding the main Method to

the Frame Class 457

Scripting Languages 455

bj4_fm.fm Page xxxi Saturday, November 7, 2009 12:01 PM

xxxii Special Features

Chapter Common Errors

How Tos and Worked Examples

Quality Tips

11 Input/Output and Exception Handling

Backslashes in File Names 470

Constructing a Scanner with a String 470

Processing Text Files 478 Analyzing Baby Names

Throw Early, Catch Late 487

Do Not Squelch Exceptions 487

Do Not Use catch and finally in the Same try Statement 489

Do Throw Specific Exceptions 491

12 Object- Oriented Design

CRC Cards and UML Diagrams 516

13 Recursion Infinite Recursion 561 Tracing Through

Recursive Methods 562

Thinking Recursively 563 Finding Files

14 Sorting and Searching

The compareTo Method Can Return Any Integer, Not Just –1, 0, and 1 621

15 An Introduc- tion to Data Structures

A Reverse Polish Notation Calculator

16 Advanced Data Structures

Forgetting to Provide hashCode 685

Choosing a Container 673 Word Frequency

Use Interface References to Manipulate Data Structures 670

17 Generic Programming

Genericity and Inheritance 731

Using Generic Types in a Static Context 735

18 Graphical User Interfaces (Advanced)

Laying Out a User Interface 755

Implementing a Graphical User Interface (GUI) 763

bj4_fm.fm Page xxxii Saturday, November 7, 2009 12:01 PM

Special Features xxxiii

Productivity Hints

Special Topics

Random Facts

Regular Expressions 477 File Dialog Boxes 471 Reading Web Pages 472 Command Line Arguments 472 Automatic Resource

Management in Java 7 490

The Ariane Rocket Incident 495

Attributes and Methods in UML Diagrams 516

Multiplicities 517 Aggregation and Association 517

Programmer Productivity 510 Software Development—

Art or Science? 548

The Limits of Computation 576

Insertion Sort 604 Oh, Omega, and Theta 605 The Quicksort Algorithm 611 The Parameterized Comparable Interface 621

The Comparator Interface 622

The First Programmer 613

The Iterable Interface and the “For Each” Loop 635

Static Inner Classes 646

Standardization 650 Reverse Polish Notation 654

Enhancements to Collection Classes in Java 7 672

Software Piracy 714

Wildcard Types 731

Use a GUI Builder 757

bj4_fm.fm Page xxxiii Saturday, November 7, 2009 12:01 PM

xxxiv Special Features

Chapter Common Errors

How Tos and Worked Examples

Quality Tips

19 Streams and Binary Input/ Output (Advanced)

Negative byte Values 782 Using Files and Streams 793

20 Multi- threading (Advanced)

Calling await Without Calling signalAll 822

Calling signalAll Without Locking the Object 823

Use the Runnable Interface 806

Check for Thread Interruptions in the run Method of a Thread 809

21 Internet Networking (Advanced)

Designing Client/Server Programs 855

22 Relational Databases (Advanced)

Joining Tables Without Specifying a Link Condition 879

Delimiters in Manually Constructed Queries 892

Don’t Hardwire Database Connection Parameters into Your Program 892

23 XML (Advanced)

XML Elements Describe Objects, Not Classes 919

Designing an XML Document Format 909

Writing an XML Document 928

Writing a DTD 936

Prefer XML Elements over Attributes 911

Avoid Children with Mixed Elements and Text 912

24 Web Applications (Advanced)

Designing a Managed Bean 962

bj4_fm.fm Page xxxiv Saturday, November 7, 2009 12:01 PM

Special Features xxxv

Productivity Hints

Special Topics

Random Facts

Encryption Algorithms 783

Thread Pools 806 Object Locks and

Synchronized Methods 823 The Java Memory Model 824

Embedded Systems 832

Use High-Level Libraries 859

Stick with the Standard 871 Avoid Unnecessary

Data Replication 872 Don’t Replicate Columns

in a Table 873 Let the Database

Do the Work 892

Primary Keys and Indexes 872 Transactions 898 Object-Relational Mapping 899

Databases and Privacy 880

Schema Languages 938 Other XML Technologies 939

Word Processing and Typesetting Systems 912

Grammars, Parsers, and Compilers 920

Session State and Cookies 955 AJAX 973

bj4_fm.fm Page xxxv Saturday, November 7, 2009 12:01 PM

bj4_fm.fm Page xxxvi Saturday, November 7, 2009 12:01 PM

1

Chapter

1

Introduction

C H A P T E R G O A L S

•

To understand the activity of programming

•

To learn about the architecture of computers

•

To learn about machine code and high-level programming languages

•

To become familiar with the structure of simple Java programs

•

To compile and run your first Java program

•

To recognize syntax and logic errors

•

To write pseudocode for simple algorithms

The purpose of this chapter is to familiarize you with the concepts

of programming and program development. It reviews the architecture of a computer and discusses

the difference between machine code and high-level programming languages. You will see how to

compile and run your first Java program, and how to diagnose errors that may occur when a

program is compiled or executed. Finally, you will learn how to formulate simple algorithms using

pseudocode notation.

BJ4_ch01_3.fm Page 1 Monday, June 29, 2009 11:15 AM

2

CHAPTER CONTENTS

You have probably used a computer for work or fun. Many people use computers for everyday tasks such as balancing a checkbook or writing a term paper. Comput- ers are good for such tasks. They can handle repetitive chores, such as totaling up numbers or placing words on a page, without getting bored or exhausted. Comput- ers also make good game machines because they can play sequences of sounds and pictures, involving the human user in the process.

The flexibility of a computer is quite an amazing phenomenon. The same machine can balance your checkbook, print your term paper, and play a game. In contrast, other machines carry out a much narrower range of tasks—a car drives and a toaster toasts.

To achieve this flexibility, the computer must be

programmed

to perform each task. A computer itself is a machine that stores data (numbers, words, pictures), interacts with devices (the monitor screen, the sound system, the printer), and exe- cutes programs. Programs are sequences of instructions and decisions that the com- puter carries out to achieve a task. One program balances checkbooks; a different program, perhaps designed and constructed by a different company, processes words; and a third program, probably from yet another company, plays a game.

Today’s computer programs are so sophisticated that it is hard to believe that they are all composed of extremely primitive operations. A typical operation may be one of the following:

• Put a red dot onto this screen position. • Get a number from this location in memory. • Add up two numbers. • If this value is negative, continue the program at that instruction.

A computer program tells a computer, in minute detail, the sequence of steps that are needed to complete a task. A program contains a huge number of simple opera- tions, and the computer executes them at great speed. The computer has no intelli- gence—it simply executes instruction sequences that have been prepared in advance.

1.1 What Is Programming?

A computer must be programmed to perform tasks. Different tasks require different programs.

A computer program executes a sequence of very basic operations in rapid succession.

A computer program contains the instruction sequences for all tasks that it can execute.

1.1 What Is Programming?

2

1.2 The Anatomy of a Computer

3

R

ANDOM

F

ACT

1.2: The ENIAC and the Dawn of

Computing

7

1.3 Translating Human-Readable Programs to Machine Code

8

1.4 The Java Programming Language

9

1.5 The Structure of a Simple Program

11

S

YNTAX

1.1: Method Call

14

C

OMMON

E

RROR

1.1: Omitting Semicolons

14

S

PECIAL

T

OPIC

1.1: Alternative Comment Syntax

15

1.6 Compiling and Running a Java Program

15

P

RODUCTIVITY

H

INT

1.1: Understand the File System

18

P

RODUCTIVITY

H

INT

1.3: Have a Backup Strategy

19

1.7 Errors

19

C

OMMON

E

RROR

1.2: Misspelling Words

21

1.8 Algorithms

21

H

OW

T

O

1.1: Describing an Algorithm with

Pseudocode

24

W

ORKED

E

XAMPLE

1.1: Writing an Algorithm for Tiling a

Floor

BJ4_ch01_3.fm Page 2 Monday, June 29, 2009 11:15 AM

1.2 The Anatomy of a Computer

3

To use a computer, no knowledge of programming is required. When you write a term paper with a word processor, that computer program has been developed by the manufacturer and is ready for you to use. That is only to be expected—you can drive a car without being a mechanic and toast bread without being an electrician.

A primary purpose of this book is to teach you how to design and implement computer programs. You will learn how to formulate instructions for all tasks that your programs need to execute.

Keep in mind that programming a sophisticated computer game or word proces- sor requires a team of many highly skilled programmers, graphic artists, and other professionals. Your first programming efforts will be more mundane. The concepts and skills you learn in this book form an important foundation, but you should not expect to immediately produce professional software. A typical college degree in computer science or software engineering takes four years to complete; this book is intended as a text for an introductory course in such a program.

Many students find that there is an immense thrill even in simple programming tasks. It is an amazing experience to see the computer carry out a task precisely and quickly that would take you hours of drudgery.

1.

What is required to play a music CD on a computer?

2.

Why is a CD player less flexible than a computer?

3.

Can a computer program develop the initiative to execute tasks in a better way than its programmers envisioned?

To understand the programming process, you need to have a rudimentary under- standing of the building blocks that make up a computer. This section will describe a personal computer. Larger computers have faster, larger, or more powerful com- ponents, but they have fundamentally the same design.

At the heart of the computer lies the

central processing unit

(CPU) (see Figure 1). It consists of a single

chip

(integrated circuit) or a small number of chips. A com- puter chip is a component with a plastic or metal housing, metal connectors, and

S E L F C H E C K

1.2 The Anatomy of a Computer

At the heart of the computer lies the central processing unit (CPU).

Figure 1

Central Processing Unit

bj4_ch01_5.fm Page 3 Wednesday, September 9, 2009 9:44 AM

4

Chapter 1 Introduction

inside wiring made principally from silicon. For a CPU chip, the inside wiring is enormously complicated. For example, the Intel Atom chip (a popular CPU for inexpensive laptops at the time of this writing) contains about 50 million structural elements called

transistors

—the elements that enable electrical signals to control other electrical signals, making automatic computing possible. The CPU locates and executes the program instructions; it carries out arithmetic operations such as addition, subtraction, multiplication, and division; and it fetches data from storage and input/output devices and sends data back.

The computer keeps data and programs in

storage.

There are two kinds of stor- age.

Primary storage,

also called

random-access memory

(RAM ) or simply

memory,

is fast but expensive; it is made from memory chips (see Figure 2). Primary storage has two disadvantages. It is comparatively expensive, and it loses all its data when the power is turned off.

Secondary storage,

usually a

hard disk

(see Figure 3),

pro- vides less expensive storage that persists without electricity. A hard disk consists of rotating platters, which are coated with a magnetic material, and read/write heads, which can detect and change the patterns of varying magnetic flux on the platters.

Some computers are self-contained units, whereas others are interconnected through

networks.

Home computers are usually intermittently connected to the Internet via a dialup or broadband connection. The computers in your computer lab are probably permanently connected to a local area network. Through the net- work cabling, the computer can read programs from central storage locations or send data to other computers. For the user of a networked computer, it may not even be obvious which data reside on the computer itself and which are transmitted through the network.

Most computers have

removable storage

devices that can access data or programs on media such as memory sticks or optical disks.

To interact with a human user, a computer requires other peripheral devices. The computer transmits information to the user through a display screen, loudspeakers, and printers. The user can enter information and directions to the computer by using a keyboard or a pointing device such as a mouse.

Figure 2

A Memory Module with Memory Chips

Data and programs are stored in primary storage (memory) and secondary storage (such as a hard disk).

BJ4_ch01_3.fm Page 4 Monday, June 29, 2009 11:15 AM

1.2 The Anatomy of a Computer

5

The CPU, the RAM, and the electronics controlling the hard disk and other devices are interconnected through a set of electrical lines called a

bus.

Data travel along the bus from the system memory and peripheral devices to the CPU and back. Figure 4 shows a

motherboard,

which contains the CPU, the RAM, and con- nectors to peripheral devices.

Figure 3

A Hard Disk

Figure 4

A Motherboard

BJ4_ch01_3.fm Page 5 Monday, June 29, 2009 11:15 AM

6

Chapter 1 Introduction

Figure 5 gives a schematic overview of the architecture of a computer. Program instructions and data (such as text, numbers, audio, or video) are stored on the hard disk, on an optical disk (such as a DVD), or on a network. When a program is started, it is brought into memory where it can be read by the CPU. The CPU reads the program one instruction at a time. As directed by these instructions, the CPU reads data, modifies it, and writes it back to RAM or to secondary storage. Some program instructions will cause the CPU to interact with the devices that control the display screen or the speaker. Because these actions happen many times over and at great speed, the human user will perceive images and sound. Similarly, the CPU can send instructions to a printer to mark the paper with patterns of closely spaced dots, which a human recognizes as text characters and pictures. Some pro- gram instructions read user input from the keyboard or mouse. The program ana- lyzes the nature of these inputs and then executes the next appropriate instructions.

4.

Where is a program stored when it is not currently running?

5.

Which part of the computer carries out arithmetic operations, such as addition and multiplication?

The ENIAC and the Dawn of Computing

Random Fact 1.1 tells the story of the ENIAC, the first usable electronic computer. The ENIAC was completed in 1946, contained about 18,000 vacuum tubes, and filled a large room.

Figure 5

Schematic Diagram of a Computer

Printer

Mouse

Keyboard

Bus

Ports

CPU

RAM

Disk Controller

Hard disk

Optical disk drive

Monitor

Speakers

Internet

Graphics card

Sound card

Network card

The CPU reads machine instructions from memory. The instructions direct it to communicate with memory, secondary storage, and peripheral devices.

S E L F C H E C K

Random Fact 1.1

BJ4_ch01_3.fm Page 6 Monday, June 29, 2009 11:15 AM

1.2 The Anatomy of a Computer

7

The ENIAC and the Dawn of Computing

The ENIAC (

e

lectronic

n

umerical

i

ntegrator

a

nd

c

omputer) was the first usable electronic computer. It was designed by J. Presper Eckert and John Mauchly at the University of Penn- sylvania and was completed in 1946. Instead of transistors, which were not invented until two years after it was built, the ENIAC contained about 18,000

vacuum tubes

in many cabi- nets housed in a large room. Vacuum tubes burned out at the rate of several tubes per day. An attendant with a shopping cart full of tubes constantly made the rounds and replaced defective ones. The computer was programmed by connecting wires on panels. Each wiring configuration would set up the computer for a particular problem. To have the computer work on a different problem, the wires had to be replugged.

Work on the ENIAC was supported by the U.S. Navy, which was interested in computa- tions of ballistic tables that would give the trajectory of a projectile, depending on the wind resistance, initial velocity, and atmospheric conditions. To compute the trajectories, one must find the numerical solutions of certain differential equations; hence the name “numerical integrator”. Before machines like ENIAC were developed, humans did this kind of work, and until the 1950s the word “computer” referred to these people. The ENIAC was later used for peaceful purposes, such as the tabulation of U.S. census data.

The ENIAC

Random Fact 1.2

BJ4_ch01_3.fm Page 7 Monday, June 29, 2009 11:15 AM

8

Chapter 1 Introduction

On the most basic level, computer instructions are extremely primitive. The proces- sor executes

machine instructions.

CPUs from different vendors, such as the Intel Pentium or the Sun SPARC, have different sets of machine instructions. To enable Java applications to run on multiple CPUs without modification, Java programs contain machine instructions for a so-called “Java virtual machine” (JVM), an ideal- ized CPU that is simulated by a program run on the actual CPU.

The difference between actual and virtual machine instructions is not impor- tant—all you need to know is that machine instructions are very simple, are encoded as numbers and stored in memory, and can be executed very quickly.

A typical sequence of machine instructions is

1.

Load the contents of memory location 40.

2.

Load the value 100.

3.

If the first value is greater than the second value, continue with the instruction that is stored in memory location 240.

Actually, machine instructions are encoded as numbers so that they can be stored in memory. On the Java virtual machine, this sequence of instructions is encoded as the sequence of numbers

21 40 16 100 163 240

When the virtual machine fetches this sequence of numbers, it decodes them and executes the associated sequence of commands.

How can you communicate the command sequence to the computer? The most direct method is to place the actual numbers into the computer memory. This is, in fact, how the very earliest computers worked. However, a long program is com- posed of thousands of individual commands, and it is tedious and error-prone to look up the numeric codes for all commands and manually place the codes into memory. As we said before, computers are really good at automating tedious and error-prone activities, and it did not take long for computer programmers to realize that computers could be harnessed to help in the programming process.

In the mid-1950s,

high-level

programming languages began to appear. In these languages, the programmer expresses the idea behind the task that needs to be per- formed, and a special computer program, called a

compiler

,

translates the high-level description into machine instructions for a particular processor.

For example, in Java, the high-level programming language that you will use in this book, you might give the following instruction:

if (intRate > 100) System.out.println("Interest rate error");

This means, “If the interest rate is over 100, display an error message”. It is then the job of the compiler program to look at the sequence of characters

if (intRate >

100). . .

and translate that into

21 40 16 100 163 240 . . .

1.3 Translating Human-Readable Programs to Machine Code Generally, machine code depends on the CPU type. However, the instruction set of the Java virtual machine (JVM) can be executed on many CPUs.

Because machine instructions are encoded as numbers, it is difficult to write programs in machine code.

High-level languages allow you to describe tasks at a higher conceptual level than machine code.

BJ4_ch01_3.fm Page 8 Monday, June 29, 2009 11:15 AM

1.4 The Java Programming Language 9

Compilers are quite sophisticated programs. They translate logical statements, such as the if statement, into sequences of computations, tests, and jumps. They assign memory locations for variables—items of information identified by symbolic names—like intRate. In this course, we will generally take the existence of a com- piler for granted. If you decide to become a professional computer scientist, you may well learn more about compiler-writing techniques later in your studies.

6. What is the code for the Java virtual machine instruction “Load the contents of memory location 100”?

7. Does a person who uses a computer for office work ever run a compiler?

In 1991, a group led by James Gosling and Patrick Naughton at Sun Microsystems designed a programming language that they code-named “Green” for use in con- sumer devices, such as intelligent television “set-top” boxes. The language was designed to be simple and architecture neutral, so that it could be executed on a variety of hardware. No customer was ever found for this technology.

Gosling recounts that in 1994 the team realized, “We could write a really cool browser. It was one of the few things in the client/server mainstream that needed some of the weird things we’d done: architecture neutral, real-time, reliable, secure.” Java was introduced to an enthusiastic crowd at the SunWorld exhibition in 1995.

Since then, Java has grown at a phenomenal rate. Programmers have embraced the language because it is simpler than its closest rival, C++. In addition, Java has a rich library that makes it possible to write portable programs that can bypass pro- prietary operating systems—a feature that was eagerly sought by those who wanted to be independent of those proprietary systems and was bitterly fought by their vendors. A “micro edition” and an “enterprise edition” of the Java library make Java programmers at home on hardware ranging from smart cards and cell phones to the largest Internet servers.

Because Java was designed for the Internet, it has two attributes that make it very suitable for beginners: safety and portability. If you visit a web page that contains Java code (so-called applets—see Figure 6 for an example), the code automatically starts running. It is important that you can trust that applets are inherently safe. If an applet could do something evil, such as damaging data or reading personal infor- mation on your computer, then you would be in real danger every time you browsed the Web—an unscrupulous designer might put up a web page containing dangerous code that would execute on your machine as soon as you visited the page. The Java language has an assortment of security features that guarantees that no evil applets can run on your computer. As an added benefit, these features also help you to learn the language faster. The Java virtual machine can catch many kinds of beginners’ mistakes and report them accurately. (In contrast, many beginners’ mistakes in the C++ language merely produce programs that act in random and confusing ways.) The other benefit of Java is portability. The same Java program will run, without change, on Windows, UNIX, Linux, or the Macintosh. This too is a requirement for applets. When you visit a web page, the web server that serves up

A compiler translates programs written in a high-level language into machine code.

S E L F C H E C K

1.4 The Java Programming Language Java was originally designed for programming consumer devices, but it was first successfully used to write Internet applets.

Java was designed to be safe and portable, benefiting both Internet users and students.

BJ4_ch01_3.fm Page 9 Monday, June 29, 2009 11:15 AM

10 Chapter 1 Introduction

the page contents has no idea what computer you are using to browse the Web. It simply returns you the portable code that was generated by the Java compiler. The virtual machine on your computer executes that portable code. Again, there is a benefit for the student. You do not have to learn how to write programs for differ- ent operating systems.

At this time, Java is firmly established as one of the most important languages for general-purpose programming as well as for computer science instruction. How- ever, although Java is a good language for beginners, it is not perfect, for three reasons.

Because Java was not specifically designed for students, no thought was given to making it really simple to write basic programs. A certain amount of technical machinery is necessary in Java to write even the simplest programs. This is not a problem for professional programmers, but it is a drawback for beginning students. As you learn how to program in Java, there will be times when you will be asked to be satisfied with a preliminary explanation and wait for complete details in a later chapter.

Java was revised and extended many times during its life—see Table 1. In this book, we assume that you have Java version 5 or later.

Finally, you cannot hope to learn all of Java in one semester. The Java language itself is relatively simple, but Java contains a vast set of library packages that are required to write useful programs. There are packages for graphics, user interface design, cryptography, networking, sound, database storage, and many other pur-

Figure 6 An Applet for Visualizing Molecules (http://jmol.sourceforge.net/applet/)

Java has a very large library. Focus on learning those parts of the library that you need for your programming projects.

BJ4_ch01_3.fm Page 10 Monday, June 29, 2009 11:15 AM

1.5 The Structure of a Simple Program 11

poses. Even expert Java programmers cannot hope to know the contents of all of the packages—they just use those that they need for particular projects.

Using this book, you should expect to learn a good deal about the Java language and about the most important packages. Keep in mind that the central goal of this book is not to make you memorize Java minutiae, but to teach you how to think about programming.

8. What are the two most important benefits of the Java language? 9. How long does it take to learn the entire Java library?

When learning a new programming language, it is traditional to start with a “Hello, World!” program—a program that displays a greeting. Here is this program in Java:

ch01/hello/HelloPrinter.java

Program Run

Table 1 Java Versions

Version Year Important New Features

1.0 1996

1.1 1997 Inner classes

1.2 1998 Swing, Collections

1.3 2000 Performance enhancements

1.4 2002 Assertions, XML

5 2004 Generic classes, enhanced for loop, auto-boxing, enumerations

6 2006 Library improvements

7 2010 Small language changes and library improvements

S E L F C H E C K

1.5 The Structure of a Simple Program

1 public class HelloPrinter 2 { 3 public static void main(String[] args) 4 { 5 // Display a greeting in the console window 6 7 System.out.println("Hello, World!"); 8 } 9 }

Hello, World!

BJ4_ch01_3.fm Page 11 Monday, June 29, 2009 11:15 AM

12 Chapter 1 Introduction

In the next section, you will see how to compile and run this program. But let us first understand how it is structured.

The line, public class HelloPrinter

starts a new class. Classes are a fundamental concept in Java, and you will begin to study them in Chapter 2. In Java, every program consists of one or more classes.

The reserved word public denotes that the class is usable by the “public”. You will later encounter private features. At this point, you should simply regard the

public class ClassName { . . . }

as a necessary part of the “plumbing” that is required to write any Java program. In Java, every source file can contain at most one public class, and the name of the public class must match the name of the file containing the class. For example, the class HelloPrinter must be contained in a file HelloPrinter.java.

The construction public static void main(String[] args) { . . . }

defines a method called main. A method contains a collection of programming instructions that describe how to carry out a particular task. Every Java application must have a main method. Most Java programs contain other methods besides main, and you will see in Chapter 3 how to write other methods.

The parameter String[] args is a required part of the main method. (It contains command line arguments, which we will not discuss until Chapter 11.) The reserved word static indicates that the main method does not operate on an object. (As you will see in Chapter 2, most methods in Java do operate on objects, and static meth- ods are not common in large Java programs. Nevertheless, main must always be static, because it starts running before the program can create objects.)

At this time, simply consider public class ClassName { public static void main(String[] args) { . . . } }

as yet another part of the “plumbing”. Our first program has all instructions inside the main method of a class.

The first line inside the main method is a comment: // Display a greeting in the console window

This comment is purely for the benefit of the human reader, to explain in more detail what the next statement does. Any text enclosed between // and the end of the line is completely ignored by the compiler. Comments are used to explain the program to other programmers or to yourself.

Classes are the fundamental building blocks of Java programs.

Every Java application contains a class with a main method. When the application starts, the instructions in the main method are executed.

Each class contains definitions of methods. Each method contains a sequence of instructions.

Use comments to help human readers understand your program.

BJ4_ch01_3.fm Page 12 Monday, June 29, 2009 11:15 AM

1.5 The Structure of a Simple Program 13

The instructions or statements in the body of the main method—that is, the state- ments inside the curly braces ({})—are executed one by one. Each statement ends in a semicolon (;). Our method has a single statement:

System.out.println("Hello, World!");

This statement prints a line of text, namely “Hello, World!”. However, there are many places where a program can send that text: to a window, to a file, or to a net- worked computer on the other side of the world. You need to specify that the desti- nation is the system output—that is, a console window. The console window is represented in Java by an object called out. Just as you needed to place the main method in a HelloPrinter class, the designers of the Java library needed to place the out object into a class. They placed it in the System class, which contains useful objects and methods to access system resources. To use the out object in the System class, you must refer to it as System.out.

To use an object, such as System.out, you specify what you want to do to it. In this case, you want to print a line of text. The println method carries out this task.

You do not have to implement this method—the programmers who wrote the Java library already did that for us—but you do need to call the method.

Whenever you call a method in Java, you need to specify three items (see Figure 7):

1. The object that you want to use (in this case, System.out). 2. The name of the method you want to use (in this case, println). 3. A pair of parentheses, containing any other information the method needs (in

this case, "Hello, World!"). The technical term for this information is a parame- ter for the method. Note that the two periods in System.out.println have dif- ferent meanings. The first period means “locate the out object in the System class”. The second period means “apply the println method to that object”.

A sequence of characters enclosed in quotation marks "Hello, World!"

is called a string. You must enclose the contents of the string inside quotation marks so that the compiler knows you literally mean "Hello, World!". There is a rea- son for this requirement. Suppose you need to print the word main. By enclosing it in quotation marks, "main", the compiler knows you mean the sequence of charac- ters m a i n, not the method named main. The rule is simply that you must enclose all text strings in quotation marks, so that the compiler considers them plain text and does not try to interpret them as program instructions.

You can also print numerical values. For example, the statement System.out.println(3 + 4);

displays the number 7.

Figure 7 Calling a Method

A method is called by specifying an object, the method name, and the method parameters.

A string is a sequence of characters enclosed in quotation marks.

System.out.println("Hello, World!")

Object Method Parameters

BJ4_ch01_3.fm Page 13 Monday, June 29, 2009 11:15 AM

14 Chapter 1 Introduction

The println method prints a string or a number and then starts a new line. For example, the sequence of statements

System.out.println("Hello"); System.out.println("World!");

prints two lines of text: Hello World!

There is a second method, called print, that you can use to print an item without starting a new line. For example, the output of the two statements

System.out.print("00"); System.out.println(3 + 4);

is the single line 007

10. How would you modify the HelloPrinter program to print the words “Hello,” and “World!” on two lines?

11. Would the program continue to work if you omitted the line starting with //? 12. What does the following set of statements print?

System.out.print("My lucky number is"); System.out.println(3 + 4 + 5);

Omitting Semicolons

In Java every statement must end in a semicolon. Forgetting to type a semicolon is a com- mon error. It confuses the compiler, because the compiler uses the semicolon to find where one statement ends and the next one starts. The compiler does not use line breaks or closing braces to recognize the end of statements. For example, the compiler considers

System.out.println("Hello") System.out.println("World!");

Syntax 1.1 Method Call

object.methodName(parameters)Syntax

Example This is the

name of the method.

These parameters are

inputs to the method.

The method is

invoked on this object.

System.out.println("Hello, World!")

Parameters are enclosed in parentheses.

Multiple parameters are separated by commas.

S E L F C H E C K

Common Error 1.1

BJ4_ch01_3.fm Page 14 Monday, June 29, 2009 11:15 AM

1.6 Compiling and Running a Java Program 15

a single statement, as if you had written

System.out.println("Hello") System.out.println("World!");

Then it doesn’t understand that statement, because it does not expect the word System fol- lowing the closing parenthesis after "Hello". The remedy is simple. Scan every statement for a terminating semicolon, just as you would check that every English sentence ends in a period.

Alternative Comment Syntax

In Java there are two methods for writing comments. You already learned that the compiler ignores anything that you type between // and the end of the current line. The compiler also ignores any text between a /* and */.

/* A simple Java program */

The // comment is easier to type if the comment is only a single line long. If you have a com- ment that is longer than a line, then the /* . . . */ comment is simpler:

/* This is a simple Java program that you can use to try out your compiler and virtual machine. */

It would be somewhat tedious to add the // at the beginning of each line and to move them around whenever the text of the comment changes.

In this book, we use // for comments that will never grow beyond a line, and /* . . . */ for longer comments. If you prefer, you can always use the // style. The readers of your code will be grateful for any comments, no matter which style you use.

Many students find that the tools that they need as programmers are very different from the software with which they familiar. You should spend some time making yourself familiar with your programming environment. Instructions for several popular environments are available in WileyPLUS.

Some Java development environments are very convenient to use. Enter the code in one window, click on a button to compile, and click on another button to execute your program. Error messages show up in a second window, and the program runs in a third window. With such an environment you are completely shielded from the details of the compilation process. On other systems you must carry out every step manually, by typing commands into a shell window.

No matter which compilation environment you use, you begin your activity by typing in the program statements. The program that you use for entering and mod- ifying the program text is called an editor. The first step for creating a Java program, such as the HelloPrinter program of the preceding section, is to launch your editor. Make a new program file and call it HelloPrinter.java. (If your environment requires that you supply a project name in addition to the file name, use the name hello for

Special Topic 1.1

1.6 Compiling and Running a Java Program Set aside some time to become familiar with the computer system and the Java compiler that you will use for your class work.

An editor is a program for entering and modifying text, such as a Java program.

BJ4_ch01_3.fm Page 15 Monday, June 29, 2009 11:15 AM

16 Chapter 1 Introduction

the project.) Enter the program instructions exactly as they are given above. Alter- natively, locate an electronic copy and paste it into your editor.

Java is case sensitive. You must enter upper- and lowercase letters in the same way as they appear in the program listing. You cannot type MAIN or PrintLn. If you are not careful, you will run into problems—see Common Error 1.2 on page 21. On the other hand, Java has free-form layout. You can use any number of spaces and line breaks to separate words. You can cram as many words as possible into each line,

public class HelloPrinter{public static void main(String[] args){// Display a greeting in the console window System.out.println("Hello, World!");}}

However, good taste dictates that you lay out your programs in a readable fashion. We will give you recommendations for good layout throughout this book. Appen- dix A contains a summary of our recommendations.

Now find out how to run the test program. The message Hello, World!

will appear somewhere on the screen (see Figures 8 and 9). The exact location depends on your programming environment.

Running your program takes two steps. (Some development environments auto- matically carry out both steps when you ask to run a program.)

The first step is to compile your program. The compiler translates the Java source code (that is, the statements that you wrote) into class files, which consist of virtual machine instructions and other information that is required for execution. The class files have the extension .class. For example, the virtual machine instructions for the HelloPrinter program are stored in a file HelloPrinter.class. Note that the compiler does not produce a class file if it has found erors in your program.

The class file contains the translation of only the instructions that you wrote. That is not enough to actually run the program. To display a string in a window, quite a bit of low-level activity is necessary. The authors of the System and

PrintStream classes (which define the out object and the println method) have imple-

Figure 8 Running the HelloPrinter Program in a Console Window

Java is case sensitive. You must be careful about distinguishing between upper- and lowercase letters.

Lay out your programs so that they are easy to read.

The Java compiler translates source code into class files that contain instructions for the Java virtual machine.

BJ4_ch01_3.fm Page 16 Monday, June 29, 2009 11:15 AM

1.6 Compiling and Running a Java Program 17

mented all necessary actions and placed the required class files into a library. A library is a collection of code that has been programmed and translated by someone else, ready for you to use in your program.

The Java virtual machine loads the instructions for the program that you wrote, starts your program, and loads the necessary library files as they are required.

The steps of compiling and running your program are outlined in Figure 10.

Figure 9 Running the HelloPrinter Program in an Integrated Development Environment

The Java virtual machine loads program instructions from class files and library files.

Figure 10 From Source Code to Running Program

CompilerEditor Virtual Machine

Running ProgramSource File

Library files

Class files

BJ4_ch01_3.fm Page 17 Monday, June 29, 2009 11:15 AM

18 Chapter 1 Introduction

13. Can you use a word processor for writing Java programs? 14. What do you expect to see when you load a class file into your text editor?

Understand the File System

In recent years, computers have become easier to use for home or office users. Many inessen- tial details are now hidden from casual users. For example, many users simply place all their work inside a default folder (such as “Home” or “My Documents”) and are blissfully igno- rant about details of the file system.

For your programming work, you need to understand that files are stored in folders or directories, and that these file containers can be nested. That is, a folder can contain not only files but also other folders, which themselves can contain more files and folders (see Figure 11).

You need to know how to impose an organization on the data that you create. You also need to be able to locate files and inspect their contents.

If you are not comfortable with files and folders, be sure to set aside some time to learn about these concepts.

Have a Backup Strategy

Productivity Hint 1.2 discusses strategies for backing up your programming work so that you won’t lose data if your computer malfunctions.

S E L F C H E C K

Productivity Hint 1.1

Figure 11 A Folder Hierarchy

Productivity Hint 1.2

BJ4_ch01_3.fm Page 18 Monday, June 29, 2009 11:15 AM

1.7 Errors 19

Have a Backup Strategy

You will spend many hours typing Java program code and improving it. The resulting pro- gram files have some value, and you should treat them as you would other important prop- erty. A conscientious safety strategy is particularly important for computer files. They are more fragile than paper documents or other more tangible objects. It is easy to delete a file accidentally, and occasionally files are lost because of a computer malfunction. Unless you keep a copy, you must then retype the contents. Because you probably won’t remember the entire file, you will likely find yourself spending almost as much time as you did to enter and improve it in the first place. This costs time, and it may cause you to miss deadlines. It is therefore crucial that you learn how to safeguard files and that you get in the habit of doing so before disaster strikes. You can make safety or backup copies of files by saving copies into another folder, on a thumb drive, or on the Internet.

Here are a few pointers to keep in mind. • Back up often. Backing up a file takes only a few seconds, and you will hate yourself if

you have to spend many hours recreating work that you easily could have saved. • Rotate backups. Use more than one place for backups, and rotate between them. That is,

first back up onto the first backup destination, then to the second and third, and then go back to the first. That way you always have three recent backups. Even if one of them has a defect, you can use one of the others.

• Back up source files only. The compiler translates the files that you write into files consist- ing of machine code. There is no need to back up the machine code files, because you can recreate them easily by running the compiler again. Focus your backup activity on those files that represent your effort. That way your backups won’t fill up with files that you don’t need.

• Pay attention to the backup direction. Backing up involves copying files from one place to another. It is important that you do this right—that is, copy from your work location to the backup location. If you do it the wrong way, you will overwrite a newer file with an older version.

• Check your backups once in a while. Double-check that your backups are where you think they are. There is nothing more frustrating than finding out that the backups are not there when you need them.

• Relax before restoring. When you lose a file and need to restore it from backup, you are likely to be in an unhappy, nervous state. Take a deep breath and think through the recovery process before you start. It is not uncommon for an agitated computer user to wipe out the last backup when trying to restore a damaged file.

Experiment a little with the HelloPrinter program. What happens if you make a typ- ing error such as

System.ouch.println("Hello, World!"); System.out.println("Hello, World!); System.out.println("Hello, Word!");

In the first case, the compiler will complain. It will say that it has no clue what you mean by ouch. The exact wording of the error message is dependent on the compiler,

Productivity Hint 1.3

Develop a strategy for keeping backup copies of your work before disaster strikes.

1.7 Errors

A syntax error is a violation of the rules of the programming language. The compiler detects syntax errors.

BJ4_ch01_3.fm Page 19 Monday, June 29, 2009 11:15 AM

20 Chapter 1 Introduction

but it might be something like “Undefined symbol ouch”. This is a compile-time error or syntax error. Something is wrong according to the language rules and the compiler finds it. When the compiler finds one or more errors, it refuses to translate the program to Java virtual machine instructions, and as a consequence you have no program that you can run. You must fix the error and compile again. In fact, the compiler is quite picky, and it is common to go through several rounds of fixing compile-time errors before compilation succeeds for the first time.

If the compiler finds an error, it will not simply stop and give up. It will try to report as many errors as it can find, so you can fix them all at once. Sometimes, however, one error throws it off track. This is likely to happen with the error in the second line. Because the closing quotation mark is missing, the compiler will think that the ); characters are still part of the string. In such cases, it is common for the compiler to emit bogus error reports for neighboring lines. You should fix only those error messages that make sense to you and then recompile.

The error in the third line is of a different kind. The program will compile and run, but its output will be wrong. It will print

Hello, Word!

This is a run-time error or logic error. The program is syntactically correct and does something, but it doesn’t do what it is supposed to do. The compiler cannot find the error. You, the programmer, must flush out this type of error. Run the pro- gram, and carefully look at its output.

During program development, errors are unavoidable. Once a program is longer than a few lines, it requires superhuman concentration to enter it correctly without slipping up once. You will find yourself omitting semicolons or quotes more often than you would like, but the compiler will track down these problems for you.

Logic errors are more troublesome. The compiler will not find them—in fact, the compiler will cheerfully translate any program as long as its syntax is correct—but the resulting program will do something wrong. It is the responsibility of the pro- gram author to test the program and find any logic errors. Testing programs is an important topic that you will encounter many times in this book. Another impor- tant aspect of good craftsmanship is defensive programming: structuring programs and development processes in such a way that an error in one part of a program does not trigger a disastrous response.

The error examples that you saw so far were not difficult to diagnose or fix, but as you learn more sophisticated programming techniques, there will also be much more room for error. It is an uncomfortable fact that locating all errors in a program is very difficult. Even if you can observe that a program exhibits faulty behavior, it may not at all be obvious what part of the program caused it and how you can fix it. Special software tools (so-called debuggers) let you trace through a program to find bugs—that is, logic errors. In Chapter 6 you will learn how to use a debugger effectively.

Note that these errors are different from the types of errors that you are likely to make in calculations. If you total up a column of numbers, you may miss a minus sign or accidentally drop a carry, perhaps because you are bored or tired. Comput- ers do not make these kinds of errors.

This book uses a three-part error management strategy. First, you will learn about common errors and how to avoid them. Then you will learn defensive pro- gramming strategies to minimize the likelihood and impact of errors. Finally, you will learn debugging strategies to flush out those errors that remain.

A logic error causes a program to take an action that the programmer did not intend. You must test your programs to find logic errors.

BJ4_ch01_3.fm Page 20 Monday, June 29, 2009 11:15 AM

1.8 Algorithms 21

15. Suppose you omit the // characters from the HelloPrinter.java program but not the remainder of the comment. Will you get a compile-time error or a run-time error?

16. How can you find logic errors in a program? 17. Why can’t you test a program for run-time errors when it has compiler errors?

Misspelling Words

If you accidentally misspell a word, then strange things may happen, and it may not always be completely obvious from the error messages what went wrong. Here is a good example of how simple spelling errors can cause trouble:

public class HelloPrinter { public static void Main(String[] args) { System.out.println("Hello, World!"); } }

This class defines a method called Main. The compiler will not consider this to be the same as the main method, because Main starts with an uppercase letter and the Java language is case sensitive. Upper- and lowercase letters are considered to be completely different from each other, and to the compiler Main is no better match for main than rain. The compiler will cheer- fully compile your Main method, but when the Java virtual machine reads the compiled file, it will complain about the missing main method and refuse to run the program. Of course, the message “missing main method” should give you a clue where to look for the error.

If you get an error message that seems to indicate that the compiler is on the wrong track, it is a good idea to check for spelling and capitalization. All Java reserved words use only lowercase letters. Names of classes usually start with an uppercase letter, names of methods and variables with a lowercase letter. If you misspell the name of a symbol (for example, ouch instead of out), the compiler will complain about an “undefined symbol”. That error message is usually a good clue that you made a spelling error.

You will soon learn how to program calculations and decision making in Java. But before we look at the mechanics of implementing computations in the next chapter, let’s consider the planning process that precedes implementation.

You may have run across advertisements that encourage you to pay for a com- puterized service that matches you up with a love partner. Think how this might work. You fill out a form and send it in. Others do the same. The data are processed by a computer program. Is it reasonable to assume that the computer can perform the task of finding the best match for you? Suppose your younger brother, not the computer, had all the forms on his desk. What instructions could you give him? You can’t say, “Find the best-looking person of the opposite sex who likes inline skating and browsing the Internet”. There is no objective standard for good looks, and your brother’s opinion (or that of a computer program analyzing the digitized

S E L F C H E C K

Common Error 1.2

1.8 Algorithms

BJ4_ch01_3.fm Page 21 Monday, June 29, 2009 11:15 AM

22 Chapter 1 Introduction

photo) will likely be different from yours. If you can’t give written instructions for someone to solve the problem, there is no way the computer can magically solve the problem. The computer can only do what you tell it to do. It just does it faster, without getting bored or exhausted.

Now consider the following investment problem:

You put $10,000 into a bank account that earns 5 percent interest per year. How many years does it take for the account balance to be double the original?

Could you solve this problem by hand? Sure, you could. You figure out the balance as follows:

You keep going until the balance is at least $20,000. Then the last number in the year column is the answer.

Of course, carrying out this computation is intensely boring to you or your younger brother. But computers are very good at carrying out repetitive calcula- tions quickly and flawlessly. What is important to the computer is a description of the steps for finding the solution. Each step must be clear and unambiguous, requir- ing no guesswork. Here is such a description:

Start with a year value of 0 and a balance of $10,000.

Repeat the following steps while the balance is less than $20,000.

Add 1 to the year value.

Multiply the balance value by 1.05 (a 5 percent increase).

Report the final year value as the answer.

Of course, these steps are not yet in a language that a computer can understand, but you will soon learn how to formulate them in Java. This informal description is called pseudocode.

year balance 0 10000

1 10000.00 x 1.05 = 10500.00

2 10500.00 x 1.05 = 11025.00

3 11025.00 x 1.05 = 11576.25

4 11576.25 x 1.05 = 12155.06

year balance 0 10000

year balance 0 10000

1 10500

14 19799.32

15 20789.28

Pseudocode is an informal description of a sequence of steps for solving a problem.

BJ4_ch01_3.fm Page 22 Monday, June 29, 2009 11:15 AM

1.8 Algorithms 23

There are no strict requirements for pseudocode because it is read by human readers, not a computer program. Here are the kinds of pseudocode statements that we will use in this book:

• Use statements such as the following to describe how a value is set or changed:

total cost = purchase price + operating cost

or

Multiply the balance value by 1.05.

or

Remove the first and last character from the word.

• Describe decisions and repetitions as follows:

If total cost 1 < total cost 2

While the balance is less than $20,000

For each picture in the sequence

Use indentation to indicate which statements should be selected or repeated.

For each car

operating cost = 10 x annual fuel cost

total cost = purchase price + operating cost

Here, the indentation indicates that both statements should be executed for each car.

• Indicate results with statements such as

Choose car1.

Report the final year value as the answer.

The exact wording is not important. What is important is that the pseudocode describes a sequence of steps that is

• Unambiguous • Executable • Terminating

The step sequence is unambiguous when there are precise instructions for what to do at each step and where to go next. There is no room for guesswork or creativity. A step is is executable when it can be carried out in practice. Had we asked to use the actual interest rate that will be charged in years to come, and not a fixed rate of 5 percent per year, that step would not have been executable, because there is no way for anyone to know what that interest rate will be. A sequence of steps is terminat- ing if it will eventually come to an end. In our example, it requires a bit of thought to see that the sequence will not go on forever: With every step, the balance goes up by at least $500, so eventually it must reach $20,000.

A sequence of steps that is unambiguous, executable, and terminating is called an algorithm. We have found an algorithm to solve our investment problem, and thus we can find the solution by programming a computer. The existence of an algorithm is an essential prerequisite for programming a task. You need to first discover and describe an algorithm for the task that you want to solve before you start program- ming (see Figure 12).

An algorithm for solving a problem is a sequence of steps that is unambiguous, executable, and terminating.

BJ4_ch01_3.fm Page 23 Monday, June 29, 2009 11:15 AM

24 Chapter 1 Introduction

18. Suppose the interest rate was 20 percent. How long would it take for the invest- ment to double?

19. Suppose your cell phone carrier charges you $29.95 for up to 300 minutes of calls, and $0.45 for each additional minute, plus 12.5 percent taxes and fees. Give an algorithm to compute the monthly charge for a given number of minutes.

HOW TO 1.1 Describing an Algorithm with Pseudocode

This is the first of many “How To” sections in this book that give you step-by-step proce- dures for carrying out important tasks in developing computer programs.

Before you are ready to write a program in Java, you need to develop an algorithm–a method for arriving at a solution for a particular problem. Describe the algorithm in pseudocode: a sequence of precise steps formulated in English.

For example, consider this problem: You have the choice of buying two cars. One is more fuel efficient than the other, but also more expensive. You know the price and fuel efficiency (in miles per gallon, mpg) of both cars. You plan to keep the car for ten years. Assume a price of $4 per gallon of gas and usage of 15,000 miles per year. You will pay cash for the car and not worry about financing costs. Which car is the better deal?

Step 1 Determine the inputs and outputs.

In our sample problem, we have these inputs: • purchase price1 and fuel efficiency1, the price and fuel efficiency (in mpg) of the first car. • purchase price2 and fuel efficiency2, the price and fuel efficiency of the second car.

Figure 12 The Software Development Process

Understand the problem

Develop and describe an algorithm

Translate the algorithm

into Java

Test the algorithm with simple inputs

Compile and test your program

S E L F C H E C K

BJ4_ch01_3.fm Page 24 Monday, June 29, 2009 11:15 AM

1.8 Algorithms 25

We simply want to know which car is the better buy. That is the desired output.

Step 2 Break down the problem into smaller tasks.

For each car, we need to know the total cost of driving it. Let’s do this computation sepa- rately for each car. Once we have the total cost for each car, we can decide which car is the better deal.

The total cost for each car is purchase price + operating cost.

We assume a constant usage and gas price for ten years, so the operating cost depends on the cost of driving the car for one year.

The operating cost is 10 x annual fuel cost. The annual fuel cost is price per gallon x annual fuel consumed.

The annual fuel consumed is annual miles driven / fuel efficiency. For example, if you drive the car for 15,000 miles and the fuel efficiency is 15 miles/gallon, the car consumes 1,000 gallons.

Step 3 Describe each subtask in pseudocode.

In your description, arrange the steps so that any intermediate values are computed before they are needed in other computations. For example, list the step

total cost = purchase price + operating cost

after you have computed operating cost. Here is the algorithm for deciding which car to buy.

For each car, compute the total cost as follows:

annual fuel consumed = annual miles driven / fuel efficiency

annual fuel cost = price per gallon x annual fuel consumed

operating cost = 10 x annual fuel cost

total cost = purchase price + operating cost

If total cost1 < total cost2

Choose car1.

Else

Choose car2.

Step 4 Test your pseudocode by working a problem.

We will use these sample values:

Car 1: $25,000, 50 miles/gallon Car 2: $20,000, 30 miles/gallon

Here is the calculation for the cost of the first car.

annual fuel consumed = annual miles driven / fuel efficiency = 15000 / 50 = 300

annual fuel cost = price per gallon x annual fuel consumed = 4 x 300 = 1200

operating cost = 10 x annual fuel cost = 10 x 1200 = 12000

total cost = purchase price + operating cost = 25000 + 12000 = 37000

Similarly, the total cost for the second car is $40,000. Therefore, the output of the algorithm is to choose car 1.

Writing an Algorithm for Tiling a Floor

This Worked Example shows how to develop an algorithm for laying tile in an alternating pattern of colors.

Worked Example 1.1

BJ4_ch01_3.fm Page 25 Monday, June 29, 2009 11:15 AM

26 Chapter 1 Introduction

Define “computer program” and “programming”.

• A computer must be programmed to perform tasks. Different tasks require differ- ent programs.

• A computer program executes a sequence of very basic operations in rapid succession.

• A computer program contains the instruction sequences for all tasks that it can exe- cute.

Describe the components of a computer.

• At the heart of the computer lies the central processing unit (CPU). • Data and programs are stored in primary storage (memory) and secondary storage

(such as a hard disk). • The CPU reads machine instructions from memory. The instructions direct it to

communicate with memory, secondary storage, and peripheral devices.

Describe the process of translating high-level languages to machine code.

• Generally, machine code depends on the CPU type. However, the instruction set of the Java virtual machine (JVM) can be executed on many CPUs.

• Because machine instructions are encoded as numbers, it is difficult to write pro- grams in machine code.

• High-level languages allow you to describe tasks at a higher conceptual level than machine code.

• A compiler translates programs written in a high-level language into machine code.

Describe the history and design principles of the Java programming language.

• Java was originally designed for programming consumer devices, but it was first successfully used to write Internet applets.

• Java was designed to be safe and portable, benefiting both Internet users and stu- dents.

• Java has a very large library. Focus on learning those parts of the library that you need for your programming projects.

Describe the building blocks of a simple program and the structure of a method call.

• Classes are the fundamental building blocks of Java programs. • Every Java application contains a class with a main method. When the application

starts, the instructions in the main method are executed. • Each class contains definitions of methods. Each method contains a sequence of

instructions. • Use comments to help human readers understand your program. • A method is called by specifying an object, the method name, and the method

parameters. • A string is a sequence of characters enclosed in quotation marks.

Summary of Learning Objectives

BJ4_ch01_3.fm Page 26 Monday, June 29, 2009 11:15 AM

Classes, Objects, and Methods Introduced in this Chapter 27

Use your programming environment to write and run Java programs.

• Set aside some time to become familiar with the computer system and the Java com- piler that you will use for your class work.

• An editor is a program for entering and modifying text, such as a Java program. • Java is case sensitive. You must be careful about distinguishing between upper- and

lowercase letters. • Lay out your programs so that they are easy to read. • The Java compiler translates source code into class files that contain instructions for

the Java virtual machine. • The Java virtual machine loads program instructions from class files and library

files. • Develop a strategy for keeping backup copies of your work before disaster strikes.

Classify program errors as syntax and logic errors.

• A syntax error is a violation of the rules of the programming language. The com- piler detects syntax errors.

• A logic error causes a program to take an action that the programmer did not intend. You must test your programs to find logic errors.

Write pseudocode for simple algorithms.

• Pseudocode is an informal description of a sequence of steps for solving a problem. • An algorithm for solving a problem is a sequence of steps that is unambiguous, exe-

cutable, and terminating.

Here is a list of all classes, objects, and methods introduced in this chapter. Turn to the documentation in Appendix C for more information.

R1.1 Explain the difference between using a computer program and programming a computer. Hint: 1.1

Review 1.1 Contrast program users and programmers Diff: E

Type: Essay

R1.2 What distinguishes a computer from a typical household appliance? Hint: 1.1

Review 1.2 Contrast computers and appliances Diff: E

Classes, Objects, and Methods Introduced in this Chapter

java.io.PrintStream print println

java.lang.System out

Review Exercises

BJ4_ch01_3.fm Page 27 Monday, June 29, 2009 11:15 AM

28 Chapter 1 Introduction

Type: Essay

R1.3 Describe exactly what steps you would take to back up your work after you have typed in the HelloPrinter.java program. Hint: Productivity Hint 1.2

Review 1.3 How do you back up a file? Diff: M

Type: Essay

R1.4 On your own computer or on a lab computer, find the exact location (folder or directory name) of

a. The sample file HelloPrinter.java, which you wrote with the editor. b. The Java program launcher java.exe or java. c. The library file rt.jar that contains the run-time library.

Hint: 1.6 Review 1.4 Find files on your computer

Diff: M Type: Essay

R1.5 How do you discover syntax errors? How do you discover logic errors? Hint: 1.7

Review 1.5 How do you discover syntax/logic errors? Diff: E

Type: Essay

R1.6 Write three versions of the HelloPrinter.java program that have different syntax errors. Write a version that has a logic error. Hint: 1.7

Review 1.6 Write HelloPrinter with errors Diff: M

Type: Essay

R1.7 What do the following statements print? Don’t guess; write programs to find out. a. System.out.println("3 + 4"); b. System.out.println(3 + 4); c. System.out.println(3 + "4");

Hint: 1.6 Review 1.7 What do these statements print?

Diff: H Type: Essay

R1.8 Write an algorithm to settle the following question: A bank account starts out with $10,000. Interest is compounded monthly at 6 percent per year (0.5 percent per month). Every month, $500 is withdrawn to meet college expenses. After how many years is the account depleted? Hint: 1.8

Review 1.8 Write an algorithm to say when bank account is depleted. Diff: M Type: Essay

BJ4_ch01_3.fm Page 28 Monday, June 29, 2009 11:15 AM

Review Exercises 29

R1.9 Consider the question in Exercise R1.8. Suppose the numbers ($10,000, 6 percent, $500) were user selectable. Are there values for which the algorithm you developed would not terminate? If so, change the algorithm to make sure it always terminates. Hint: 1.8

Review 1.9 Assess whether algorithm terminates and fix it if it doesn’t. Diff: H Type: Essay

R1.10 In order to estimate the cost of painting a house, a painter needs to know the surface area of the exterior. Develop an algorithm for computing that value. Your inputs are the width, length, and height of the house, the number of windows and doors, and their dimensions. (Assume the windows and doors have a uniform size.) Hint: 1.8

Review 1.10 Write an algorithm to calculate the surface area of a house. Diff: H Type: Essay

R1.11 You want to decide whether you should drive your car to work or take the train. You know the one-way distance from your home to your place of work, and the fuel efficiency of your car (in miles per gallon). You also know the one-way price of a train ticket. You assume the cost of gas at $4 per gallon, and car maintenance at 5 cents per mile. Write an algorithm to decide which commute is cheaper. Hint: 1.8

Review 1.11 Write an algorithm to decide which commute is cheaper. Diff: M Type: Essay

R1.12 You want to find out which fraction of your car use is for commuting to work, and which is for personal use. You know the one-way distance from your home to your place of work. For a particular period, you recorded the beginning and ending mile- age on the odometer and the number of work days. Write an algorithm to settle this question. Hint: 1.8

Review 1.12 Write an algorithm to calculate work/personal use of car. Diff: M Type: Essay

R1.13 In the problem described in How To 1.1 on page 24, you made assumptions about the price of gas and the annual usage. Ideally, you would like to know which car is the better deal without making these assumptions. Why can’t a computer program solve that problem? Hint: 1.8

Review 1.13 Why can’t a computer solve this problem? Diff: E Type: Essay

Additional review exercises are available in WileyPLUS.

BJ4_ch01_3.fm Page 29 Monday, June 29, 2009 11:15 AM

30 Chapter 1 Introduction

P1.1 Write a program NamePrinter that displays your name inside a box on the console screen, like this:

+----+ |Dave| +----+

Do your best to approximate lines with characters, such as |, -, and +. Hint: 1.6

Programming 1.1 Name in box Diff: E

Type: Program

P1.2 Write a program that prints your name in large letters, such as * * ** **** **** * * * * * * * * * * * * ***** * * **** **** * * * * ****** * * * * * * * * * * * * * *

Hint: 1.5 Programming 1.2 Write name in large letters

Diff: H Type: Essay

P1.3 Write a program FacePrinter that prints a face, using text characters, hopefully better looking than this one:

///// | o o | (| ^ |) | [_] | -----

Use comments to indicate the statements that print the hair, ears, mouth, and so on. Hint: 1.6

Programming 1.3 FacePrinter Diff: E

Type: Program

P1.4 Write a program that prints an animal speaking a greeting, similar to (but different from) the following

/\_/\ ----- ( ‘ ’ ) / Hello \ ( - ) < Junior | | | | \ Coder!/ (__|__) -----

Hint: 1.5 Programming 1.4 Print animal speaking a greeting

Diff: H Type: Essay

P1.5 Write a program TicTacToeBoardPrinter that prints a tic-tac-toe board: +---+---+---+ | | | |

Programming Exercises

BJ4_ch01_3.fm Page 30 Monday, June 29, 2009 11:15 AM

Review Exercises 31

+---+---+---+ | | | | +---+---+---+ | | | | +---+---+---+

Hint: 1.6 Programming 1.5 TicTacToe board

Diff: E Type: Program

P1.6 Write a program StaircasePrinter that prints a staircase: +---+ | | +---+---+ | | | +---+---+---+ | | | | +---+---+---+---+ | | | | | +---+---+---+---+

Hint: 1.6 Programming 1.6 Staircase

Diff: E Type: Program

P1.7 Write a program that prints three items, such as the names of your three best friends or favorite movies, on three separate lines. Hint: 1.5

Programming 1.7 Diff: E Type: Program

P1.8 Write a program that computes the sum of the first ten positive integers, 1 + 2 + · · · + 10. Hint: Write a program of the form

public class Sum10 { public static void main(String[] args) { System.out.println( ); } }

Hint: 1.6 Programming 1.8 Sum 1 + 2 + · · · + 10

Diff: M Type: Program

P1.9 Type in and run the following program: import javax.swing.JOptionPane;

public class DialogViewer { public static void main(String[] args) { JOptionPane.showMessageDialog(null, "Hello, World!"); System.exit(0);

BJ4_ch01_3.fm Page 31 Monday, June 29, 2009 11:15 AM

32 Chapter 1 Introduction

} }

Then modify the program to show the message “Hello, your name!”. Hint: 1.6

Programming 1.9 DialogViewer Diff: M

Type: Program

P1.10 Type in and run the following program: import javax.swing.JOptionPane;

public class DialogViewer { public static void main(String[] args) { String name = JOptionPane.showInputDialog("What is your name?"); System.out.println(name); System.exit(0); } }

Then modify the program to print “Hello, name!”, displaying the name that the user typed in. Hint: 1.6

Programming 1.10 DialogViewer with input Diff: M

Type: Program

P1.11 Run the following program: import java.net.URL; import javax.swing.ImageIcon; import javax.swing.JOptionPane;

public class Test { public static void main(String[] args) throws Exception { URL imageLocation = new URL( "https://duke.dev.java.net/images/iconSized/duke.gif"); JOptionPane.showMessageDialog(null, "Hello", "Title", JOptionPane.PLAIN_MESSAGE, new ImageIcon(imageLocation)); System.exit(0); } }

Then modify it to show a different greeting and image. Hint: 1.5

Programming 1.11 Modify program to show different greeting and image Diff: M Type: Program

Additional programming exercises are available in WileyPLUS.

BJ4_ch01_3.fm Page 32 Monday, June 29, 2009 11:15 AM

33

Chapter

2

Using Objects

C H A P T E R G O A L S

•

To learn about variables

•

To understand the concepts of classes and objects

•

To be able to call methods

•

To learn about parameters and return values

•

To be able to browse the API documentation

T

To implement test programs

•

To understand the difference between objects and object references

G

To write programs that display simple shapes

Most useful programs don’t just manipulate numbers and strings.

Instead, they deal with data items that are more complex and that more closely represent entities in

the real world. Examples of these data items include bank accounts, employee records, and graphical

shapes.

The Java language is ideally suited for designing and manipulating such data items, or

objects

. In

Java, you implement

classes

that describe the behavior of these objects. In this chapter, you will learn

how to manipulate objects that belong to classes that have already been implemented. This

knowledge will prepare you for the next chapter in which you will learn how to implement your

own classes.

bj4_ch02_8.fm Page 33 Thursday, November 5, 2009 10:47 AM

34

CHAPTER CONTENTS

2.1 Types

34

2.2 Variables

36

S

YNTAX

2.1: Variable Declaration

37

Q

UALITY

T

IP

2.1: Choose Descriptive Names

for Variables

38

2.3 The Assignment Operator

39

S

YNTAX

2.2: Assignment

39

C

OMMON

E

RROR

2.1: Confusing Variable Declarations

and Assignment Statements

40

2.4 Objects, Classes, and Methods

41

2.5 Method Parameters and Return Values

43

2.6 Constructing Objects

46

S

YNTAX

2.3: Object Construction

47

C

OMMON

E

RROR

2.2: Trying to Invoke a Constructor

Like a Method

47

2.7 Accessor and Mutator Methods

48

2.8 The API Documentation

49

S

YNTAX

2.4: Importing a Class from a Package

51

P

RODUCTIVITY

H

INT

2.1: Don’t Memorize—Use

Online Help

51

2.9T Implementing a Test Program

52

S

PECIAL

T

OPIC

2.1: Testing Classes in an Interactive

Environment

53

W

ORKED

E

XAMPLE

2.1: How Many Days Have You

Been Alive?

W

ORKED

E

XAMPLE

2.2: Working with Pictures

2.10 Object References

54

R

ANDOM

F

ACT

2.1: Mainframes—When Dinosaurs

Ruled the Earth

57

2.11G Graphical Applications and Frame Windows

58

2.12G Drawing on a Component

60

S

PECIAL

T

OPIC

2.2: Applets

63

2.13G Ellipses, Lines, Text, and Color

65

R

ANDOM

F

ACT

2.2: The Evolution of the Internet

69

Before we start with the main topic of this chapter, we need to go over some basic programming terminology. In the first three sections of this chapter, you will learn about the concepts of types, variables, and assignment.

A computer program processes values: numbers, strings, and more complex data items. In Java, every value has a

type

. For example, the number 13 has the type

int

(an abbreviation for “integer”),

"Hello, World"

has the type

String

, and the object

System.out

has the type

PrintStream

. The type tells you what operations you can carry out with the values. For example, you can compute the sum or product of any two integers. You can call

println

on any object of type

PrintStream

. Java has separate types for

integers

and

floating-point numbers

. Integers are whole numbers; floating-point numbers can have fractional parts. For example, 13 is an integer and 1.3 is a floating-point number.

The name “floating-point” describes the representation of the number in the com- puter as a sequence of the significant digits and an indication of the position of the decimal point. For example, the numbers 13000.0, 1.3, 0.00013 all have the same dec- imal digits: 13. When a floating-point number is multiplied or divided by 10, only the position of the decimal point changes; it “floats”. This representation is related to the “scientific” notation 1.3

×

10

–4

. (Actually, the computer represents numbers in base 2, not base 10, but the principle is the same.)

If you need to process numbers with a fractional part, you should use the type called

double

, which stands for “double precision floating-point number”. Think of a number in

double

format as any number that can appear in the display panel of a calculator, such as 1.3 or –0.333333333.

2.1 Types

A type specifies a set of values and the operations that can be carried out with the values.

The double type denotes floating- point numbers that can have fractional parts.

bj4_ch02_8.fm Page 34 Thursday, November 5, 2009 10:47 AM

2.1 Types

35

When a value such as

13

or

1.3

occurs in a Java program, it is called a

number lit- eral

. Do not use commas when you write number literals in Java. For example, 13,000 must be written as

13000

. To write numbers in exponential notation in Java, use the notation

E

n

instead of “

×

10

n

”. For example, 1.3

×

10

–4

is written as

1.3E-4

. Table 1 shows how to write integer and floating-point literals in Java.

You may wonder why Java has separate integer and floating-point number types. Pocket calculators don’t need a separate integer type; they use floating-point num- bers for all calculations. However, integers have several advantages over floating- point numbers. They take less storage space, are processed faster, and don’t cause rounding errors. You will want to use the

int

type for quantities that can never have fractional parts, such as the length of a string. Use the

double

type for quantities that can have fractional parts, such as a grade point average.

There are several other number types in Java that are not as commonly used. We will discuss these types in Chapter 4. For most programs in this book, however, the

int

and

double

types are all you need for processing numbers. In Java, the number types (

int

,

double

, and the less commonly used types) are

primitive types

. Numbers are not objects. The number types have no methods. However, you can combine numbers with operators such as

+

and

-

, as in

10 + n

or

n - 1

. To multiply two numbers, use the

*

operator. For example, 10

× n is writ- ten as 10 * n.

A combination of variables, literals, operators, and/or methods (which you will see in Section 2.4) is called an expression. A typical example of an expression is

x + y * 2

As in mathematics, the * operator binds more strongly than the + operator. That is, x + y * 2 means the sum of x and y * 2. If you want to multiply the sum of x and y by 2, use parentheses:

(x + y) * 2

Table 1 Number Literals in Java

Number Type Comment

6 int An integer has no fractional part.

–6 int Integers can be negative.

0 int Zero is an integer.

0.5 double A number with a fractional part has type double.

1.0 double An integer with a fractional part .0 has type double.

1E6 double A number in exponential notation: 1 × 106 or 1000000. Numbers in exponential notation always have type double.

2.96E-2 double Negative exponent: 2.96 × 10–2 = 2.96 / 100 = 0.0296

100,000 Error: Do not use a comma as a decimal separator.

3 1/2 Error: Do not use fractions; use decimal notation: 3.5.

In Java, the number types are primitive types, and numbers are not objects.

Numbers can be combined by arithmetic operators such as +, -, and *.

bj4_ch02_8.fm Page 35 Thursday, November 5, 2009 10:47 AM

36 Chapter 2 Using Objects

1. What are the types of the values 0 and "0"? 2. Which number type would you use for storing the area of a circle? 3. Why is the expression 13.println() an error? 4. Write an expression to compute the average of the values x and y.

You often want to store values so that you can use them at a later time. To remem- ber a value, you need to hold it in a variable. A variable is a storage location in the computer’s memory that has a type, name, and contents. For example, here we declare three variables:

String greeting = "Hello, World!"; PrintStream printer = System.out; int width = 20;

The first variable is called greeting. It can be used to store String values, and it is set to the value "Hello, World!". The second variable, printer, stores a PrintStream value, and the third stores an integer.

Variables can be used in place of the values that they store: printer.println(greeting); // Same as System.out.println("Hello, World!") printer.println(width); // Same as System.out.println(20)

When you declare your own variables, you need to make two decisions.

• What type should you use for the variable? • What name should you give the variable?

The type depends on the intended use. If you need to store a string, use the String type for your variable. If you need a number, choose the int or double type.

It is an error to store a value whose type does not match the type of the variable. For example, the following is an error:

String greeting = 20; // ERROR: Types don’t match

S E L F C H E C K

2.2 Variables

You use variables to store values that you want to use at a later time. A variable has a type, a name, and a value.

Table 2 Variable Declarations in Java

Variable Name Comment

int width = 10; Declares an integer variable and initializes it with 10.

int area = width * height; The initial value can depend on other variables. (Of course, width and height must have been previously declared.)

height = 5; Error: The type is missing. This statement is not a declaration but an assignment of a new value to an existing variable—see Section 2.3.

int height = "5"; Error: You cannot initialize a number with a string.

int width, height; Declares two integer variables in a single statement. In this book, we will declare each variable in a separate statement.

bj4_ch02_8.fm Page 36 Thursday, November 5, 2009 10:47 AM

2.2 Variables 37

You cannot use a String variable to store an integer. The compiler checks type mis- matches to protect you from errors.

When deciding on a name for a variable, you should make a choice that describes the purpose of the variable. For example, the variable name greeting is a better choice than the name g.

An identifier is the name of a variable, method, or class. Java imposes the follow- ing rules for identifiers:

• Identifiers can be made up of letters, digits, and the underscore (_) and dollar sign ($) characters. They cannot start with a digit, though.

• You cannot use spaces or symbols such as ? or %. • Furthermore, you cannot use reserved words, such as public, as names; these

words are reserved exclusively for their special Java meanings. (See Appendix C for all reserved words in Java.)

These are firm rules of the Java language. If you violate one of them, the compiler will report an error. Moreover, there are a couple of conventions that you should follow so that other programmers will find your programs easy to read:

• Variable and method names should start with a lowercase letter. It is OK to use an occasional uppercase letter, such as farewellMessage. This mixture of lowercase and uppercase letters is sometimes called “camel case” because the uppercase let- ters stick out like the humps of a camel.

• Class names should start with an uppercase letter. For example, Greeting would be an appropriate name for a class, but not for a variable.

• You should not use the $ symbol in names. It is intended for names that are auto- matically generated by tools.

If you violate these conventions, the compiler won’t complain, but you will confuse other programmers who read your code.

Identifiers for variables, methods, and classes are composed of letters, digits, and the underscore character.

By convention, variable names should start with a lowercase letter.

Syntax 2.1 Variable Declaration

typeName variableName = value; or typeName variableName;

Syntax

Example

String greeting = "Hello, Dave!"; A variable declaration ends

with a semicolon.

The type specifies

what can be done

with values stored

in this variable.

Supplying an initial value is optional,

but it is usually a good idea.

See pages 37-38 for rules and

examples of valid names.

Use a descriptive

variable name.

See page 38.

bj4_ch02_8.fm Page 37 Thursday, November 5, 2009 10:47 AM

38 Chapter 2 Using Objects

Table 3 shows examples of legal and illegal variable names in Java.

5. Which of the following are legal identifiers? Greeting1 g void 101dalmatians Hello, World <greeting>

6. Declare a variable to hold your name. Use camel case in the variable name.

Choose Descriptive Names for Variables

In algebra, variable names are usually just one letter long, such as p or A, maybe with a sub- script such as p1. You might be tempted to save yourself a lot of typing by using short vari- able names in your Java programs:

int A = w * h;

Compare this with the following statement:

int area = width * height;

The advantage is obvious. Reading width is much easier than reading w and then figuring out that it must mean “width”.

In practical programming, descriptive variable names are particularly important when programs are written by more than one person. It may be obvious to you that w stands for width, but is it obvious to the person who needs to update your code years later? For that matter, will you yourself remember what w means when you look at the code a month from now?

Table 3 Variable Names in Java

Variable Name Comment

farewellMessage Use “camel case” for variable names consisting of multiple words.

x In mathematics, you use short variable names such as x or y. This is legal in Java, but not very common, because it can make programs harder to understand.

Greeting Caution: Variable names are case-sensitive. This variable name is different from greeting.

6pack Error: Variable names cannot start with a number.

farewell message Error: Variable names cannot contain spaces.

public Error: You cannot use a reserved word as a variable name.

!

S E L F C H E C K

Quality Tip 2.1

bj4_ch02_8.fm Page 38 Thursday, November 5, 2009 10:47 AM

2.3 The Assignment Operator 39

You can change the value of a variable with the assignment operator (=). For exam- ple, consider the variable declaration

int width = 10;

If you want to change the value of the variable, simply assign the new value: width = 20;

The assignment replaces the original value of the variable (see Figure 1).

It is an error to use a variable that has never had a value assigned to it. For example, the following assignment statement has an error:

int height; width = height; // ERROR—uninitialized variable height

The compiler will complain about an “uninitialized variable” when you use a vari- able that has never been assigned a value. (See Figure 2.)

2.3 The Assignment Operator Use the assignment operator (=) to change the value of a variable. 1

2

Figure 1 Assigning a New Value to a Variable

width = 10

width = 20

1

2

Figure 2 An Uninitialized Variable

Syntax 2.2 Assignment

height = No value has been assigned.

variableName = value;Syntax

Example double width = 20; . . width = 30; . . . width = width + 10;

The value of this variable is changed.

The same name

can occur on both sides.

See Figure 3.

The new value of the variable

This is a variable declaration. This is an assignment statement.

bj4_ch02_8.fm Page 39 Thursday, November 5, 2009 10:47 AM

40 Chapter 2 Using Objects

The remedy is to assign a value to the variable before you use it: int height = 30; width = height; // OK

Or, even better, initialize the variable when you declare it. int height = 30; int width = height; // OK

The right-hand side of the = symbol can be a mathematical expression. For example, width = height + 10;

This means “compute the value of height + 10 and store that value in the variable width”.

In the Java programming language, the = operator denotes an action, to replace the value of a variable. This usage differs from the mathematical usage of the = symbol, as a statement about equality. For example, in Java, the following statement is entirely legal:

width = width + 10;

This means “compute the value of width + 10 and store that value in the variable width ” (see Figure 3).

In Java, it is not a problem that the variable width is used on both sides of the = symbol. Of course, in mathematics, the equation width = width + 10 has no solution.

7. Is 12 = 12 a valid expression in the Java language? 8. How do you change the value of the greeting variable to "Hello, Nina!"?

Confusing Variable Declarations and Assignment Statements

Suppose your program declares a variable as follows:

int width = 20;

If you want to change the value of the variable, you use an assignment statement:

width = 30;

It is a common error to accidentally use another variable declaration:

int width = 30; // ERROR—starts with int and is therefore a declaration

Figure 3 Executing the Statement width = width + 10

1

width =

width + 10

40

30

2

width =

40

40

Compute the value of the right-hand side Store the value in the variable

All variables must be initialized before you access them.

A N I M A T I O N Variable

Initialization and Assignment

1 2

S E L F C H E C K

Common Error 2.1

bj4_ch02_8.fm Page 40 Thursday, November 5, 2009 10:47 AM

2.4 Objects, Classes, and Methods 41

But there is already a variable named width. The compiler will complain that you are trying to declare another variable with the same name.

We now come to the main purpose of this chapter: a closer understanding of objects. An object is a value that you can manipulate by calling one or more of its methods. A method consists of a sequence of instructions that can access the inter- nal data of an object. When you call the method, you do not know exactly what those instructions are, or even how the object is organized internally. However, the behavior of the method is well-defined, and that is what matters to us when we use it.

For example, you saw in Chapter 1 that System.out refers to an object. You manipulate it by calling the println method. When the println method is called, some activities occur inside the object, and the ultimate effect is that text appears in the console window. You don’t know how that happens, and that’s OK. What mat- ters is that the method carries out the work that you requested.

Figure 4 shows a representation of the System.out object. The internal data is sym- bolized by a sequence of zeroes and ones. Think of each method (symbolized by the gears) as a piece of machinery that carries out its assigned task.

In Chapter 1, you encountered two objects: • System.out • "Hello, World!" The type of an object is a class. The System.out object belongs to the class Print- Stream. The "Hello, World!" object belongs to the class String. A class specifies the methods that you can apply to its objects.

You can use the println method with any object that belongs to the PrintStream class. System.out is one such object. It is possible to obtain other objects of the Print- Stream class. For example, you can construct a PrintStream object to send output to a file. However, we won’t discuss files until Chapter 11.

Just as the PrintStream class provides methods such as println and print for its objects, the String class provides methods that you can apply to String objects. One of them is the length method. The length method counts the number of characters in

2.4 Objects, Classes, and Methods

Figure 4 Representation of the System.out Object

Objects are entities in your program that you manipulate by calling methods.

A method is a sequence of instructions that accesses the data of an object.

A class declares the methods that you can apply to its objects.

data =

PrintStream

println

print

10101110

11110110

01101011

00110101

bj4_ch02_8.fm Page 41 Thursday, November 5, 2009 10:47 AM

42 Chapter 2 Using Objects

a string. You can apply that method to any object of type String. For example, the sequence of statements

String greeting = "Hello, World!"; int n = greeting.length();

sets n to the number of characters in the String object "Hello, World!". After the instructions in the length method are executed, n is set to 13. (The quotation marks are not part of the string, and the length method does not count them.)

The length method—unlike the println method—requires no input inside the paren- theses. However, the length method yields an output, namely the character count.

In the next section, you will see in greater detail how to supply method inputs and obtain method outputs.

Let us look at another method of the String class. When you apply the toUpperCase method to a String object, the method creates another String object that contains the characters of the original string, with lowercase letters converted to uppercase. For example, the sequence of statements

String river = "Mississippi"; String bigRiver = river.toUpperCase();

sets bigRiver to the String object "MISSISSIPPI". When you apply a method to an object, you must make sure that the method is

declared in the appropriate class. For example, it is an error to call System.out.length(); // This method call is an error

The PrintStream class (to which System.out belongs) has no length method. Let us summarize. In Java, every object belongs to a class. The class declares the

methods for the objects. For example, the String class declares the length and toUpper- Case methods (as well as other methods—you will learn about most of them in Chapter 4). The methods form the public interface of the class, telling you what you can do with the objects of the class. A class also declares a private implementation, describing the data inside its objects and the instructions for its methods. Those details are hidden from the programmers who use objects and call methods.

Figure 5 shows two objects of the String class. Each object stores its own data (drawn as boxes that contain characters). Both objects support the same set of methods—the interface that is specified by the String class.

Figure 5 A Representation of Two String Objects

length

toUpperCase

H e l l o ...

Stringg

data =

length

toUpperCase

Stringg

M i s s i ...data =

The public interface of a class specifies what you can do with its objects. The hidden imple- mentation describes how these actions are carried out.

bj4_ch02_8.fm Page 42 Thursday, November 5, 2009 10:47 AM

2.5 Method Parameters and Return Values 43

Occasionally, a class declares two methods with the same name and different parameter types. For example, the PrintStream class declares a second method, also called println, as

public void println(int output)

That method is used to print an integer value. We say that the println name is over- loaded because it refers to more than one method.

9. How can you compute the length of the string "Mississippi"? 10. How can you print out the uppercase version of "Hello, World!"? 11. Is it legal to call river.println()? Why or why not?

Methods are fundamental building blocks of Java programs. A program performs useful work by calling methods. In this section, we will examine how to provide inputs into a method, and how to obtain the result of the method.

Most methods require inputs that give details about the work that the method needs to do. For example, the println method has an input: the string that should be printed. Computer scientists use the technical term parameter for method inputs. We say that the string greeting is a parameter of the method call

System.out.println(greeting);

Figure 6 illustrates passing of the parameter to the method. Technically speaking, the greeting parameter is an explicit parameter of the

println method. The object on which you invoke the method is also considered a parameter of the method call; it is called the implicit parameter. For example, Sys- tem.out is the implicit parameter of the method call

System.out.println(greeting);

Some methods require multiple explicit parameters, others don’t require any explicit parameters at all. An example of the latter is the length method of the String class (see Figure 7). All the information that the length method requires to do its job—namely, the character sequence of the string—is stored in the implicit parame- ter object.

S E L F C H E C K

2.5 Method Parameters and Return Values

Figure 6 Passing a Parameter to the println Method

A parameter is an input to a method.

The implicit parameter of a method call is the object on which the method is invoked. All other parameters are explicit parameters.

PrintStream

println

print

10101110

11110110

01101011

00110101

"Hello, World"

bj4_ch02_8.fm Page 43 Thursday, November 5, 2009 10:47 AM

44 Chapter 2 Using Objects

The length method differs from the println method in another way: it has an out- put. We say that the method returns a value, namely the number of characters in the string. You can store the return value in a variable:

int n = greeting.length();

You can also use the return value as a parameter of another method: System.out.println(greeting.length());

The method call greeting.length() returns a value—the integer 13. The return value becomes a parameter of the println method. Figure 8 shows the process.

Not all methods return values. One example is the println method. The println method interacts with the operating system, causing characters to appear in a win- dow. But it does not return a value to the code that calls it.

Let us analyze a more complex method call. Here, we will call the replace method of the String class. The replace method carries out a search-and-replace operation, similar to that of a word processor. For example, the call

river.replace("issipp", "our")

constructs a new string that is obtained by replacing all occurrences of "issipp" in "Mississippi" with "our". (In this situation, there was only one replacement.) The method returns the String object "Missouri". You can save that string in a variable:

river = river.replace("issipp", "our");

Or you can pass it to another method: System.out.println(river.replace("issipp", "our"));

Figure 7 Invoking the length Method on a String Object

13length

toUpperCase

Stringg

(no parameter)

H e l l o ...

The return value of a method is a result that the method has computed for use by the code that called it.

A N I M A T I O N Parameter Passing

Figure 8 Passing the Result of a Method Call to Another Method

13length

toUpperCase

Stringg

no parameter)

H e l l o ...

PrintStream

println

print

10101110

11110110

01101011

00110101

bj4_ch02_8.fm Page 44 Thursday, November 5, 2009 10:47 AM

2.5 Method Parameters and Return Values 45

As Figure 9 shows, this method call has

• one implicit parameter: the string "Mississippi" • two explicit parameters: the strings "issipp" and "our" • a return value: the string "Missouri"

When a method is declared in a class, the declaration specifies the types of the explicit parameters and the return value. For example, the String class declares the length method as

public int length()

That is, there are no explicit parameters, and the return value has the type int. (For now, all the methods that we consider will be “public” methods—see Chapter 10 for more restricted methods.)

The type of the implicit parameter is the class that declares the method—String in our case. It is not mentioned in the method declaration—hence the term “implicit”.

The replace method is declared as public String replace(String target, String replacement)

To call the replace method, you supply two explicit parameters, target and replace- ment, which both have type String. The returned value is another string.

When a method returns no value, the return type is declared with the reserved word void. For example, the PrintStream class declares the println method as

public void println(String output)

12. What are the implicit parameters, explicit parameters, and return values in the method call river.length()?

13. What is the result of the call river.replace("p", "s")?

14. What is the result of the call greeting.replace("World", "Dave").length()?

15. How is the toUpperCase method declared in the String class?

Figure 9 Calling the replace Method

length

toUpperCase

replace

Stringg

M i s s i ...

"issipp"

"our"

"Missouri"

S E L F C H E C K

bj4_ch02_8.fm Page 45 Thursday, November 5, 2009 10:47 AM

46 Chapter 2 Using Objects

Most Java programs need to work on a variety of objects. In this section, you will see how to construct new objects. This allows you to go beyond String objects and the System.out object.

To learn about object construction, let us turn to another class: the Rectangle class in the Java class library. Objects of type Rectangle describe rectangular shapes—see Figure 10. These objects are useful for a variety of purposes. You can assemble rect- angles into bar charts, and you can program simple games by moving rectangles inside a window.

Note that a Rectangle object isn’t a rectangular shape—it’s an object that contains a set of numbers. The numbers describe the rectangle (see Figure 11). Each rectangle is described by the x- and y-coordinates of its top-left corner, its width, and its height.

It is very important that you understand this distinction. In the computer, a Rectangle object is a block of memory that holds four numbers, for example x = 5, y = 10, width = 20, height = 30. In the imagination of the programmer who uses a Rectangle object, the object describes a geometric figure.

To make a new rectangle, you need to specify the x, y, width, and height values. Then invoke the new operator, specifying the name of the class and the parameters that are required for constructing a new object. For example, you can make a new rectangle with its top-left corner at (5, 10), width 20, and height 30 as follows:

new Rectangle(5, 10, 20, 30)

Here is what happens in detail:

1. The new operator makes a Rectangle object. 2. It uses the parameters (in this case, 5, 10, 20, and 30) to initialize the data of the

object. 3. It returns the object.

2.6 Constructing Objects

Figure 10 Rectangular Shapes

Use the new operator, followed by a class name and parameters, to construct new objects.

Figure 11 Rectangle Objects

x =

Rectangle

y =

width =

height =

5

10

20

g

30

x =

Rectangle

y =

width =

height =

45

0

30

g

20

x =

Rectangle

y =

width =

height =

35

30

20

g

20

bj4_ch02_8.fm Page 46 Thursday, November 5, 2009 10:47 AM

2.6 Constructing Objects 47

The process of creating a new object is called construction. The four values 5, 10, 20, and 30 are called the construction parameters.

The new expression yields an object, and you need to store the object if you want to use it later. Usually you assign the output of the new operator to a variable. For example,

Rectangle box = new Rectangle(5, 10, 20, 30);

Some classes let you construct objects in multiple ways. For example, you can also obtain a Rectangle object by supplying no construction parameters at all (but you must still supply the parentheses):

new Rectangle()

This expression constructs a (rather useless) rectangle with its top-left corner at the origin (0, 0), width 0, and height 0.

16. How do you construct a square with center (100, 100) and side length 20? 17. The getWidth method returns the width of a Rectangle object. What does the fol-

lowing statement print? System.out.println(new Rectangle().getWidth());

Trying to Invoke a Constructor Like a Method

Constructors are not methods. You can only use a constructor with the new operator, not to reinitialize an existing object:

box.Rectangle(20, 35, 20, 30); // Error—can’t reinitialize object

The remedy is simple: Make a new object and overwrite the current one stored by box.

box = new Rectangle(20, 35, 20, 30); // OK

Syntax 2.3 Object Construction

new ClassName(parameters)Syntax

Example

Rectangle box = new Rectangle(5, 10, 20, 30);

System.out.println(new Rectangle());

Construction parameters

Usually, you save

the constructed object

in a variable.

The new expression yields an object.

Supply the parentheses even when

there are no parameters. You can also

pass the constructed object

to a method.

S E L F C H E C K

Common Error 2.2

bj4_ch02_8.fm Page 47 Thursday, November 5, 2009 10:47 AM

48 Chapter 2 Using Objects

In this section we introduce a useful terminology for the methods of a class. A method that accesses an object and returns some information about it, without changing the object, is called an accessor method. In contrast, a method whose pur- pose is to modify the internal data of an object is called a mutator method.

For example, the length method of the String class is an accessor method. It returns information about a string, namely its length. But it doesn’t modify the string at all when counting the characters.

The Rectangle class has a number of accessor methods. The getX, getY, getWidth, and getHeight methods return the x- and y-coordinates of the top-left corner, the width, and the height values. For example,

double width = box.getWidth();

Now let us consider a mutator method. Programs that manipulate rectangles fre- quently need to move them around, for example, to display animations. The Rectangle class has a method for that purpose, called translate. (Mathematicians use the term “translation” for a rigid motion of the plane.) This method moves a rectan- gle by a certain distance in the x- and y-directions. The method call,

box.translate(15, 25);

moves the rectangle by 15 units in the x-direction and 25 units in the y-direction (see Figure 12). Moving a rectangle doesn’t change its width or height, but it changes the top-left corner. Afterward, the rectangle that had its top-left corner at (5, 10) now has it at (20, 35).

This method is a mutator because it modifies the implicit parameter object.

18. Is the toUpperCase method of the String class an accessor or a mutator?

19. Which call to translate is needed to move the rectangle declared by Rectangle box = new Rectangle(5, 10, 20, 30) so that its top-left corner is the origin (0, 0)?

2.7 Accessor and Mutator Methods

Figure 12 Using the translate Method to Move a Rectangle

An accessor method does not change the internal data of its implicit parameter. A mutator method changes the data.

S E L F C H E C K

bj4_ch02_8.fm Page 48 Thursday, November 5, 2009 10:47 AM

2.8 The API Documentation 49

The classes and methods of the Java library are listed in the API documentation. The API is the “application programming interface”. A programmer who uses the Java classes to put together a computer program (or application) is an application programmer. That’s you. In contrast, the programmers who designed and imple- mented the library classes such as PrintStream and Rectangle are system programmers.

You can find the API documentation on the Web. Point your web browser to http://java.sun.com/javase/7/docs/api/index.html. Appendix D contains an abbrevi- ated version of the API documentation that may be easier to use at first. It is fine if you rely on the abbreviated documentation for your first programs, but you should eventually move on to the real thing.

The API documentation documents all classes in the Java library—there are thousands of them (see Figure 13). Most of the classes are rather specialized, and only a few are of interest to the beginning programmer.

Locate the Rectangle link in the left pane, preferably by using the search function of your browser. Click on the link, and the right pane shows all the features of the Rectangle class (see Figure 14).

2.8 The API Documentation

Figure 13 The API Documentation of the Standard Java Library

Figure 14 The API Documentation for the Rectangle Class

The API (Application Programming Interface) documentation lists the classes and methods of the Java library.

bj4_ch02_8.fm Page 49 Thursday, November 5, 2009 10:47 AM

50 Chapter 2 Using Objects

The API documentation for each class starts out with a section that describes the purpose of the class. Then come summary tables for the constructors and methods (see Figure 15). Click on the link of a method to get a detailed description (see Figure 16).

The detailed description of a method shows

• The action that the method carries out. • The parameters that the method receives. • The value that it returns (or the reserved word void if the method doesn’t return

any value). As you can see, the Rectangle class has quite a few methods. While occasionally intimidating for the beginning programmer, this is a strength of the standard library. If you ever need to do a computation involving rectangles, chances are that there is a method that does all the work for you.

For example, suppose you want to change the width or height of a rectangle. If you browse through the API documentation, you will find a setSize method with the description “Sets the size of this Rectangle to the specified width and height.” The method has two parameters, described as

• width - the new width for this Rectangle • height - the new height for this Rectangle

Now let us use this information to change the box object so that it is a square of side length 40. The name of the method is setSize, and we supply two parameters: the new width and height:

box.setSize(40, 40);

Figure 15 The Method Summary for the Rectangle Class

Figure 16 The API Documentation of the translate Method

bj4_ch02_8.fm Page 50 Thursday, November 5, 2009 10:47 AM

2.8 The API Documentation 51

The API documentation contains another important piece of information about each class. The classes in the standard library are organized into packages. A pack- age is a collection of classes with a related purpose. The Rectangle class belongs to the package java.awt (where awt is an abbreviation for “Abstract Windowing Tool- kit”), which contains many classes for drawing windows and graphical shapes. You can see the package name java.awt in Figure 14, just above the class name.

To use the Rectangle class from the java.awt package, you must import the pack- age. Simply place the following line at the top of your program:

import java.awt.Rectangle;

Why don’t you have to import the System and String classes? Because the System and String classes are in the java.lang package, and all classes from this package are auto- matically imported, so you never need to import them yourself.

20. Look at the API documentation of the String class. Which method would you use to obtain the string "hello, world!" from the string "Hello, World!"?

21. In the API documentation of the String class, look at the description of the trim method. What is the result of applying trim to the string " Hello, Space ! "? (Note the spaces in the string.)

22. The Random class is declared in the java.util package. What do you need to do in order to use that class in your program?

Don’t Memorize—Use Online Help

The Java library has thousands of classes and methods. It is neither necessary nor useful try- ing to memorize them. Instead, you should become familiar with using the API documenta- tion. Because you will need to use the API documentation all the time, it is best to download and install it onto your computer, particularly if your computer is not always connected to the Internet. You can download the documentation from http://java.sun.com/javase/ downloads/index.html.

Syntax 2.4 Importing a Class from a Package

import packageName.ClassName;Syntax

Example

import java.awt.Rectangle;

Class name

You can look up the package name

in the API documentation.

Package name

Import statements

must be at the top of

the source file.

Java classes are grouped into packages. Use the import statement to use classes that are declared in other packages.

S E L F C H E C K

Productivity Hint 2.1

bj4_ch02_8.fm Page 51 Thursday, November 5, 2009 10:47 AM

52 Chapter 2 Using Objects Testing Track

In this section, we discuss the steps that are necessary to implement a test program. The purpose of a test program is to verify that one or more methods have been implemented correctly. A test program calls methods and checks that they return the expected results. Writing test programs is a very important skill.

In this section, we will develop a simple program that tests a method in the Rect- angle class. The program performs the following steps:

1. Provide a tester class. 2. Supply a main method. 3. Inside the main method, construct one or more objects. 4. Apply methods to the objects. 5. Display the results of the method calls. 6. Display the values that you expect to get.

Our sample test program tests the behavior of the translate method. Here are the key steps (which have been placed inside the main method of the MoveTester class).

Rectangle box = new Rectangle(5, 10, 20, 30);

// Move the rectangle box.translate(15, 25);

// Print information about the moved rectangle System.out.print("x: "); System.out.println(box.getX()); System.out.println("Expected: 20");

We print the value that is returned by the getX method, and then we print a message that describes the value we expect to see.

This is a very important step. You want to spend some time thinking about the expected result before you run a test program. This thought process will help you understand how your program should behave, and it can help you track down errors at an early stage. Finding and fixing errors early is a very effective strategy that can save you a great deal of time.

In our case, the rectangle has been constructed with the top-left corner at (5, 10). The x-direction is moved by 15, so we expect an x-value of 5 + 15 = 20 after the move.

Here is a complete program that tests the moving of a rectangle.

ch02/rectangle/MoveTester.java

2.9 Implementing a Test Program

A test program verifies that methods behave as expected.

Determining the expected result in advance is an important part of testing.

1 import java.awt.Rectangle; 2 3 public class MoveTester 4 { 5 public static void main(String[] args) 6 { 7 Rectangle box = new Rectangle(5, 10, 20, 30); 8 9 // Move the rectangle

10 box.translate(15, 25); 11

bj4_ch02_8.fm Page 52 Thursday, November 5, 2009 10:47 AM

Testing Track 2.9 Implementing a Test Program 53

Program Run

23. Suppose we had called box.translate(25, 15) instead of box.translate(15, 25). What are the expected outputs?

24. Why doesn’t the MoveTester program need to print the width and height of the rectangle?

Testing Classes in an Interactive Environment

Some development environments are specifically designed to help students explore objects without having to provide tester classes. These environments can be very helpful for gaining insight into the behavior of objects, and for promoting object-oriented thinking. The BlueJ environment (shown in the figure) displays objects as blobs on a workbench. You can

Testing a Method Call in BlueJ

12 // Print information about the moved rectangle 13 System.out.print("x: "); 14 System.out.println(box.getX()); 15 System.out.println("Expected: 20"); 16 17 System.out.print("y: "); 18 System.out.println(box.getY()); 19 System.out.println("Expected: 35"); 20 } 21 }

x: 20 Expected: 20 y: 35 Expected: 35

S E L F C H E C K

Special Topic 2.1

bj4_ch02_8.fm Page 53 Thursday, November 5, 2009 10:47 AM

54 Chapter 2 Using Objects Testing Track

construct new objects, put them on the workbench, invoke methods, and see the return val- ues, all without writing a line of code. You can download BlueJ at no charge from www.bluej.org. Another excellent environment for interactively exploring objects is Dr. Java at drjava.sourceforge.net.

How Many Days Have You Been Alive?

In this Worked Example, you explore the API of a class Day that represents a calendar day, and you write a program that computes how many days have elapsed since the day you were born.

Working with Pictures

In this Worked Example, you use the API of a Picture class to edit photos.

In Java, a variable whose type is a class does not actually hold an object. It merely holds the memory location of an object. The object itself is stored elsewhere—see Figure 17.

There is a reason for this behavior. Objects can be very large. It is more efficient to store only the memory location instead of the entire object.

We use the technical term object reference to denote the memory location of an object. When a variable contains the memory location of an object, we say that it refers to an object. For example, after the statement

Rectangle box = new Rectangle(5, 10, 20, 30);

the variable box refers to the Rectangle object that the new operator constructed. Tech- nically speaking, the new operator returned a reference to the new object, and that reference is stored in the box variable.

It is very important that you remember that the box variable does not contain the object. It refers to the object. Two object variables can refer to the same object:

Rectangle box2 = box;

Worked Example 2.1

Worked Example 2.2

2.10 Object References

Figure 17 An Object Variable Containing an Object Reference

An object reference describes the location of an object.

box =

x =

Rectangle

y =

width =

height =

5

10

20

g

30

Available online in WileyPLUS and at www.wiley.com/college/horstmann.

bj4_ch02_8.fm Page 54 Thursday, November 5, 2009 10:47 AM

2.10 Object References 55

Now you can access the same Rectangle object both as box and as box2, as shown in Figure 18.

However, number variables actually store numbers. When you declare int luckyNumber = 13;

then the luckyNumber variable holds the number 13, not a reference to the number (see Figure 19). The reason is again efficiency. Because numbers require little stor- age, it is more efficient to store them directly in a variable.

You can see the difference between number variables and object variables when you make a copy of a variable. When you copy a number, the original and the copy of the number are independent values. But when you copy an object reference, both the original and the copy are references to the same object.

Consider the following code, which copies a number and then changes the copy (see Figure 20):

int luckyNumber = 13; int luckyNumber2 = luckyNumber; luckyNumber2 = 12;

Now the variable luckyNumber contains the value 13, and luckyNumber2 contains 12.

Figure 18 Two Object Variables Referring to the Same Object

Figure 19 A Number Variable Stores a Number

Figure 20 Copying Numbers

box =

box2 = x =

Rectangle

y =

width =

height =

5

10

20

g

30

Multiple object variables can contain references to the same object.

luckyNumber = 13

Number variables store numbers. Object variables store references.

1 2

3

luckyNumber = 13

luckyNumber2 = 13

luckyNumber = 131

2

luckyNumber = 13

luckyNumber2 = 12

3

bj4_ch02_8.fm Page 55 Thursday, November 5, 2009 10:47 AM

56 Chapter 2 Using Objects

Now consider the seemingly analogous code with Rectangle objects (see Figure 21).

Rectangle box = new Rectangle(5, 10, 20, 30); Rectangle box2 = box; box2.translate(15, 25);

Since box and box2 refer to the same rectangle after step , both variables refer to the moved rectangle after the call to the translate method.

You need not worry too much about the difference between objects and object references. Much of the time, you will have the correct intuition when you think of “the object box” rather than the technically more accurate “the object reference stored in box”. The difference between objects and object references only becomes apparent when you have multiple variables that refer to the same object.

25. What is the effect of the assignment String greeting2 = greeting?

26. After calling greeting2.toUpperCase(), what are the contents of greeting and greeting2?

Figure 21 Copying Object References

box =

box2 = x =

Rectangle

y =

width =

height =

5

10

20

g

30

box =

box2 = x =

Rectangle

y =

width =

height =

20

35

20

g

30

box =

x =

Rectangle

y =

width =

height =

5

10

20

g

30

1

2

3

1 2

3A N I M A T I O N Object References

2

S E L F C H E C K

bj4_ch02_8.fm Page 56 Thursday, November 5, 2009 10:47 AM

2.10 Object References 57

Mainframes—When Dinosaurs Ruled the Earth

When International Business Machines Corporation (IBM), a successful manufacturer of punched-card equipment for tabulating data, first turned its attention to designing comput- ers in the early 1950s, its planners assumed that there was a market for perhaps 50 such devices, for installation by the government, the military, and a few of the country’s largest corporations. Instead, they sold about 1,500 machines of their System 650 model and went on to build and sell more powerful computers.

The so-called mainframe computers of the 1950s, 1960s, and 1970s were huge. They filled rooms, which had to be climate-controlled to protect the delicate equipment (see figure). Today, because of miniaturization technology, even mainframes are getting smaller, but they are still very expensive. (At the time of this writing, the cost for a typical mainframe is several million dollars.)

These huge and expensive systems were an immediate success when they first appeared, because they replaced many roomfuls of even more expensive employees, who had previ- ously performed the tasks by hand. Few of these computers do any exciting computations. They keep mundane information, such as billing records or airline reservations; they just keep lots of them.

IBM was not the first company to build mainframe computers; that honor belongs to the Univac Corporation. However, IBM soon became the major player, partially because of technical excellence and attention to customer needs and partially because it exploited its strengths and structured its products and services in a way that made it difficult for custom- ers to mix them with those of other vendors. In the 1960s, IBM’s competitors, the so-called “Seven Dwarfs”—GE, RCA, Univac, Honeywell, Burroughs, Control Data, and NCR—fell on hard times. Some went out of the computer business altogether, while others tried unsuc- cessfully to combine their strengths by merging their computer operations. It was generally

A Mainframe Computer

Random Fact 2.1

bj4_ch02_8.fm Page 57 Thursday, November 5, 2009 10:47 AM

58 Chapter 2 Using Objects Graphics Track

predicted that they would eventually all fail. It was in this atmosphere that the U.S. govern- ment brought an antitrust suit against IBM in 1969. The suit went to trial in 1975 and dragged on until 1982, when the Reagan Administration abandoned it, declaring it “without merit”.

Of course, by then the computing landscape had changed completely. Just as the dino- saurs gave way to smaller, nimbler creatures, three new waves of computers had appeared: the minicomputers, workstations, and microcomputers, all engineered by new companies, not the Seven Dwarfs. Today, the importance of mainframes in the marketplace has dimin- ished, and IBM, while still a large and resourceful company, no longer dominates the com- puter market.

Mainframes are still in use today for two reasons. They still excel at handling large data volumes. More importantly, the programs that control the business data have been refined over the last 30 or more years, fixing one problem at a time. Moving these programs to less expensive computers, with different languages and operating systems, is difficult and error-prone. In the 1990s, Sun Microsystems, a leading manufacturer of workstations and servers—and the inventor of Java—was eager to prove that its mainframe system could be “downsized” and replaced by its own equipment. Sun eventually succeeded, but it took over five years—far longer than it expected.

This is the first of several optional sections that teach you how to write graphical applications: applications that display drawings inside a window. Graphical applica- tions look more attractive than the console applications that show plain text in a console window.

A graphical application shows information inside a frame: a window with a title bar, as shown in Figure 22. In this section, you will learn how to display a frame. In Section 3.9, you will learn how to create a drawing inside the frame.

2.11 Graphical Applications and Frame Windows

Figure 22 A Frame Window

To show a frame, construct a JFrame object, set its size, and make it visible.

bj4_ch02_8.fm Page 58 Thursday, November 5, 2009 10:47 AM

Graphics Track 2.11 Graphical Applications and Frame Windows 59

To show a frame, carry out the following steps:

1. Construct an object of the JFrame class: JFrame frame = new JFrame();

2. Set the size of the frame: frame.setSize(300, 400);

This frame will be 300 pixels wide and 400 pixels tall. If you omit this step the frame will be 0 by 0 pixels, and you won’t be able to see it. (Pixels are the tiny dots from which digital images are composed.)

3. If you’d like, set the title of the frame: frame.setTitle("An Empty Frame");

If you omit this step, the title bar is simply left blank. 4. Set the “default close operation”:

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); When the user closes the frame, the program automatically exits. Don’t omit this step. If you do, the program continues running even after the frame is closed.

5. Make the frame visible: frame.setVisible(true);

The simple program below shows all of these steps. It produces the empty frame shown in Figure 22.

The JFrame class is a part of the javax.swing package. Swing is the nickname for the graphical user interface library in Java. The “x” in javax denotes the fact that Swing started out as a Java extension before it was added to the standard library.

We will go into much greater detail about Swing programming in Chapters 3, 9, 10, and 18. For now, consider this program to be the essential plumbing that is required to show a frame.

ch02/emptyframe/EmptyFrameViewer.java

27. How do you display a square frame with a title bar that reads “Hello, World!”? 28. How can a program display two frames at once?

1 import javax.swing.JFrame; 2 3 public class EmptyFrameViewer 4 { 5 public static void main(String[] args) 6 { 7 JFrame frame = new JFrame(); 8 9 frame.setSize(300, 400);

10 frame.setTitle("An Empty Frame"); 11 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 12 13 frame.setVisible(true); 14 } 15 }

S E L F C H E C K

bj4_ch02_8.fm Page 59 Thursday, November 5, 2009 10:47 AM

60 Chapter 2 Using Objects Graphics Track

This section continues the optional graphics track. You will learn how to make shapes appear inside a frame window. The first drawing will be exceedingly modest: just two rectangles (see Figure 23). You’ll soon see how to produce more interesting drawings. The purpose of this example is to show you the basic outline of a pro- gram that creates a drawing. You cannot draw directly onto a frame. Whenever you want to show anything inside a frame, be it a button or a drawing, you have to construct a component object and add it to the frame. In the Swing toolkit, the JComponent class represents a blank component.

Since we don’t want to add a blank component, we have to modify the JComponent class and specify how the component should be painted. The solution is to declare a new class that extends the JComponent class. You will learn about the process of extending classes in Chapter 10. For now, simply use the following code as a template.

public class RectangleComponent extends JComponent { public void paintComponent(Graphics g) { Drawing instructions } }

The extends reserved word indicates that our component class, RectangleComponent, can be used like a JComponent. However, the RectangleComponent class will be different from the plain JComponent class in one respect: Its paintComponent method will contain instructions to draw the rectangles.

When the component is shown for the first time, the paintComponent method is called automatically. The method is also called when the window is resized, or when it is shown again after it was hidden.

The paintComponent method receives an object of type Graphics. The Graphics object stores the graphics state—the current color, font, and so on, that are used for

2.12 Drawing on a Component

Figure 23 Drawing Rectangles

In order to display a drawing in a frame, declare a class that extends the JComponent class.

Place drawing instructions inside the paintComponent method. That method is called whenever the component needs to be repainted.

bj4_ch02_8.fm Page 60 Thursday, November 5, 2009 10:47 AM

Graphics Track 2.12 Drawing on a Component 61

drawing operations. However, the Graphics class is primitive. When programmers clamored for a more object-oriented approach for drawing graphics, the designers of Java created the Graphics2D class, which extends the Graphics class. Whenever the Swing toolkit calls the paintComponent method, it actually passes a parameter of type Graphics2D. Because we want to use the more sophisticated methods to draw two- dimensional graphics objects, we need to use the Graphics2D class. This is accom- plished by using a cast:

public class RectangleComponent extends JComponent { public void paintComponent(Graphics g) { // Recover Graphics2D Graphics2D g2 = (Graphics2D) g; . . . } }

We cover the concepts of extending classes and of casting in Chapter 10. For now, you should simply include the cast at the top of your paintComponent methods.

Now you are ready to draw shapes. The draw method of the Graphics2D class can draw shapes, such as rectangles, ellipses, line segments, polygons, and arcs. Here we draw a rectangle:

public class RectangleComponent extends JComponent { public void paintComponent(Graphics g) { . . . Rectangle box = new Rectangle(5, 10, 20, 30); g2.draw(box); . . . } }

Following is the source code for the RectangleComponent class. Note that the paintComponent method of the RectangleComponent class draws two rectangles.

As you can see from the import statements, the Graphics and Graphics2D classes are part of the java.awt package.

ch02/rectangles/RectangleComponent.java

Use a cast to recover the Graphics2D object from the Graphics parameter of the paintComponent method.

1 import java.awt.Graphics; 2 import java.awt.Graphics2D; 3 import java.awt.Rectangle; 4 import javax.swing.JComponent; 5 6 /* 7 A component that draws two rectangles. 8 */ 9 public class RectangleComponent extends JComponent

10 { 11 public void paintComponent(Graphics g) 12 { 13 // Recover Graphics2D 14 Graphics2D g2 = (Graphics2D) g; 15

bj4_ch02_8.fm Page 61 Thursday, November 5, 2009 10:47 AM

62 Chapter 2 Using Objects Graphics Track

In order to see the drawing, one task remains. You need to display the frame into which you added a component object. Follow these steps:

1. Construct a frame as described in the preceding section. 2. Construct an object of your component class:

RectangleComponent component = new RectangleComponent(); 3. Add the component to the frame:

frame.add(component); 4. Make the frame visible, as described in the preceding section.

The following listing shows the complete process.

ch02/rectangles/RectangleViewer.java

Note that the rectangle drawing program consists of two classes:

• The RectangleComponent class, whose paintComponent method produces the drawing. • The RectangleViewer class, whose main method constructs a frame and a

RectangleComponent, adds the component to the frame, and makes the frame visible.

29. How do you modify the program to draw two squares? 30. How do you modify the program to draw one rectangle and one square? 31. What happens if you call g.draw(box) instead of g2.draw(box)?

16 // Construct a rectangle and draw it 17 Rectangle box = new Rectangle(5, 10, 20, 30); 18 g2.draw(box); 19 20 // Move rectangle 15 units to the right and 25 units down 21 box.translate(15, 25); 22 23 // Draw moved rectangle 24 g2.draw(box); 25 } 26 }

1 import javax.swing.JFrame; 2 3 public class RectangleViewer 4 { 5 public static void main(String[] args) 6 { 7 JFrame frame = new JFrame(); 8 9 frame.setSize(300, 400);

10 frame.setTitle("Two rectangles"); 11 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 12 13 RectangleComponent component = new RectangleComponent(); 14 frame.add(component); 15 16 frame.setVisible(true); 17 } 18 }

S E L F C H E C K

bj4_ch02_8.fm Page 62 Thursday, November 5, 2009 10:47 AM

Graphics Track 2.12 Drawing on a Component 63

Applets

In the preceding section, you learned how to write a program that displays graphical shapes. Some people prefer to use applets for learning about graphics programming. Applets have two advantages. They don’t need separate component and viewer classes; you only imple- ment a single class. And, more importantly, applets run inside a web browser, allowing you to place your creations on a web page for all the world to admire.

To implement an applet, use this code outline:

public class MyApplet extends JApplet { public void paint(Graphics g) { // Recover Graphics2D Graphics2D g2 = (Graphics2D) g;

// Drawing instructions go here . . . } }

This is almost the same outline as for a component, with two minor differences:

1. You extend JApplet, not JComponent. 2. You place the drawing code inside the paint method, not inside paintComponent.

The following applet draws two rectangles:

ch02/applet/RectangleApplet.java

Special Topic 2.2

Applets are programs that run inside a web browser.

1 import java.awt.Graphics; 2 import java.awt.Graphics2D; 3 import java.awt.Rectangle; 4 import javax.swing.JApplet; 5 6 /* 7 An applet that draws two rectangles. 8 */ 9 public class RectangleApplet extends JApplet

10 { 11 public void paint(Graphics g) 12 { 13 // Prepare for extended graphics 14 Graphics2D g2 = (Graphics2D) g; 15 16 // Construct a rectangle and draw it 17 Rectangle box = new Rectangle(5, 10, 20, 30); 18 g2.draw(box); 19 20 // Move rectangle 15 units to the right and 25 units down 21 box.translate(15, 25); 22 23 // Draw moved rectangle 24 g2.draw(box); 25 } 26 }

bj4_ch02_8.fm Page 63 Thursday, November 5, 2009 10:47 AM

64 Chapter 2 Using Objects Graphics Track

To run this applet, you need an HTML file with an applet tag. HTML, the hypertext markup language, is the language used to describe web pages. (See Appendix F for more information on HTML.) Here is the simplest possible file to display the rectangle applet:

ch02/applet/RectangleApplet.html

If you know HTML, you can proudly explain your creation, by adding text and more HTML tags:

ch02/applet/RectangleAppletExplained.html

An HTML file can have multiple applets. Simply add a separate applet tag for each applet. You can give the HTML file any name you like. It is easiest to give the HTML file the

same name as the applet. But some development environments already generate an HTML file with the same name as your project to hold your project notes; then you must give the HTML file containing your applet a different name.

An Applet in the Applet Viewer An Applet in a Web Browser

To run an applet, you need an HTML file with the applet tag.

1 <applet code="RectangleApplet.class" width="300" height="400"> 2 </applet>

1 <html> 2 <head> 3 <title>Two rectangles</title> 4 </head> 5 <body> 6 <p>Here is my <i>first applet</i>:</p> 7 <applet code="RectangleApplet.class" width="300" height="400"> 8 </applet> 9 </body>

10 </html>

bj4_ch02_8.fm Page 64 Thursday, November 5, 2009 10:47 AM

Graphics Track 2.13 Ellipses, Lines, Text, and Color 65

To run the applet, you have two choices. You can use the applet viewer, a program that is included with the Java Software Development Kit from Sun Microsystems. You simply start the applet viewer, giving it the name of the HTML file that contains your applets:

appletviewer RectangleApplet.html

The applet viewer only shows the applet, not the HTML text (see the left figure). You can also show the applet inside any Java-enabled web browser, such as Firefox or

Safari. (If you use Internet Explorer, you probably need to configure it. By default, Microsoft supplies either an outdated version of Java or no Java at all. Go to the java.com web site and install the Java plugin.) The second figure shows the applet running in a browser. As you can see, both the text and the applet are displayed.

In Section 2.12 you learned how to write a program that draws rectangles. In this section you will learn how to draw other shapes: ellipses and lines. With these graphical elements, you can draw quite a few interesting pictures.

To draw an ellipse, you specify its bounding box (see Figure 24) in the same way that you would specify a rectangle, namely by the x- and y-coordinates of the top- left corner and the width and height of the box.

However, there is no simple Ellipse class that you can use. Instead, you must use one of the two classes Ellipse2D.Float and Ellipse2D.Double, depending on whether you want to store the ellipse coordinates as single- or double-precision floating- point values. Because the latter are more convenient to use in Java, we will always use the Ellipse2D.Double class. Here is how you construct an ellipse:

Ellipse2D.Double ellipse = new Ellipse2D.Double(x, y, width, height);

The class name Ellipse2D.Double looks different from the class names that you have encountered up to now. It consists of two class names Ellipse2D and Double separated

You view applets with the applet viewer or a Java- enabled browser.

2.13 Ellipses, Lines, Text, and Color

Figure 24 An Ellipse and Its Bounding Box

2.13.1 Ellipses and Circles

The Ellipse2D.Double and Line2D.Double classes describe graphical shapes.

(x, y)

H ei

gh t

Width

bj4_ch02_8.fm Page 65 Thursday, November 5, 2009 10:47 AM

66 Chapter 2 Using Objects Graphics Track

by a period (.). This indicates that Ellipse2D.Double is a so-called inner class inside Ellipse2D. When constructing and using ellipses, you don’t actually need to worry about the fact that Ellipse2D.Double is an inner class—just think of it as a class with a long name. However, in the import statement at the top of your program, you must be careful that you import only the outer class:

import java.awt.geom.Ellipse2D;

Drawing an ellipse is easy: Use exactly the same draw method of the Graphics2D class that you used for drawing rectangles.

g2.draw(ellipse);

To draw a circle, simply set the width and height to the same values: Ellipse2D.Double circle = new Ellipse2D.Double(x, y, diameter, diameter); g2.draw(circle);

Notice that (x, y) is the top-left corner of the bounding box, not the center of the circle.

To draw a line, use an object of the Line2D.Double class. A line is constructed by spec- ifying its two end points. You can do this in two ways. Simply give the x- and y- coordinates of both end points:

Line2D.Double segment = new Line2D.Double(x1, y1, x2, y2);

Or specify each end point as an object of the Point2D.Double class: Point2D.Double from = new Point2D.Double(x1, y1); Point2D.Double to = new Point2D.Double(x2, y2);

Line2D.Double segment = new Line2D.Double(from, to);

The second option is more object-oriented and is often more useful, particularly if the point objects can be reused elsewhere in the same drawing.

You often want to put text inside a drawing, for example, to label some of the parts. Use the drawString method of the Graphics2D class to draw a string anywhere in a window. You must specify the string and the x- and y-coordinates of the basepoint of the first character in the string (see Figure 25). For example,

g2.drawString("Message", 50, 100);

Figure 25 Basepoint and Baseline

2.13.2 Lines

2.13.3 Drawing Text

The drawString method draws a string, starting at its basepoint.

Baseline

Basepoint

bj4_ch02_8.fm Page 66 Thursday, November 5, 2009 10:47 AM

Graphics Track 2.13 Ellipses, Lines, Text, and Color 67

When you first start drawing, all shapes and strings are drawn with a black pen. To change the color, you need to supply an object of type Color. Java uses the RGB color model. That is, you specify a color by the amounts of the primary colors— red, green, and blue—that make up the color. The amounts are given as integers between 0 (primary color not present) and 255 (maximum amount present). For example,

Color magenta = new Color(255, 0, 255);

constructs a Color object with maximum red, no green, and maximum blue, yielding a bright purple color called magenta.

For your convenience, a variety of colors have been declared in the Color class. Table 4 shows those colors and their RGB values. For example, Color.PINK has been declared to be the same color as new Color(255, 175, 175).

To draw a shape in a different color, first set the color of the Graphics2D object, then call the draw method:

g2.setColor(Color.RED); g2.draw(circle); // Draws the shape in red

If you want to color the inside of the shape, use the fill method instead of the draw method. For example,

g2.fill(circle);

fills the inside of the circle with the current color.

2.13.4 Colors

When you set a new color in the graphics context, it is used for subsequent drawing operations.

Table 4 Predefined Colors

Color RGB Value

Color.BLACK 0, 0, 0

Color.BLUE 0, 0, 255

Color.CYAN 0, 255, 255

Color.GRAY 128, 128, 128

Color.DARKGRAY 64, 64, 64

Color.LIGHTGRAY 192, 192, 192

Color.GREEN 0, 255, 0

Color.MAGENTA 255, 0, 255

Color.ORANGE 255, 200, 0

Color.PINK 255, 175, 175

Color.RED 255, 0, 0

Color.WHITE 255, 255, 255

Color.YELLOW 255, 255, 0

bj4_ch02_8.fm Page 67 Thursday, November 5, 2009 10:47 AM

68 Chapter 2 Using Objects Graphics Track

The following program puts all these shapes to work, creating a simple drawing (see Figure 26).

ch02/face/FaceComponent.java

Figure 26 An Alien Face

1 import java.awt.Color; 2 import java.awt.Graphics; 3 import java.awt.Graphics2D; 4 import java.awt.Rectangle; 5 import java.awt.geom.Ellipse2D; 6 import java.awt.geom.Line2D; 7 import javax.swing.JComponent; 8 9 /*

10 A component that draws an alien face. 11 */ 12 public class FaceComponent extends JComponent 13 { 14 public void paintComponent(Graphics g) 15 { 16 // Recover Graphics2D 17 Graphics2D g2 = (Graphics2D) g; 18 19 // Draw the head 20 Ellipse2D.Double head = new Ellipse2D.Double(5, 10, 100, 150); 21 g2.draw(head); 22 23 // Draw the eyes 24 g2.setColor(Color.GREEN); 25 Rectangle eye = new Rectangle(25, 70, 15, 15); 26 g2.fill(eye); 27 eye.translate(50, 0); 28 g2.fill(eye); 29 30 // Draw the mouth 31 Line2D.Double mouth = new Line2D.Double(30, 110, 80, 110); 32 g2.setColor(Color.RED); 33 g2.draw(mouth); 34 35 // Draw the greeting 36 g2.setColor(Color.BLUE); 37 g2.drawString("Hello, World!", 5, 175); 38 } 39 }

bj4_ch02_8.fm Page 68 Thursday, November 5, 2009 10:47 AM

Graphics Track 2.13 Ellipses, Lines, Text, and Color 69

ch02/face/FaceViewer.java

32. Give instructions to draw a circle with center (100, 100) and radius 25. 33. Give instructions to draw a letter “V” by drawing two line segments. 34. Give instructions to draw a string consisting of the letter “V”. 35. What are the RGB color values of Color.BLUE? 36. How do you draw a yellow square on a red background?

The Evolution of the Internet

In 1962, J.C.R. Licklider was head of the first computer research program at DARPA, the Defense Advanced Research Projects Agency. He wrote a series of papers describing a “galactic network” through which computer users could access data and programs from other sites. This was well before computer networks were invented. By 1969, four computers—three in California and one in Utah—were connected to the ARPANET, the precursor of the Internet. The network grew quickly, linking computers at many universities and research organizations. It was originally thought that most network users wanted to run programs on remote computers. Using remote execution, a researcher at one institution would be able to access an underutilized computer at a different site. It quickly became apparent that remote execution was not what the network was actually used for. Instead, the “killer application” was electronic mail: the transfer of messages between computer users at different locations.

In 1972, Bob Kahn proposed to extend ARPANET into the Internet: a collection of interoperable networks. All networks on the Internet share common protocols for data transmission. Kahn and Vinton Cerf developed a protocol, now called TCP/IP (Transmis- sion Control Protocol/Internet Protocol). On January 1, 1983, all hosts on the Internet simultaneously switched to the TCP/IP protocol (which is used to this day).

Over time, researchers, computer scientists, and hobbyists published increasing amounts of information on the Internet. For example, the GNU (GNU’s Not UNIX) project is pro- ducing a free set of high-quality operating system utilities and program development tools (www.gnu.org). Project Gutenberg makes available the text of important classical books, whose copyright has expired, in computer-readable form (www.gutenberg.org). In 1989, Tim Berners-Lee started work on hyperlinked documents, allowing users to browse by following

1 import javax.swing.JFrame; 2 3 public class FaceViewer 4 { 5 public static void main(String[] args) 6 { 7 JFrame frame = new JFrame(); 8 frame.setSize(150, 250); 9 frame.setTitle("An Alien Face");

10 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 11 12 FaceComponent component = new FaceComponent(); 13 frame.add(component); 14 15 frame.setVisible(true); 16 } 17 }

S E L F C H E C K

Random Fact 2.2

bj4_ch02_8.fm Page 69 Thursday, November 5, 2009 10:47 AM

70 Chapter 2 Using Objects Graphics Track

links to related documents. This infrastructure is now known as the World Wide Web (WWW).

The first interfaces to retrieve this information were, by today’s standards, unbelievably clumsy and hard to use. In March 1993, WWW traffic was 0.1% of all Internet traffic. All that changed when Marc Andreesen, then a graduate student working for NCSA (the National Center for Supercomputing Applications), released Mosaic. Mosaic displayed web pages in graphical form, using images, fonts, and colors (see the figure). Andreesen went on to fame and fortune at Netscape, and Microsoft licensed the Mosaic code to create Internet Explorer. By 1996, WWW traffic accounted for more than half of the data transported on the Internet.

Use integers and floating-point numbers.

• A type specifies a set of values and the operations that can be carried out with the values.

• The double type denotes floating-point numbers that can have fractional parts. • In Java, the number types are primitive types, and numbers are not objects. • Numbers can be combined by arithmetic operators such as +, -, and *.

Write variable declarations in Java.

• You use variables to store values that you want to use at a later time. A variable has a type, a name, and a value.

• Identifiers for variables, methods, and classes are composed of letters, digits, and the underscore character.

• By convention, variable names should start with a lowercase letter.

The NCSA Mosaic Browser

Summary of Learning Objectives

bj4_ch02_8.fm Page 70 Thursday, November 5, 2009 10:47 AM

Summary of Learning Objectives 71

Explain the processes of variable assignment and initialization.

• Use the assignment operator (=) to change the value of a variable. • All variables must be initialized before you access them.

Declare objects, classes, and methods.

• Objects are entities in your program that you manipulate by calling methods. • A method is a sequence of instructions that accesses the data of an object. • A class declares the methods that you can apply to its objects. • The public interface of a class specifies what you can do with its objects. The hidden

implementation describes how these actions are carried out.

Recognize implicit parameters, explicit parameters, and return values of methods.

• A parameter is an input to a method. • The implicit parameter of a method call is the object on which the method is

invoked. All other parameters are explicit parameters. • The return value of a method is a result that the method has computed for use by

the code that called it.

Use constructors to construct new objects.

• Use the new operator, followed by a class name and parameters, to construct new objects.

Classify methods as accessor and mutator methods.

• An accessor method does not change the internal data of its implicit parameter. A mutator method changes the data.

Use the API documentation for finding method descriptions and packages.

• The API (Application Programming Interface) documentation lists the classes and methods of the Java library.

• Java classes are grouped into packages. Use the import statement to use classes that are declared in other packages.

Write programs that test behavior of methods.

• A test program verifies that methods behave as expected. • Determining the expected result in advance is an important part of testing.

Describe how multiple object references can refer to the same object.

• An object reference describes the location of an object. • Multiple object variables can contain references to the same object. • Number variables store numbers. Object variables store references.

Write programs that display frame windows.

• To show a frame, construct a JFrame object, set its size, and make it visible. • In order to display a drawing in a frame, declare a class that extends the

JComponent class. • Place drawing instructions inside the paintComponent method. That method is called

whenever the component needs to be repainted.

bj4_ch02_8.fm Page 71 Thursday, November 5, 2009 10:47 AM

72 Chapter 2 Using Objects

• Use a cast to recover the Graphics2D object from the Graphics parameter of the paintComponent method.

• Applets are programs that run inside a web browser. • To run an applet, you need an HTML file with the applet tag. • You view applets with the applet viewer or a Java-enabled browser.

Use the Java API for drawing simple figures.

• The Ellipse2D.Double and Line2D.Double classes describe graphical shapes. • The drawString method draws a string, starting at its basepoint. • When you set a new color in the graphics context, it is used for subsequent drawing

operations.

• Worked Example How Many Days Have You Been Alive? • Worked Example Working with Pictures • Lab Exercises

Animation Variable Initialization and Assignment Animation Parameter Passing Animation Object References Practice Quiz Code Completion Exercises

R2.1 Explain the difference between an object and an object reference.

R2.2 Explain the difference between an object and an object variable.

Classes, Objects, and Methods Introduced in this Chapter java.awt.Color java.awt.Component getHeight getWidth setSize setVisible java.awt.Frame setTitle java.awt.geom.Ellipse2D.Double java.awt.geom.Line2D.Double java.awt.geom.Point2D.Double java.awt.Graphics setColor java.awt.Graphics2D draw drawString fill

java.awt.Rectangle getX getY getHeight getWidth setSize translate java.lang.String length replace toLowerCase toUpperCase javax.swing.JComponent paintComponent javax.swing.JFrame setDefaultCloseOperation

Media Resources

www.wiley.com/ college/ horstmann

Review Exercises

bj4_ch02_8.fm Page 72 Thursday, November 5, 2009 10:47 AM

Review Exercises 73

R2.3 Explain the difference between an object and a class.

R2.4 Give the Java code for constructing an object of class Rectangle, and for declaring an object variable of class Rectangle.

R2.5 Explain the difference between the = symbol in Java and in mathematics.

R2.6 Give Java code for objects with the following descriptions: a. A rectangle with center (100, 100) and all side lengths equal to 50 b. A string with the contents “Hello, Dave”

Create objects, not object variables.

R2.7 Repeat Exercise R2.6, but now declare object variables that are initialized with the required objects.

R2.8 Write a Java statement to initialize a variable square with a rectangle object whose top left corner is (10, 20) and whose sides all have length 40. Then write a statement that replaces square with a rectangle of the same size and top left corner (20, 20).

R2.9 Write Java statements that initialize two variables square1 and square2 to refer to the same square with center (20, 20) and side length 40.

R2.10 Write Java statements that initialize a string message with "Hello" and then change it to "HELLO". Use the toUpperCase method.

R2.11 Write Java statements that initialize a string message with "Hello" and then change it to "hello". Use the replace method.

R2.12 Find the errors in the following statements: a. Rectangle r = (5, 10, 15, 20); b. double width = Rectangle(5, 10, 15, 20).getWidth(); c. Rectangle r;

r.translate(15, 25);

d. r = new Rectangle(); r.translate("far, far away!");

R2.13 Name two accessor methods and two mutator methods of the Rectangle class.

R2.14 Look into the API documentation of the Rectangle class and locate the method void add(int newx, int newy)

Read through the method documentation. Then determine the result of the follow- ing statements:

Rectangle box = new Rectangle(5, 10, 20, 30); box.add(0, 0);

If you are not sure, write a small test program.

R2.15 What is the difference between a console application and a graphical application?

R2.16 Who calls the paintComponent method of a component? When does the call to the paintComponent method occur?

R2.17 Why does the parameter of the paintComponent method have type Graphics and not Graphics2D?

R2.18 What is the purpose of a graphics context?

G

G

G

G

bj4_ch02_8.fm Page 73 Thursday, November 5, 2009 10:47 AM

74 Chapter 2 Using Objects

R2.19 Why are separate viewer and component classes used for graphical programs?

R2.20 How do you specify a text color?

P2.1 Write an AreaTester program that constructs a Rectangle object and then computes and prints its area. Use the getWidth and getHeight methods. Also print the expected answer.

P2.2 Write a PerimeterTester program that constructs a Rectangle object and then com- putes and prints its perimeter. Use the getWidth and getHeight methods. Also print the expected answer.

P2.3 Write a program called FourRectanglePrinter that constructs a Rectangle object, prints its location by calling System.out.println(box), and then translates and prints it three more times, so that, if the rectangles were drawn, they would form one large rectangle:

Your program will not produce a drawing. It will simply print the locations of the four rectangles.

P2.4 Write a GrowSquarePrinter program that constructs a Rectangle object square repre- senting a square with top-left corner (100, 100) and side length 50, prints its location by calling System.out.println(square), applies the translate and grow methods and calls System.out.println(square) again. The calls to translate and grow should modify the square so that it has twice the size and the same top-left corner as the original. If the squares were drawn, they would look like this:

Your program will not produce a drawing. It will simply print the locations of square before and after calling the mutator methods. Look up the description of the grow method in the API documentation.

G

G

Programming Exercises

T

T

bj4_ch02_8.fm Page 74 Thursday, November 5, 2009 10:47 AM

Review Exercises 75

P2.5 The intersection method computes the intersection of two rectangles—that is, the rectangle that would be formed by two overlapping rectangles if they were drawn:

You call this method as follows: Rectangle r3 = r1.intersection(r2);

Write a program IntersectionPrinter that constructs two rectangle objects, prints them as described in Exercise P2.3, and then prints the rectangle object that describes the intersection. Then the program should print the result of the intersec- tion method when the rectangles do not overlap. Add a comment to your program that explains how you can tell whether the resulting rectangle is empty.

P2.6 In this exercise, you will explore a simple way of visualizing a Rectangle object. The setBounds method of the JFrame class moves a frame window to a given rectangle. Complete the following program to visually show the translate method of the Rect- angle class:

import java.awt.Rectangle; import javax.swing.JFrame; import javax.swing.JOptionPane;

public class TranslateDemo { public static void main(String[] args) { // Construct a frame and show it JFrame frame = new JFrame(); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true);

// Your work goes here: // Construct a rectangle and set the frame bounds

JOptionPane.showMessageDialog(frame, "Click OK to continue");

// Your work goes here: // Move the rectangle and set the frame bounds again } }

P2.7 In the Java library, a color is specified by its red, green, and blue components between 0 and 255 (see Table 4 on page 67). Write a program BrighterDemo that constructs a Color object with red, green, and blue values of 50, 100, and 150. Then apply the

Intersection

bj4_ch02_8.fm Page 75 Thursday, November 5, 2009 10:47 AM

76 Chapter 2 Using Objects

brighter method and print the red, green, and blue values of the resulting color. (You won’t actually see the color—see the next exercise on how to display the color.)

P2.8 Repeat Exercise P2.7, but place your code into the following class. Then the color will be displayed.

import java.awt.Color; import javax.swing.JFrame;

public class BrighterDemo { public static void main(String[] args) { JFrame frame = new JFrame(); frame.setSize(200, 200); Color myColor = ...; frame.getContentPane().setBackground(myColor); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }

P2.9 Repeat Exercise P2.7, but apply the darker method twice to the object Color.RED. Call your class DarkerDemo.

P2.10 The Random class implements a random number generator, which produces sequences of numbers that appear to be random. To generate random integers, you construct an object of the Random class, and then apply the nextInt method. For example, the call generator.nextInt(6) gives you a random number between 0 and 5. Write a program DieSimulator that uses the Random class to simulate the cast of a die, printing a random number between 1 and 6 every time that the program is run.

P2.11 Write a program LotteryPrinter that picks a combination in a lottery. In this lottery, players can choose 6 numbers (possibly repeated) between 1 and 49. (In a real lot- tery, repetitions aren’t allowed, but we haven’t yet discussed the programming con- structs that would be required to deal with that problem.) Your program should print out a sentence such as “Play this combination—it’ll make you rich!”, followed by a lottery combination.

P2.12 Write a program ReplaceTester that encodes a string by replacing all letters "i" with "!" and all letters "s" with "$". Use the replace method. Demonstrate that you can correctly encode the string "Mississippi". Print both the actual and expected result.

P2.13 Write a program HollePrinter that switches the letters "e" and "o" in a string. Use the replace method repeatedly. Demonstrate that the string "Hello, World!" turns into "Holle, Werld!"

P2.14 Write a graphics program that draws your name in red, contained inside a blue rect- angle. Provide a class NameViewer and a class NameComponent.

P2.15 Write a graphics program that draws 12 strings, one each for the 12 standard colors, besides Color.WHITE, each in its own color. Provide a class ColorNameViewer and a class ColorNameComponent.

P2.16 Write a program that draws two solid squares: one in pink and one in purple. Use a standard color for one of them and a custom color for the other. Provide a class TwoSquareViewer and a class TwoSquareComponent.

T

G

G

G

bj4_ch02_8.fm Page 76 Thursday, November 5, 2009 10:47 AM

Programming Projects 77

P2.17 Write a program that fills the window with a large ellipse, with a black outline and filled with your favorite color. The ellipse should touch the window boundaries, even if the window is resized.

P2.18 Write a program to plot the following face.

Provide a class FaceViewer and a class FaceComponent.

Project 2.1 The GregorianCalendar class describes a point in time, as measured by the Gregorian calendar, the standard calendar that is commonly used throughout the world today. You construct a GregorianCalendar object from a year, month, and day of the month, like this:

GregorianCalendar cal = new GregorianCalendar(); // Today’s date GregorianCalendar eckertsBirthday = new GregorianCalendar(1919, Calendar.APRIL, 9);

Use the values Calendar.JANUARY . . . Calendar.DECEMBER to specify the month. The add method can be used to add a number of days to a GregorianCalendar object:

cal.add(Calendar.DAY_OF_MONTH, 10); // Now cal is ten days from today

This is a mutator method—it changes the cal object. The get method can be used to query a given GregorianCalendar object:

int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH); int month = cal.get(Calendar.MONTH); int year = cal.get(Calendar.YEAR); int weekday = cal.get(Calendar.DAY_OF_WEEK); // 1 is Sunday, 2 is Monday, . . . , 7 is Saturday

Your task is to write a program that prints the following information: • The date and weekday that is 100 days from today • The weekday of your birthday • The date that is 10,000 days from your birthday

Use the birthday of a computer scientist if you don’t want to reveal your own birthday.

Project 2.2 Run the following program: import java.awt.Color; import javax.swing.JFrame; import javax.swing.JLabel;

public class FrameViewer { public static void main(String[] args) {

G

G

Programming Projects

bj4_ch02_8.fm Page 77 Thursday, November 5, 2009 10:47 AM

78 Chapter 2 Using Objects

JFrame frame = new JFrame(); frame.setSize(200, 200); JLabel label = new JLabel("Hello, World!"); label.setOpaque(true); label.setBackground(Color.PINK); frame.add(label); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } }

Modify the program as follows: • Double the frame size. • Change the greeting to “Hello, your name!”. • Change the background color to pale green (see Exercise P2.7). • For extra credit, add an image of yourself. (Hint: Construct an ImageIcon.)

1. int and String 2. double 3. An int is not an object, and you cannot call a method on it. 4. (x + y) * 0.5 5. Only the first two are legal identifiers. 6. String myName = "John Q. Public"; 7. No, the left-hand side of the = operator must be a variable. 8. greeting = "Hello, Nina!";

Note that String greeting = "Hello, Nina!";

is not the right answer—that statement declares a new variable. 9. river.length() or "Mississippi".length()

10. System.out.println(greeting.toUpperCase()); or System.out.println("Hello, World!".toUpperCase());

11. It is not legal. The variable river has type String. The println method is not a method of the String class.

12. The implicit parameter is river. There is no explicit parameter. The return value is 11.

13. "Missississi" 14. 12 15. As public String toUpperCase(), with no explicit parameter and return type String. 16. new Rectangle(90, 90, 20, 20) 17. 0 18. An accessor—it doesn’t modify the original string but returns a new string with

uppercase letters.

Answers to Self-Check Questions

bj4_ch02_8.fm Page 78 Thursday, November 5, 2009 10:47 AM

Answers to Self-Check Questions 79

19. box.translate(-5, -10), provided the method is called immediately after storing the new rectangle into box.

20. toLowerCase 21. "Hello, Space !"—only the leading and trailing spaces are trimmed. 22. Add the statement import java.util.Random; at the top of your program. 23. x: 30, y: 25 24. Because the translate method doesn’t modify the shape of the rectangle. 25. Now greeting and greeting2 both refer to the same String object. 26. Both variables still refer to the same string, and the string has not been modified.

Recall that the toUpperCase method constructs a new string that contains uppercase characters, leaving the original string unchanged.

27. Modify the EmptyFrameViewer program as follows: frame.setSize(300, 300); frame.setTitle("Hello, World!");

28. Construct two JFrame objects, set each of their sizes, and call setVisible(true) on each of them.

29. Rectangle box = new Rectangle(5, 10, 20, 20); 30. Replace the call to box.translate(15, 25) with

box = new Rectangle(20, 35, 20, 20);

31. The compiler complains that g doesn’t have a draw method. 32. g2.draw(new Ellipse2D.Double(75, 75, 50, 50)); 33. Line2D.Double segment1 = new Line2D.Double(0, 0, 10, 30);

g2.draw(segment1); Line2D.Double segment2 = new Line2D.Double(10, 30, 20, 0); g2.draw(segment2);

34. g2.drawString("V", 0, 30); 35. 0, 0, 255 36. First fill a big red square, then fill a small yellow square inside:

g2.setColor(Color.RED); g2.fill(new Rectangle(0, 0, 200, 200)); g2.setColor(Color.YELLOW); g2.fill(new Rectangle(50, 50, 100, 100));

bj4_ch02_8.fm Page 79 Thursday, November 5, 2009 10:47 AM

bj4_ch02_8.fm Page 80 Thursday, November 5, 2009 10:47 AM

81

Chapter

3

Implementing Classes

C H A P T E R G O A L S

•

To become familiar with the process of implementing classes

•

To be able to implement simple methods

•

To understand the purpose and use of constructors

•

To understand how to access instance variables and local variables

•

To be able to write javadoc comments

G

To implement classes for drawing graphical shapes

In this chapter, you will learn how to implement your own classes.

You will start with a given design that specifies the public interface of the class—that is, the methods

through which programmers can manipulate the objects of the class. Then you will learn the steps to

completing the class. You need to implement the methods, which requires that you find a data

representation for the objects, and supply the instructions for each method. You need to document

your efforts so that other programmers can understand and use your creation. And you need to

provide a tester to validate that your class works correctly.

bj4_ch03_8.fm Page 81 Thursday, October 22, 2009 8:32 PM

82

CHAPTER CONTENTS

In Chapter 2, you learned how to use objects from existing classes. In this chapter, you will start implementing your own classes. We begin with a very simple example that shows you how objects store their data, and how methods access the data of an object. You will then learn a systematic process for implementing classes.

Our first example is a class that models a

tally counter

, a mechanical device that is used to count people—for example, to find out how many people attend a concert or board a bus (see Figure 1).

Whenever the operator pushes a button, the counter value advances by one. We model this operation with a

count

method. A physical counter has a display to show the current value. In our simulation, we use a

getValue

method instead. For example,

Counter tally = new Counter(); tally.count(); tally.count(); int result = tally.getValue(); //

Sets result to 2

When implementing the

Counter

class, we need to determine the data that each counter object contains. In this simple example, that is very straightforward. Each counter needs to store a variable that keeps track of how many times the counter has been advanced.

3.1 Instance Variables

Figure 1

A Tally Counter

3.1 Instance Variables

82

S

YNTAX

3.1: Instance Variable Declaration

83

3.2 Encapsulation

84

3.3 Specifying the Public Interface of a Class

85

S

YNTAX

3.2: Class Declaration

88

C

OMMON

E

RROR

3.1: Declaring a Constructor

as

void

89

3.4 Commenting the Public Interface

89

P

RODUCTIVITY

H

INT

3.1: The

javadoc

Utility

92

3.5 Providing the Class Implementation

92

S

YNTAX

3.3: Method Declaration

94

H

OW

T

O

3.1: Implementing a Class

96

W

ORKED

E

XAMPLE

3.1: Making a Simple Menu

3.6T Unit Testing

98

3.7 Local Variables

100

C

OMMON

E

RROR

3.2: Forgetting to Initialize Object

References in a Constructor

101

3.8 Implicit Parameters

102

S

PECIAL

T

OPIC

3.1: Calling One Constructor

from Another

104

R

ANDOM

F

ACT

3.1: Electronic Voting Machines

104

3.9G Shape Classes

106

H

OW

T

O

3.2: Drawing Graphical Shapes

110

R

ANDOM

F

ACT

3.2: Computer Graphics

114

bj4_ch03_8.fm Page 82 Thursday, October 22, 2009 8:32 PM

3.1 Instance Variables

83

An object stores its data in

instance variables

. An

instance

of a class is an object of the class. Thus, an instance variable is a storage location that is present in each object of the class.

You specify instance variables in the class declaration:

public class Counter { private int value; . . . }

An instance variable declaration consists of the following parts:

• An

access specifier

(

private

) • The

type

of the instance variable (such as

int

) • The name of the instance variable (such as

value

)

Each object of a class has its own set of instance variables. For example, if

concert-

Counter

and

boardingCounter

are two objects of the

Counter

class, then each object has its own

value

variable (see Figure 2). As you will see in Section 3.7, the instance vari- able

value

is set to 0 when a

Counter

object is constructed. In order to gain a better understanding of how methods affect instance variables,

we will have a quick look at the implementation of the methods of the

Counter

class.

Syntax 3.1

Instance Variable Declaration

accessSpecifier class ClassName { accessSpecifier typeName variableName; . . . }

Syntax

Example public class Counter { private int value; . . . }

Each object of this class

has a separate copy of

this instance variable. Instance variables should

always be private.

Type of the variable

Figure 2

Instance Variables

An object’s instance variables store the data required for executing its methods.

Each object of a class has its own set of instance variables.

concertCounter =

value =

Counter

value =

CounterboardingCounter =

Instance variables

bj4_ch03_8.fm Page 83 Thursday, October 22, 2009 8:32 PM

84

Chapter 3 Implementing Classes

The

count

method advances the counter value by 1. We will cover the syntax of the method header in Section 3.3. For now, focus on the body of the method inside the braces:

public void count() { value = value + 1; }

Note how the

count

method accesses the instance variable

value

.

Which

instance variable? The one belonging to the object on which the method is invoked. For example, consider the call

concertCounter.count();

This call advances the

value

variable of the

concertCounter

object. The

getValue

method returns the current value:

public int getValue() { return value; }

The

return

statement is a special statement that terminates the method call and returns a result to the method’s caller.

Instance variables are generally declared with the access specifier

private

. That specifier means that they can be accessed only by the methods of the

same class

, not by any other method. For example, the

value

variable can be accessed by the

count

and

getValue

methods of the

Counter

class but not a method of another class. Those other methods need to use the

Counter

class methods if they want to manipulate a counter’s value.

In the next section, we discuss the reason for making instance variables private.

1.

Supply the body of a method

public void reset() that resets the counter back to zero.

2. Suppose you use a class Clock with private instance variables hours and minutes. How can you access these variables in your program?

In the preceding section, you learned that you should hide instance variables by making them private. Why would a programmer want to hide something? In this section we discuss the benefits of information hiding.

The strategy of information hiding is not unique to computer programming—it is used in many engineering disciplines. Consider the electronic control module that is present in every modern car. It is a device that controls the timing of the spark plugs and the flow of gasoline into the motor. If you ask your mechanic what is inside the electronic control module, you will likely get a shrug.

The module is a black box, something that magically does its thing. A car mechanic would never open the control module—it contains electronic parts that can only be serviced at the factory. In general, engineers use the term “black box” to describe any device whose inner workings are hidden. Note that a black box is not

Private instance variables can only be accessed by methods of the same class.

S E L F C H E C K

3.2 Encapsulation

bj4_ch03_8.fm Page 84 Thursday, October 22, 2009 8:32 PM

3.3 Specifying the Public Interface of a Class 85

totally mysterious. Its interface with the outside world is well-defined. For exam- ple, the car mechanic understands how the electronic control module must be con- nected with sensors and engine parts.

The process of hiding implementation details while publishing an interface is called encapsulation. In Java, the class construct provides encapsulation. The pub- lic methods of a class are the interface through which the private implementation is manipulated.

Why do car manufacturers put black boxes into cars? The black box greatly sim- plifies the work of the car mechanic. Before engine control modules were invented, gasoline flow was regulated by a mechanical device called a carburetor, and car mechanics had to know how to adjust the springs and latches inside. Nowadays, a mechanic no longer needs to know what is inside the module.

Similarly, a programmer using a class is not burdened by unnecessary detail, as you know from your own experience. In Chapter 2, you used classes for strings, streams, and windows without worrying how these classes are implemented.

Encapsulation also helps with diagnosing errors. A large program may consist of hundreds of classes and thousands of methods, but if there is an error with the internal data of an object, you only need to look at the methods of one class. Finally, encapsulation makes it possible to change the implementation of a class without having to tell the programmers who use the class.

In Chapter 2, you learned to be an object user. You saw how to obtain objects, how to manipulate them, and how to assemble them into a program. In that chapter, your treated objects as black boxes. Your role was roughly analogous to the car mechanic who fixed a car by hooking up a new engine control module.

In this chapter, you will move on to implementing classes. In these sections, your role is analogous to the car parts manufacturer who puts together an engine control module from transistors, capacitors, and other electronic parts. You will learn the necessary Java programming techniques that enable your objects to carry out the desired behavior.

3. Consider the Counter class. A counter’s value starts at 0 and is advanced by the count method, so it should never be negative. Suppose you found a negative value variable during testing. Where would you look for the error?

4. In Chapters 1 and 2, you used System.out as a black box to cause output to appear on the screen. Who designed and implemented System.out?

5. Suppose you are working in a company that produces personal finance soft- ware. You are asked to design and implement a class for representing bank accounts. Who will be the users of your class?

In this section, we will discuss the process of specifying the public interface of a class. Imagine that you are a member of a team that works on banking software. A fundamental concept in banking is a bank account. Your task is to understand the design of a BankAccount class so that you can implement it, which in turn allows other programmers on the team to use it.

Encapsulation is the process of hiding implementation details and providing methods for data access.

Encapsulation allows a programmer to use a class without having to know its implementation.

Information hiding makes it simpler for the implementor of a class to locate errors and change implementations.

S E L F C H E C K

3.3 Specifying the Public Interface of a Class

bj4_ch03_8.fm Page 85 Thursday, October 22, 2009 8:32 PM

86 Chapter 3 Implementing Classes

You need to know exactly what features of a bank account need to be imple- mented. Some features are essential (such as deposits), whereas others are not important (such as the gift that a customer may receive for opening a bank account). Deciding which features are essential is not always an easy task. We will revisit that issue in Chapters 8 and 12. For now, we will assume that a competent designer has decided that the following are considered the essential operations of a bank account:

• Deposit money • Withdraw money • Get the current balance

In Java, operations are expressed as method calls. To figure out the exact specifica- tion of the method calls, imagine how a programmer would carry out the bank account operations. We’ll assume that the variable harrysChecking contains a refer- ence to an object of type BankAccount. We want to support method calls such as the following:

harrysChecking.deposit(2240.59); harrysChecking.withdraw(500); double currentBalance = harrysChecking.getBalance();

The first two methods are mutators. They modify the balance of the bank account and don’t return a value. The third method is an accessor. It returns a value that you store in a variable or pass to a method.

As you can see from the sample calls, the BankAccount class should declare three methods:

• public void deposit(double amount) • public void withdraw(double amount) • public double getBalance()

Recall from Chapter 2 that double denotes the double-precision floating-point type, and void indicates that a method does not return a value.

Here we only give the method headers. When you declare a method, you also need to provide the method body, consisting of statements that are executed when the method is called.

public void deposit(double amount) { implementation—filled in later }

We will supply the method bodies in Section 3.5. Every method header contains the following parts:

• An access specifier (usually public) • The return type (the type of the value returned, such as void or double) • The name of the method (such as deposit) • A list of the parameter variables of the method (if any), enclosed in parentheses

(such as double amount) The access specifier controls which other methods can call this method. Most meth- ods should be declared as public. That way, all other methods in a program can call them. (Occasionally, it can be useful to have private methods. They can only be called from other methods of the same class.)

In order to implement a class, you first need to know which methods are required.

In a method header, you specify the return type, method name, and the types and names of the parameters.

bj4_ch03_8.fm Page 86 Thursday, October 22, 2009 8:32 PM

3.3 Specifying the Public Interface of a Class 87

The return type is the type of the value that the method returns. The deposit method does not return a value, whereas the getBalance method returns a value of type double.

Each parameter of the method has both a type and a name that describes its pur- pose. For example, the deposit method has a single parameter named amount of type double.

Next, you need to supply constructors. A constructor initializes the instance variables of an object. In Java, a constructor is very similar to a method, with two important differences.

• The name of the constructor is always the same as the name of the class (e.g., BankAccount).

• Constructors have no return type (not even void).

We want to construct bank accounts that initially have a zero balance, as well as accounts that have a given initial balance. For this purpose, we specify two con- structors.

• public BankAccount() • public BankAccount(double initialBalance)

They are used as follows: BankAccount harrysChecking = new BankAccount(); BankAccount momsSavings = new BankAccount(5000);

Just like a method, a constructor also has a body—a sequence of statements that is executed when a new object is constructed.

public BankAccount() { implementation—filled in later }

The statements in the constructor body will set the instance variables of the object that is being constructed—see Section 3.5.

Don’t worry about the fact that there are two constructors with the same name— all constructors of a class have the same name, that is, the name of the class. The compiler can tell them apart because they take different parameters.

When declaring a class, you place all constructor and method declarations inside, like this:

public class BankAccount { private instance variables—filled in later

// Constructors public BankAccount() { implementation—filled in later }

public BankAccount(double initialBalance) { implementation—filled in later }

Constructors set the initial data for objects. The constructor name is always the same as the class name.

bj4_ch03_8.fm Page 87 Thursday, October 22, 2009 8:32 PM

88 Chapter 3 Implementing Classes

// Methods public void deposit(double amount) { implementation—filled in later }

public void withdraw(double amount) { implementation—filled in later }

public double getBalance() { implementation—filled in later } }

The public constructors and methods of a class form the public interface of the class. These are the operations that any programmer can use to create and manipu- late BankAccount objects.

Our BankAccount class is simple, but it allows programmers to carry out all of the important operations that commonly occur with bank accounts. For example, con- sider this program segment, authored by a programmer who uses the BankAccount class. These statements transfer an amount of money from one bank account to another:

// Transfer from one account to another double transferAmount = 500; momsSavings.withdraw(transferAmount); harrysChecking.deposit(transferAmount);

And here is a program segment that adds interest to a savings account: double interestRate = 5; // 5% interest double interestAmount = momsSavings.getBalance() * interestRate / 100; momsSavings.deposit(interestAmount);

Syntax 3.2 Class Declaration

accessSpecifier class ClassName { instance variables constructors methods }

Syntax

Example public class Counter { private int value; public Counter(int initialValue) { value = initialValue; }

public void count() { value = value + 1; } public int getValue() { return value; } }

Public interface

Private

implementation

bj4_ch03_8.fm Page 88 Thursday, October 22, 2009 8:32 PM

3.4 Commenting the Public Interface 89

As you can see, programmers can use objects of the BankAccount class to carry out meaningful tasks, without knowing how the BankAccount objects store their data or how the BankAccount methods do their work.

Of course, as implementors of the BankAccount class, we will need to supply the private implementation. We will do so in Section 3.5. First, however, an important step remains: documenting the public interface. That is the topic of the next section.

6. How can you use the methods of the public interface to empty the harrysChecking bank account?

7. What is wrong with this sequence of statements? BankAccount harrysChecking = new BankAccount(10000); System.out.println(harrysChecking.withdraw(500));

8. Suppose you want a more powerful bank account abstraction that keeps track of an account number in addition to the balance. How would you change the public interface to accommodate this enhancement?

Declaring a Constructor as void

Do not use the void reserved word when you declare a constructor:

public void BankAccount() // Error—don’t use void!

This would declare a method with return type void and not a constructor. Unfortunately, the Java compiler does not consider this a syntax error.

When you implement classes and methods, you should get into the habit of thor- oughly commenting their behaviors. In Java there is a very useful standard form for documentation comments. If you use this form in your classes, a program called javadoc can automatically generate a neat set of HTML pages that describe them. (See Productivity Hint 3.1 on page 92 for a description of this utility.)

A documentation comment is placed before the class or method declaration that is being documented. It starts with a /**, a special comment delimiter used by the javadoc utility. Then you describe the method’s purpose. Then, for each method parameter, you supply a line that starts with @param, followed by the parameter name and a short explanation. Finally, you supply a line that starts with @return, describ- ing the return value. You omit the @param tag for methods that have no parameters, and you omit the @return tag for methods whose return type is void.

The javadoc utility copies the first sentence of each comment to a summary table in the HTML documentation. Therefore, it is best to write that first sentence with some care. It should start with an uppercase letter and end with a period. It does not have to be a grammatically complete sentence, but it should be meaningful when it is pulled out of the comment and displayed in a summary.

S E L F C H E C K

Common Error 3.1

3.4 Commenting the Public Interface

Use documentation comments to describe the classes and public methods of your programs.

bj4_ch03_8.fm Page 89 Thursday, October 22, 2009 8:32 PM

90 Chapter 3 Implementing Classes

Here are two typical examples.

/** Withdraws money from the bank account. @param amount the amount to withdraw */ public void withdraw(double amount) { implementation—filled in later }

/** Gets the current balance of the bank account. @return the current balance */ public double getBalance() { implementation—filled in later }

The comments you have just seen explain individual methods. Supply a brief com- ment for each class, explaining its purpose. The comment syntax for class comments is very simple: Just place the documentation comment above the class.

/** A bank account has a balance that can be changed by deposits and withdrawals. */ public class BankAccount { . . . }

Your first reaction may well be “Whoa! Am I supposed to write all this stuff?” These comments do seem pretty repetitive. But you should take the time to write them, even if it feels silly.

It is always a good idea to write the method comment first, before writing the code in the method body. This is an excellent test to see that you firmly understand what you need to program. If you can’t explain what a class or method does, you aren’t ready to implement it.

What about very simple methods? You can easily spend more time pondering whether a comment is too trivial to write than it takes to write it. In practical pro- gramming, very simple methods are rare. It is harmless to have a trivial method overcommented, whereas a complicated method without any comment can cause real grief to future maintenance programmers. According to the standard Java doc- umentation style, every class, every method, every parameter, and every return value should have a comment.

The javadoc utility formats your comments into a neat set of documents that you can view in a web browser. It makes good use of the seemingly repetitive phrases. The first sentence of the comment is used for a summary table of all methods of your class (see Figure 3). The @param and @return comments are neatly formatted in the detail description of each method (see Figure 4). If you omit any of the com- ments, then javadoc generates documents that look strangely empty.

This documentation format should look familiar. The programmers who imple- ment the Java library use javadoc themselves. They too document every class, every

Provide documen- tation comments for every class, every method, every parameter, and every return value.

bj4_ch03_8.fm Page 90 Thursday, October 22, 2009 8:32 PM

3.4 Commenting the Public Interface 91

method, every parameter, and every return value, and then use javadoc to extract the documentation in HTML format.

9. Provide documentation comments for the Counter class of Section 3.1. 10. Suppose we enhance the BankAccount class so that each account has an account

number. Supply a documentation comment for the constructor public BankAccount(int accountNumber, double initialBalance)

11. Why is the following documentation comment questionable? /** Each account has an account number. @return the account number of this account */ public int getAccountNumber()

Figure 3 A Method Summary Generated by javadoc

Figure 4 Method Detail Generated by javadoc

S E L F C H E C K

bj4_ch03_8.fm Page 91 Thursday, October 22, 2009 8:32 PM

92

Chapter 3 Implementing Classes

The

javadoc

Utility

Always insert documentation comments in your code, whether or not you use

javadoc

to produce HTML documentation. Most people find the HTML documentation convenient, so it is worth learning how to run

javadoc

. Some programming environments (such as BlueJ) can execute

javadoc

for you. Alternatively, you can invoke the

javadoc

utility from a shell window, by issuing the command

javadoc MyClass.java

or, if you want to document multiple Java files,

javadoc *.java

The

javadoc

utility produces files such as

MyClass.html

in HTML format, which you can inspect in a browser. If you know HTML (see Appendix F), you can embed HTML tags into the comments to specify fonts or add images. Perhaps most importantly,

javadoc

automati- cally provides

hyperlinks

to other classes and methods. You can run

javadoc

before implementing any methods. Just leave all the method bodies empty. Don’t run the compiler—it would complain about missing return values. Simply run

javadoc

on your file to generate the documentation for the public interface that you are about to implement.

The

javadoc

tool is wonderful because it does one thing right: It allows you to put the documentation

together with your code

. That way, when you update your programs, you can see right away which documentation needs to be updated. Hopefully, you will update it right then and there. Afterward, run

javadoc

again and get updated information that is timely and nicely formatted.

Now that you understand the specification of the public interface of the

BankAccount

class, let’s provide the implementation. First, we need to determine the data that each bank account object contains. In

the case of our simple bank account class, each object needs to store a single value, the current balance. (A more complex bank account class might store additional data—perhaps an account number, the interest rate paid, the date for mailing out the next statement, and so on.)

public class BankAccount { private double balance; . . . }

Now that we have determined the instance variables, let’s complete the

BankAccount

class by supplying the bodies of the constructors and methods. Each body contains a sequence of statements. We’ll start with the constructors because they are very straightforward. A constructor has a simple job: to initialize the instance variables of an object.

Productivity Hint 3.1

3.5 Providing the Class Implementation

The private implementation of a class consists of instance variables, and the bodies of constructors and methods.

bj4_ch03_9.fm Page 92 Thursday, November 5, 2009 11:18 AM

3.5 Providing the Class Implementation 93

Recall that we designed the BankAccount class to have two constructors. The first constructor simply sets the balance to zero:

public BankAccount() { balance = 0; }

The second constructor sets the balance to the value supplied as the construction parameter:

public BankAccount(double initialBalance) { balance = initialBalance; }

To see how these constructors work, let us trace the statement BankAccount harrysChecking = new BankAccount(1000);

one step at a time. Here are the steps that are carried out when the statement executes.

• Create a new object of type BankAccount.

• Call the second constructor (because a parameter value is supplied in the constructor call).

• Set the parameter variable initialBalance to 1000.

• Set the balance instance variable of the newly created object to initialBalance.

• Return an object reference, that is, the memory location of the object, as the value of the new expression.

• Store that object reference in the harrysChecking variable.

Let’s move on to implementing the BankAccount methods. Here is the deposit method: public void deposit(double amount) { balance = balance + amount; }

To understand exactly what the method does, consider this statement: harrysChecking.deposit(500);

This statement carries out the following steps:

• Set the parameter variable amount to 500.

• Fetch the balance instance variable of the object whose location is stored in harrysChecking.

• Add the value of amount to balance

• Store the sum in the balance instance variable, overwriting the old value.

The withdraw method is very similar to the deposit method: public void withdraw(double amount) { balance = balance - amount; }

bj4_ch03_8.fm Page 93 Thursday, October 22, 2009 8:32 PM

94 Chapter 3 Implementing Classes

There is only one method left, getBalance. Unlike the deposit and withdraw methods, which modify the instance variables of the object on which they are invoked, the getBalance method returns a value:

public double getBalance() { return balance; }

We have now completed the implementation of the BankAccount class—see the code listing below. There is only one step remaining: testing that the class works cor- rectly. That is the topic of the next section.

ch03/account/BankAccount.java

Syntax 3.3 Method Declaration

accessSpecifier returnType methodName(parameterType parameterName, . . . ) { method body }

Syntax

Example

public void deposit(double amount) { balance = balance + amount; }

public double getBalance() { return balance; }

These methods

are part of the

public interface.

A mutator method modifies

an instance variable.

An accessor method returns a value.

This method has

no parameters.

This method does

not return a value.

1 /** 2 A bank account has a balance that can be changed by 3 deposits and withdrawals. 4 */ 5 public class BankAccount 6 { 7 private double balance; 8 9 /**

10 Constructs a bank account with a zero balance. 11 */ 12 public BankAccount() 13 { 14 balance = 0; 15 } 16

bj4_ch03_8.fm Page 94 Thursday, October 22, 2009 8:32 PM

3.5 Providing the Class Implementation 95

12. Suppose we modify the BankAccount class so that each bank account has an account number. How does this change affect the instance variables?

13. Why does the following code not succeed in robbing mom’s bank account? public class BankRobber { public static void main(String[] args) { BankAccount momsSavings = new BankAccount(1000); momsSavings.balance = 0; } }

14. The Rectangle class has four instance variables: x, y, width, and height. Give a possible implementation of the getWidth method.

15. Give a possible implementation of the translate method of the Rectangle class.

17 /** 18 Constructs a bank account with a given balance. 19 @param initialBalance the initial balance 20 */ 21 public BankAccount(double initialBalance) 22 { 23 balance = initialBalance; 24 } 25 26 /** 27 Deposits money into the bank account. 28 @param amount the amount to deposit 29 */ 30 public void deposit(double amount) 31 { 32 balance = balance + amount; 33 } 34 35 /** 36 Withdraws money from the bank account. 37 @param amount the amount to withdraw 38 */ 39 public void withdraw(double amount) 40 { 41 balance = balance - amount; 42 } 43 44 /** 45 Gets the current balance of the bank account. 46 @return the current balance 47 */ 48 public double getBalance() 49 { 50 return balance; 51 } 52 }

S E L F C H E C K

bj4_ch03_8.fm Page 95 Thursday, October 22, 2009 8:32 PM

96 Chapter 3 Implementing Classes

HOW TO 3.1 Implementing a Class

This “How To” section tells you how you implement a class from a given specification. For example, a homework assignment might ask you to implement a class that models a

cash register. Your class should allow a cashier to enter item prices and the amount of money that the customer paid. It should then calculate the change due.

Step 1 Find out which methods you are asked to supply.

In the cash register example, you won’t have to provide every feature of a real cash register— there are too many. The assignment tells you, in plain English, which aspects of a cash regis- ter your class should simulate. Make a list of them: • Ring up the sales price for a purchased item. • Enter the amount of payment. • Calculate the amount of change due to the customer.

Step 2 Specify the public interface.

Turn the list in Step 1 into a set of methods, with specific types for the parameters and the return values. Many programmers find this step simpler if they write out method calls that are applied to a sample object, like this:

CashRegister register = new CashRegister(); register.recordPurchase(29.95); register.recordPurchase(9.95); register.enterPayment(50); double change = register.giveChange();

Now we have a specific list of methods. • public void recordPurchase(double amount) • public void enterPayment(double amount) • public double giveChange() To complete the public interface, you need to specify the constructors. Ask yourself what information you need in order to construct an object of your class. Sometimes you will want two constructors: one that sets all instance variables to a default and one that sets them to user-supplied values.

In the case of the cash register example, we can get by with a single constructor that cre- ates an empty register. A more realistic cash register would start out with some coins and bills so that we can give exact change, but that is beyond the scope of our assignment.

Thus, we add a single constructor: • public CashRegister()

Step 3 Document the public interface.

Here is the documentation, with comments, that describes the class and its methods:

/** A cash register totals up sales and computes change due. */ public class CashRegister { /** Constructs a cash register with no money in it. */ public CashRegister() { }

bj4_ch03_8.fm Page 96 Thursday, October 22, 2009 8:32 PM

3.5 Providing the Class Implementation 97

/** Records the sale of an item. @param amount the price of the item */ public void recordPurchase(double amount) { } /** Enters the payment received from the customer. @param amount the amount of the payment */ public void enterPayment(double amount) { } /** Computes the change due and resets the machine for the next customer. @return the change due to the customer */ public double giveChange() { } }

Step 4 Determine instance variables.

Ask yourself what information an object needs to store to do its job. Remember, the meth- ods can be called in any order! The object needs to have enough internal memory to be able to process every method using just its instance variables and the method parameters. Go through each method, perhaps starting with a simple one or an interesting one, and ask your- self what you need to carry out the method’s task. Make instance variables to store the infor- mation that the method needs.

In the cash register example, you would want to keep track of the total purchase amount and the payment. You can compute the change due from these two amounts.

public class CashRegister { private double purchase; private double payment; . . . }

Step 5 Implement constructors and methods.

Implement the constructors and methods in your class, one at a time, starting with the easiest ones. For example, here is the implementation of the recordPurchase method:

public void recordPurchase(double amount) { purchase = purchase + amount; }

Here is the giveChange method. Note that this method is a bit more sophisticated—it com- putes the change due, and it also resets the cash register for the next sale.

public double giveChange() { double change = payment - purchase; purchase = 0; payment = 0; return change; }

bj4_ch03_8.fm Page 97 Thursday, October 22, 2009 8:32 PM

98

Chapter 3 Implementing Classes

Testing Track

Available online in WileyPLUS and at

www.wiley.com/college/horstmann

.

If you find that you have trouble with the implementation, you may need to rethink your choice of instance variables. It is common for a beginner to start out with a set of instance variables that cannot accurately reflect the state of an object. Don’t hesitate to go back and add or modify instance variables.

Once you have completed the implementation, compile your class and fix any compile- time errors.

You can find the complete implementation in the

ch03/cashregister

directory of the book code.

Step 6

Test your class.

Write a short tester program and execute it. The tester program can carry out the method calls that you found in Step 2.

public class CashRegisterTester { public static void main(String[] args) { CashRegister register = new CashRegister();

register.recordPurchase(29.50); register.recordPurchase(9.25); register.enterPayment(50);

double change = register.giveChange();

System.out.println(change); System.out.println("Expected: 11.25"); } }

The output of this test program is:

11.25 Expected: 11.25

Alternatively, if you use a program that lets you test objects interactively, such as BlueJ, con- struct an object and apply the method calls.

Making a Simple Menu

Worked Example 3.1 shows how to implement a class that constructs simple menus.

In the preceding section, we completed the implementation of the

BankAccount

class. What can you do with it? Of course, you can compile the file

BankAccount.java

. However, you can’t

execute

the resulting

BankAccount.class

file. It doesn’t contain a

main

method. That is normal—most classes don’t contain a

main

method. In the long run, your class may become a part of a larger program that interacts

with users, stores data in files, and so on. However, before integrating a class into a program, it is always a good idea to test it in isolation. Testing in isolation, outside a complete program, is called

unit testing

.

Worked Example 3.1

3.6 Unit Testing

A unit test verifies that a class works correctly in isolation, outside a complete program.

bj4_ch03_9.fm Page 98 Thursday, November 5, 2009 11:18 AM

Testing Track 3.6 Unit Testing 99

To test your class, you have two choices. Some interactive development environ- ments have commands for constructing objects and invoking methods (see Special Topic 2.1). Then you can test a class simply by constructing an object, calling meth- ods, and verifying that you get the expected return values. Figure 5 shows the result of calling the getBalance method on a BankAccount object in BlueJ.

Alternatively, you can write a tester class. A tester class is a class with a main method that contains statements to run methods of another class. As discussed in Section 2.9, a tester class typically carries out the following steps:

1. Construct one or more objects of the class that is being tested. 2. Invoke one or more methods. 3. Print out one or more results. 4. Print the expected results.

The MoveTester class in Section 2.9 is a good example of a tester class. That class runs methods of the Rectangle class—a class in the Java library.

Here is a class to run methods of the BankAccount class. The main method con- structs an object of type BankAccount, invokes the deposit and withdraw methods, and then displays the remaining balance on the console.

We also print the value that we expect to see. In our sample program, we deposit $2,000 and withdraw $500. We therefore expect a balance of $1,500.

ch03/account/BankAccountTester.java

Figure 5 The Return Value of the getBalance Method in BlueJ

1 /** 2 A class to test the BankAccount class. 3 */ 4 public class BankAccountTester 5 { 6 /** 7 Tests the methods of the BankAccount class. 8 @param args not used 9 */

10 public static void main(String[] args) 11 {

bj4_ch03_8.fm Page 99 Thursday, October 22, 2009 8:32 PM

100 Chapter 3 Implementing Classes Testing Track

Program Run

To produce a program, you need to combine the BankAccount and the BankAccount- Tester classes. The details for building the program depend on your compiler and development environment. In most environments, you need to carry out these steps:

1. Make a new subfolder for your program. 2. Make two files, one for each class. 3. Compile both files. 4. Run the test program.

Many students are surprised that such a simple program contains two classes. How- ever, this is normal. The two classes have entirely different purposes. The Bank- Account class describes objects that compute bank balances. The BankAccountTester class runs a test that puts a BankAccount object through its paces.

16. When you run the BankAccountTester program, how many objects of class Bank- Account are constructed? How many objects of type BankAccountTester?

17. Why is the BankAccountTester class unnecessary in development environments that allow interactive testing, such as BlueJ?

In this section, we discuss the behavior of local variables. A local variable is a vari- able that is declared in the body of a method. For example, the giveChange method in How To 3.1 on page 96 declares a local variable change:

public double giveChange() { double change = payment - purchase; purchase = 0; payment = 0; return change; }

Parameter variables are similar to local variables, but they are declared in method headers. For example, the following method declares a parameter variable amount:

public void enterPayment(double amount)

12 BankAccount harrysChecking = new BankAccount(); 13 harrysChecking.deposit(2000); 14 harrysChecking.withdraw(500); 15 System.out.println(harrysChecking.getBalance()); 16 System.out.println("Expected: 1500"); 17 } 18 }

1500 Expected: 1500

S E L F C H E C K

3.7 Local Variables Local variables are declared in the body of a method.

A N I M A T I O N Lifetime of Variables

bj4_ch03_8.fm Page 100 Thursday, October 22, 2009 8:32 PM

3.7 Local Variables 101

Local and parameter variables belong to methods. When a method runs, its local and parameter variables come to life. When the method exits, they are removed immediately. For example, if you call register.giveChange(), then a variable change is created. When the method exits, that variable is removed.

In contrast, instance variables belong to objects, not methods. When an object is constructed, its instance variables are created. The instance variables stay alive until no method uses the object any longer. (The Java virtual machine contains an agent called a garbage collector that periodically reclaims objects when they are no longer used.)

An important difference between instance variables and local variables is initial- ization. You must initialize all local variables. If you don’t initialize a local variable, the compiler complains when you try to use it. (Note that parameter variables are initialized when the method is called.)

Instance variables are initialized with a default value before a constructor is invoked. Instance variables that are numbers are initialized to 0. Object references are set to a special value called null. If an object reference is null, then it refers to no object at all. We will discuss the null value in greater detail in Section 5.2.5.

18. What do local variables and parameter variables have in common? In which essential aspect do they differ?

19. Why was it necessary to introduce the local variable change in the giveChange method? That is, why didn’t the method simply end with the statement return payment - purchase;

Forgetting to Initialize Object References in a Constructor

Just as it is a common error to forget to initialize a local variable, it is easy to forget about instance variables. Every constructor needs to ensure that all instance variables are set to appropriate values.

If you do not initialize an instance variable, the Java compiler will initialize it for you. Numbers are initialized with 0, but object references—such as string variables—are set to the null reference.

Of course, 0 is often a convenient default for numbers. However, null is hardly ever a convenient default for objects. Consider this “lazy” constructor for a modified version of the BankAccount class:

public class BankAccount { private double balance; private String owner; . . . public BankAccount(double initialBalance) { balance = initialBalance; } }

Then balance is initialized, but the owner variable is set to a null reference. This can be a prob- lem—it is illegal to call methods on the null reference.

When a method exits, its local variables are removed.

Instance variables are initialized to a default value, but you must initialize local variables.

S E L F C H E C K

Common Error 3.2

bj4_ch03_8.fm Page 101 Thursday, October 22, 2009 8:32 PM

102 Chapter 3 Implementing Classes

To avoid this problem, it is a good idea to initialize every instance variable:

public BankAccount(double initialBalance) { balance = initialBalance; owner = "None"; }

In Section 2.4, you learned that a method has an implicit parameter (the object on which the method is invoked) in addition to the explicit parameters, which are enclosed in parentheses. In this section, we will examine implicit parameters in greater detail.

Have a look at a particular invocation of the deposit method: momsSavings.deposit(500);

Here, the implicit parameter is momsSavings and the explicit parameter is 500. Now look again at the code of the deposit method: public void deposit(double amount) { balance = balance + amount; }

What does balance mean exactly? After all, our program may have multiple Bank- Account objects, and each of them has its own balance.

Of course, since we are depositing the money into momsSavings, balance must mean momsSavings.balance. In general, when you refer to an instance variable inside a method, it means the instance variable of the implicit parameter.

If you need to, you can access the implicit parameter—the object on which the method is called—with the reserved word this. For example, in the preceding method invocation, this refers to the same object as momsSavings (see Figure 6).

The statement balance = balance + amount;

actually means this.balance = this.balance + amount;

3.8 Implicit Parameters

Figure 6 The Implicit Parameter of a Method Call

Use of an instance variable name in a method denotes the instance variable of the implicit parameter.

The this reference denotes the implicit parameter.

momsSavings =

balance =

BankAccount

1000this =

amount = 500

bj4_ch03_8.fm Page 102 Thursday, October 22, 2009 8:32 PM

3.8 Implicit Parameters 103

When you refer to an instance variable in a method, the compiler automatically applies it to the this reference. Some programmers actually prefer to manually insert the this reference before every instance variable because they find it makes the code clearer. Here is an example:

public BankAccount(double initialBalance) { this.balance = initialBalance; }

You may want to try it out and see if you like that style. The this reference can also be used to distinguish between instance variables and

local or parameter variables. Consider the constructor public BankAccount(double balance) { this.balance = balance; }

The expression this.balance clearly refers to the balance instance variable. However, the expression balance by itself seems ambiguous. It could denote either the parame- ter variable or the instance variable. In Java, local and parameter variables are con- sidered first when looking up variable names. Therefore,

this.balance = balance;

means: “Set the instance variable balance to the parameter variable balance”. There is another situation in which it is important to understand the implicit

parameter. Consider the following modification to the BankAccount class. We add a method to apply the monthly account fee:

public class BankAccount { . . . public void monthlyFee() { withdraw(10); // Withdraw $10 from this account } }

That means to withdraw from the same bank account object that is carrying out the monthlyFee operation. In other words, the implicit parameter of the withdraw method is the (invisible) implicit parameter of the monthlyFee method.

If you find it confusing to have an invisible parameter, you can use the this refer- ence to make the method easier to read:

public class BankAccount { . . . public void monthlyFee() { this.withdraw(10); // Withdraw $10 from this account } }

You have now seen how to use objects and implement classes, and you have learned some important technical details about variables and method parameters. The remainder of this chapter continues the optional graphics track. In the next chapter, you will learn more about the most fundamental data types of the Java language.

A method call without an implicit parameter is applied to the same object.

bj4_ch03_8.fm Page 103 Thursday, October 22, 2009 8:32 PM

104 Chapter 3 Implementing Classes

20. How many implicit and explicit parameters does the withdraw method of the BankAccount class have, and what are their names and types?

21. In the deposit method, what is the meaning of this.amount? Or, if the expression has no meaning, why not?

22. How many implicit and explicit parameters does the main method of the Bank- AccountTester class have, and what are they called?

Calling One Constructor from Another

Consider the BankAccount class. It has two constructors: a constructor without parameters to initialize the balance with zero, and another constructor to supply an initial balance. Rather than explicitly setting the balance to zero, one constructor can call another constructor of the same class instead. There is a shorthand notation to achieve this result:

public class BankAccount { public BankAccount (double initialBalance) { balance = initialBalance; }

public BankAccount() { this(0); } . . . }

The command this(0); means “Call another constructor of this class and supply the value 0”. Such a call to another constructor can occur only as the first line in a constructor.

This syntax is a minor convenience. We will not use it in this book. Actually, the use of the reserved word this is a little confusing. Normally, this denotes a reference to the implicit parameter, but if this is followed by parentheses, it denotes a call to another constructor of this class.

Electronic Voting Machines

In the 2000 presidential elections in the United States, votes were tallied by a variety of machines. Some machines processed cardboard “punch card” ballots into which voters punched holes to indicate their choices. When voters were not careful, remains of paper—the now infamous “chads”—were partially stuck in the punch cards, causing votes to be mis- counted. A manual recount was necessary, but it was not carried out everywhere due to time constraints and procedural wrangling. The election was very close, and there remain doubts in the minds of many people whether the election outcome would have been different if the voting machines had accurately counted the intent of the voters.

Subsequently, voting machine manufacturers have argued that electronic voting machines would avoid the problems caused by punch cards or optically scanned forms. In an elec- tronic voting machine, voters indicate their preferences by pressing buttons or touching

S E L F C H E C K

Special Topic 3.1

Random Fact 3.1

bj4_ch03_8.fm Page 104 Thursday, October 22, 2009 8:32 PM

3.8 Implicit Parameters 105

icons on a computer screen. Typically, each voter is presented with a summary screen for review before casting the ballot. The process is very similar to using an automatic bank teller machine.

It seems plausible that these machines make it more likely that a vote is counted in the same way that the voter intends. However, there has been significant controversy surrounding some types of electronic voting machines. If a machine simply records the votes and prints out the totals after the election has been completed, then how do you know that the machine worked correctly? Inside the machine is a computer that executes a program, and, as you may know from your own experience, programs can have bugs.

In fact, some electronic voting machines do have bugs. There have been isolated cases where machines reported tallies that were impossible. When a machine reports far more or far fewer votes than voters, then it is clear that it malfunctioned. Unfortunately, it is then impossible to find out the actual votes. Over time, one would expect these bugs to be fixed in the software. More insidiously, if the results are plausible, nobody may ever investigate.

Many computer scientists have spoken out on this issue and confirmed that it is impossi- ble, with today’s technology, to tell that software is error free and has not been tampered with. Many of them recommend that electronic voting machines should be complemented

Punch Card Ballot

Touch Screen Voting Machine

bj4_ch03_8.fm Page 105 Thursday, October 22, 2009 8:32 PM

106

Chapter 3 Implementing Classes

Graphics Track

by a

voter verifiable audit trail

. (A good source of information is

http://verifiedvoting.org

.) Typically, a voter-verifiable machine prints out the choices that are being tallied. Each voter has a chance to review the printout, and then deposits it in an old-fashioned ballot box. If there is a problem with the electronic equipment, the printouts can be counted by hand.

As this book is written, this concept is strongly resisted both by manufacturers of elec- tronic voting machines and by their customers, the cities and counties that run elections. Manufacturers are reluctant to increase the cost of the machines because they may not be able to pass the cost increase on to their customers, who tend to have tight budgets. Election officials fear problems with malfunctioning printers, and some of them have publicly stated that they actually prefer equipment that eliminates bothersome recounts.

What do you think? You probably use an automatic bank teller machine to get cash from your bank account. Do you review the paper record that the machine issues? Do you check your bank statement? Even if you don’t, do you put your faith in other people who double- check their balances, so that the bank won’t get away with widespread cheating?

Is the integrity of banking equipment more important or less important than that of vot- ing machines? Won’t every voting process have some room for error and fraud anyway? Is the added cost for equipment, paper, and staff time reasonable to combat a potentially slight risk of malfunction and fraud? Computer scientists cannot answer these questions—an informed society must make these tradeoffs. But, like all professionals, they have an obliga- tion to speak out and give accurate testimony about the capabilities and limitations of com- puting equipment.

In this section, we continue the optional graphics track by discussing how to orga- nize complex drawings in a more object-oriented fashion.

When you produce a drawing that is composed of complex parts, such as the one in Figure 7, it is a good idea to make a separate class for each part. Provide a

draw

method that draws the shape, and provide a constructor to set the position of the shape. For example, here is the outline of the

Car

class.

public class Car { public Car(int x, int y) { //

Remember position

. . . }

public void draw(Graphics2D g2) { //

Drawing instructions

. . . } }

You will find the complete class declaration at the end of this section. The

draw

method contains a rather long sequence of instructions for drawing the body, roof, and tires. The coordinates of the car parts seem a bit arbitrary. To come up with suitable values, draw the image on graph paper and read off the coordinates (Figure 8).

3.9 Shape Classes

It is a good idea to make a class for any part of a drawing that can occur more than once.

To figure out how to draw a complex shape, make a sketch on graph paper.

bj4_ch03_9.fm Page 106 Thursday, November 5, 2009 11:19 AM

Graphics Track 3.9 Shape Classes 107

The program that produces Figure 7 is composed of three classes.

• The Car class is responsible for drawing a single car. Two objects of this class are constructed, one for each car.

• The CarComponent class displays the drawing. • The CarViewer class shows a frame that contains a CarComponent.

Let us look more closely at the CarComponent class. The paintComponent method draws two cars. We place one car in the top-left corner of the window, and the other car in the bottom right. To compute the bottom right position, we call the getWidth and getHeight methods of the JComponent class. These methods return the dimensions of

Figure 7 The Car Component Draws Two Car Shapes

Figure 8 Using Graph Paper to Find Shape Coordinates

0

10

20

30

40

0 10 20 30 40 50 60

bj4_ch03_8.fm Page 107 Thursday, October 22, 2009 8:32 PM

108 Chapter 3 Implementing Classes Graphics Track

the component. We subtract the dimensions of the car to determine the position of car2:

Car car1 = new Car(0, 0); int x = getWidth() - 60; int y = getHeight() - 30; Car car2 = new Car(x, y);

Pay close attention to the call to getWidth inside the paintComponent method of CarComponent. The method call has no implicit parameter, which means that the method is applied to the same object that executes the paintComponent method. The component simply obtains its own width.

Run the program and resize the window. Note that the second car always ends up at the bottom-right corner of the window. Whenever the window is resized, the paintComponent method is called and the car position is recomputed, taking the cur- rent component dimensions into account.

ch03/car/CarComponent.java

ch03/car/Car.java

1 import java.awt.Graphics; 2 import java.awt.Graphics2D; 3 import javax.swing.JComponent; 4 5 /** 6 This component draws two car shapes. 7 */ 8 public class CarComponent extends JComponent 9 {

10 public void paintComponent(Graphics g) 11 { 12 Graphics2D g2 = (Graphics2D) g; 13 14 Car car1 = new Car(0, 0); 15 16 int x = getWidth() - 60; 17 int y = getHeight() - 30; 18 19 Car car2 = new Car(x, y); 20 21 car1.draw(g2); 22 car2.draw(g2); 23 } 24 }

1 import java.awt.Graphics2D; 2 import java.awt.Rectangle; 3 import java.awt.geom.Ellipse2D; 4 import java.awt.geom.Line2D; 5 import java.awt.geom.Point2D; 6 7 /** 8 A car shape that can be positioned anywhere on the screen. 9 */

10 public class Car 11 {

bj4_ch03_8.fm Page 108 Thursday, October 22, 2009 8:32 PM

Graphics Track 3.9 Shape Classes 109

12 private int xLeft; 13 private int yTop; 14 15 /** 16 Constructs a car with a given top left corner. 17 @param x the x coordinate of the top left corner 18 @param y the y coordinate of the top left corner 19 */ 20 public Car(int x, int y) 21 { 22 xLeft = x; 23 yTop = y; 24 } 25 26 /** 27 Draws the car. 28 @param g2 the graphics context 29 */ 30 public void draw(Graphics2D g2) 31 { 32 Rectangle body 33 = new Rectangle(xLeft, yTop + 10, 60, 10); 34 Ellipse2D.Double frontTire 35 = new Ellipse2D.Double(xLeft + 10, yTop + 20, 10, 10); 36 Ellipse2D.Double rearTire 37 = new Ellipse2D.Double(xLeft + 40, yTop + 20, 10, 10); 38 39 // The bottom of the front windshield 40 Point2D.Double r1 41 = new Point2D.Double(xLeft + 10, yTop + 10); 42 // The front of the roof 43 Point2D.Double r2 44 = new Point2D.Double(xLeft + 20, yTop); 45 // The rear of the roof 46 Point2D.Double r3 47 = new Point2D.Double(xLeft + 40, yTop); 48 // The bottom of the rear windshield 49 Point2D.Double r4 50 = new Point2D.Double(xLeft + 50, yTop + 10); 51 52 Line2D.Double frontWindshield 53 = new Line2D.Double(r1, r2); 54 Line2D.Double roofTop 55 = new Line2D.Double(r2, r3); 56 Line2D.Double rearWindshield 57 = new Line2D.Double(r3, r4); 58 59 g2.draw(body); 60 g2.draw(frontTire); 61 g2.draw(rearTire); 62 g2.draw(frontWindshield); 63 g2.draw(roofTop); 64 g2.draw(rearWindshield); 65 } 66 }

bj4_ch03_8.fm Page 109 Thursday, October 22, 2009 8:32 PM

110

Chapter 3 Implementing Classes

Graphics Track

ch03/car/CarViewer.java

23.

Which class needs to be modified to have the two cars positioned next to each other?

24.

Which class needs to be modified to have the car tires painted in black, and what modification do you need to make?

25.

How do you make the cars twice as big?

H

OW

T

O

3.2

Drawing Graphical Shapes

You can write programs that display a wide variety of graphical shapes. These instructions give you a step-by-step procedure for decomposing a drawing into parts and implementing a program that produces the drawing. In this How To, we will create a program to draw a national flag.

Step 1

Determine the shapes that you need for the drawing.

You can use the following shapes: • Squares and rectangles • Circles and ellipses • Lines The outlines of these shapes can be drawn in any color, and you can fill the insides of these shapes with any color. You can also use text to label parts of your drawing.

Some national flag designs consist of three equally wide sections of different colors, side by side:

1 import javax.swing.JFrame; 2 3 public class CarViewer 4 { 5 public static void main(String[] args) 6 { 7 JFrame frame = new JFrame(); 8 9 frame.setSize(300, 400);

10 frame.setTitle("Two cars"); 11 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 12 13 CarComponent component = new CarComponent(); 14 frame.add(component); 15 16 frame.setVisible(true); 17 } 18 }

S E L F C H E C K

bj4_ch03_9.fm Page 110 Thursday, November 5, 2009 11:18 AM

Graphics Track 3.9 Shape Classes 111

You could draw such a flag using three rectangles. But if the middle rectangle is white, as it is, for example, in the flag of Italy (green, white, red), it is easier and looks better to draw a line on the top and bottom of the middle portion:

Step 2 Find the coordinates for the shapes.

You now need to find the exact positions for the geometric shapes. • For rectangles, you need the x- and y-position of the top-left corner, the width, and the

height. • For ellipses, you need the top-left corner, width, and height of the bounding rectangle. • For lines, you need the x- and y-positions of the starting point and the end point. • For text, you need the x- and y-position of the basepoint. A commonly-used size for a window is 300 by 300 pixels. You may not want the flag crammed all the way to the top, so perhaps the upper-left corner of the flag should be at point (100, 100).

Many flags, such as the flag of Italy, have a width : height ratio of 3 : 2. (You can often find exact proportions for a particular flag by doing a bit of Internet research on one of several Flags of the World sites.) For example, if you make the flag 90 pixels wide, then it should be 60 pixels tall. (Why not make it 100 pixels wide? Then the height would be 100 · 2 / 3 ≈ 67, which seems more awkward.)

Now you can compute the coordinates of all the important points of the shape:

Step 3 Write Java statements to draw the shapes.

In our example, there are two rectangles and two lines:

Rectangle leftRectangle = new Rectangle(100, 100, 30, 60); Rectangle rightRectangle = new Rectangle(160, 100, 30, 60);

Two rectangles

Two lines

(100, 100) (130, 100) (160, 100) (190, 100)

(100, 160) (130, 160) (160, 160) (190, 160)

bj4_ch03_8.fm Page 111 Thursday, October 22, 2009 8:32 PM

112 Chapter 3 Implementing Classes Graphics Track

Line2D.Double topLine = new Line2D.Double(130, 100, 160, 100); Line2D.Double bottomLine = new Line2D.Double(130, 160, 160, 160);

If you are more ambitious, then you can express the coordinates in terms of a few variables. In the case of the flag, we have arbitrarily chosen the top-left corner and the width. All other coordinates follow from those choices. If you decide to follow the ambitious approach, then the rectangles and lines are determined as follows:

Rectangle leftRectangle = new Rectangle( xLeft, yTop, width / 3, width * 2 / 3); Rectangle rightRectangle = new Rectangle( xLeft + 2 * width / 3, yTop, width / 3, width * 2 / 3); Line2D.Double topLine = new Line2D.Double( xLeft + width / 3, yTop, xLeft + width * 2 / 3, yTop); Line2D.Double bottomLine = new Line2D.Double( xLeft + width / 3, yTop + width * 2 / 3, xLeft + width * 2 / 3, yTop + width * 2 / 3);

Now you need to fill the rectangles and draw the lines. For the flag of Italy, the left rectangle is green and the right rectangle is red. Remember to switch colors before the filling and drawing operations:

g2.setColor(Color.GREEN); g2.fill(leftRectangle); g2.setColor(Color.RED); g2.fill(rightRectangle); g2.setColor(Color.BLACK); g2.draw(topLine); g2.draw(bottomLine);

Step 4 Combine the drawing statements with the component “plumbing”.

public class MyComponent extends JComponent { public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; // Drawing instructions . . . } }

In our example, you can simply add all shapes and drawing instructions inside the paint- Component method:

public class ItalianFlagComponent extends JComponent { public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; Rectangle leftRectangle = new Rectangle(100, 100, 30, 60); . . . g2.setColor(Color.GREEN); g2.fill(leftRectangle); . . . } }

bj4_ch03_8.fm Page 112 Thursday, October 22, 2009 8:32 PM

Graphics Track 3.9 Shape Classes 113

That approach is acceptable for simple drawings, but it is not very object-oriented. After all, a flag is an object. It is better to make a separate class for the flag. Then you can draw differ- ent flags at different positions. Specify the sizes in a constructor and supply a draw method:

public class ItalianFlag { private int xLeft; private int yTop; private int width;

public ItalianFlag(int x, int y, int aWidth) { xLeft = x; yTop = y; width = aWidth; }

public void draw(Graphics2D g2) { Rectangle leftRectangle = new Rectangle( xLeft, yTop, width / 3, width * 2 / 3); . . . g2.setColor(Color.GREEN); g2.fill(leftRectangle); . . . } }

You still need a separate class for the component, but it is very simple:

public class ItalianFlagComponent extends JComponent { public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; ItalianFlag flag = new ItalianFlag(100, 100, 90); flag.draw(g2); } }

Step 5 Write the viewer class.

Provide a viewer class, with a main method in which you construct a frame, add your compo- nent, and make your frame visible. The viewer class is completely routine; you only need to change a single line to show a different component.

public class ItalianFlagViewer { public static void main(String[] args) { JFrame frame = new JFrame();

frame.setSize(300, 400); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

ItalianFlagComponent component = new ItalianFlagComponent(); frame.add(component);

frame.setVisible(true); } }

bj4_ch03_8.fm Page 113 Thursday, October 22, 2009 8:32 PM

114 Chapter 3 Implementing Classes Graphics Track

Computer Graphics

Generating and manipulating visual images is one of the most exciting applications of the computer. We distinguish different kinds of graphics.

Diagrams, such as numeric charts or maps, are artifacts that convey information to the viewer. They do not directly depict anything that occurs in the natural world, but are a tool for visualizing information.

Scenes are computer-generated images that attempt to depict images of the real or an imagined world. It turns out to be quite challenging to render light and shadows accurately. Special effort must be taken so that the images do not look too neat and simple; clouds,

Random Fact 3.2

Diagrams

Scene

bj4_ch03_8.fm Page 114 Thursday, October 22, 2009 8:32 PM

Summary of Learning Objectives 115

rocks, leaves, and dust in the real world have a complex and somewhat random appearance. The degree of realism in these images is constantly improving.

Manipulated Images are photographs or film footage of actual events that have been con- verted to digital form and edited by the computer. For example, film sequences in the movie Apollo 13 were produced by starting from actual images and changing the perspective, show- ing the launch of the rocket from a more dramatic viewpoint.

Computer graphics is one of the most challenging fields in computer science. It requires processing of massive amounts of information at very high speed. New algorithms are con- stantly invented for this purpose. Displaying an overlapping set of three-dimensional objects with curved boundaries requires advanced mathematical tools. Realistic modeling of textures and biological entities requires extensive knowledge of mathematics, physics, and biology.

Understand instance variables and the methods that access them.

• An object’s instance variables store the data required for executing its methods. • Each object of a class has its own set of instance variables. • Private instance variables can only be accessed by methods of the same class.

Explain the concept and benefits of encapsulation.

• Encapsulation is the process of hiding implementation details and providing methods for data access.

• Encapsulation allows a programmer to use a class without having to know its implementation.

• Information hiding makes it simpler for the implementor of a class to locate errors and change implementations.

Manipulated Image

Summary of Learning Objectives

bj4_ch03_8.fm Page 115 Thursday, October 22, 2009 8:32 PM

116 Chapter 3 Implementing Classes

Write method and constructor headers that describe the public interface of a class.

• In order to implement a class, you first need to know which methods are required. • In a method header, you specify the return type, method name, and the types and

names of the parameters. • Constructors set the initial data for objects. The constructor name is always the

same as the class name.

Write class documentation in javadoc format.

• Use documentation comments to describe the classes and public methods of your programs.

• Provide documentation comments for every class, every method, every parameter, and every return value.

Provide the private implementation of a class.

• The private implementation of a class consists of instance variables, and the bodies of constructors and methods.

Write tests that verify that a class works correctly.

• A unit test verifies that a class works correctly in isolation, outside a complete program.

Compare lifetime and initialization of instance, local, and parameter variables.

• Local variables are declared in the body of a method. • When a method exits, its local variables are removed. • Instance variables are initialized to a default value, but you must initialize local

variables.

Recognize the use of the implicit parameter in method declarations.

• Use of an instance variable name in a method denotes the instance variable of the implicit parameter.

• The this reference denotes the implicit parameter. • A method call without an implicit parameter is applied to the same object.

Implement classes that draw graphical shapes.

• It is a good idea to make a class for any part of a drawing that can occur more than once.

• To figure out how to draw a complex shape, make a sketch on graph paper.

• Worked Example Making a Simple Menu • Lab Exercises

Animation Lifetime of Variables Practice Quiz Code Completion Exercises

Media Resources

www.wiley.com/ college/ horstmann

bj4_ch03_8.fm Page 116 Thursday, October 22, 2009 8:32 PM

Review Exercises 117

R3.1 What is the interface of a class? How does it differ from the implementation of a class?

R3.2 What is encapsulation? Why is it useful?

R3.3 Instance variables are a part of the hidden implementation of a class, but they aren’t actually hidden from programmers who have the source code of the class. Explain to what extent the private reserved word provides information hiding.

R3.4 Consider a class Grade that represents a letter grade, such as A+ or B. Give two choices of instance variables that can be used for implementing the Grade class.

R3.5 Consider a class Time that represents a point in time, such as 9 A.M. or 3:30 P.M. Give two different sets of instance variables that can be used for implementing the Time class.

R3.6 Suppose the implementor of the Time class of Exercise R3.5 changes from one imple- mentation strategy to another, keeping the public interface unchanged. What do the programmers who use the Time class need to do?

R3.7 You can read the value instance variable of the Counter class with the getValue acces- sor method. Should there be a setValue mutator method to change it? Explain why or why not.

R3.8 a. Show that the BankAccount(double initialBalance) constructor is not strictly nec- essary. That is, if we removed that constructor from the public interface, how could a programmer still obtain BankAccount objects with an arbitrary balance?

b. Conversely, could we keep only the BankAccount(double initialBalance) con- structor and remove the BankAccount() constructor?

R3.9 Why does the BankAccount class not have a reset method?

R3.10 What happens in our implementation of the BankAccount class when more money is withdrawn from the account than the current balance?

R3.11 What is the this reference? Why would you use it?

R3.12 What does the following method do? Give an example of how you can call the method.

public class BankAccount { public void mystery(BankAccount that, double amount) { this.balance = this.balance - amount; that.balance = that.balance + amount; } . . . // Other bank account methods }

Review Exercises

bj4_ch03_8.fm Page 117 Thursday, October 22, 2009 8:32 PM

118 Chapter 3 Implementing Classes

R3.13 Suppose you want to implement a class TimeDepositAccount. A time deposit account has a fixed interest rate that should be set in the constructor, together with the initial balance. Provide a method to get the current balance. Provide a method to add the earned interest to the account. This method should have no parameters because the interest rate is already known. It should have no return value because you already provided a method for obtaining the current balance. It is not possible to deposit additional funds into this account. Provide a withdraw method that removes the entire balance. Partial withdrawals are not allowed.

R3.14 Consider the following implementation of a class Square: public class Square { private int sideLength; private int area; // Not a good idea

public Square(int length) { sideLength = length; }

public int getArea() { area = sideLength * sideLength; return area; } }

Why is it not a good idea to introduce an instance variable for the area? Rewrite the class so that area is a local variable.

R3.15 Consider the following implementation of a class Square: public class Square { private int sideLength; private int area;

public Square(int initialLength) { sideLength = initialLength; area = sideLength * sideLength; }

public int getArea() { return area; } public void grow() { sideLength = 2 * sideLength(); } }

What error does this class have? How would you fix it?

R3.16 Provide a unit test class for the Counter class in Section 3.1.

R3.17 Read Exercise P3.7, but do not implement the Car class yet. Write a tester class that tests a scenario in which gas is added to the car, the car is driven, more gas is added, and the car is driven again. Print the actual and expected amount of gas in the tank.

R3.18 Suppose you want to extend the car viewer program in Section 3.9 to show a subur- ban scene, with several cars and houses. Which classes do you need?

T

T

G

bj4_ch03_8.fm Page 118 Thursday, October 22, 2009 8:32 PM

Programming Exercises 119

R3.19 Explain why the calls to the getWidth and getHeight methods in the CarComponent class have no explicit parameter.

R3.20 How would you modify the Car class in order to show cars of varying sizes?

P3.1 Write a BankAccountTester class whose main method constructs a bank account, depos- its $1,000, withdraws $500, withdraws another $400, and then prints the remaining balance. Also print the expected result.

P3.2 Add a method public void addInterest(double rate)

to the BankAccount class that adds interest at the given rate. For example, after the statements

BankAccount momsSavings = new BankAccount(1000); momsSavings.addInterest(10); // 10% interest

the balance in momsSavings is $1,100. Also supply a BankAccountTester class that prints the actual and expected balance.

P3.3 Write a class SavingsAccount that is similar to the BankAccount class, except that it has an added instance variable interest. Supply a constructor that sets both the initial balance and the interest rate. Supply a method addInterest (with no explicit parame- ter) that adds interest to the account. Write a SavingsAccountTester class that con- structs a savings account with an initial balance of $1,000 and an interest rate of 10%. Then apply the addInterest method and print the resulting balance. Also com- pute the expected result by hand and print it.

P3.4 Add a feature to the CashRegister class for computing sales tax. The tax rate should be supplied when constructing a CashRegister object. Add recordTaxablePurchase and getTotalTax methods. (Amounts added with recordPurchase are not taxable.) The giveChange method should correctly reflect the sales tax that is charged on taxable items.

P3.5 After closing time, the store manager would like to know how much business was transacted during the day. Modify the CashRegister class to enable this functionality. Supply methods getSalesTotal and getSalesCount to get the total amount of all sales and the number of sales. Supply a method reset that resets any counters and totals so that the next day’s sales start from zero.

P3.6 Implement a class Employee. An employee has a name (a string) and a salary (a dou- ble). Provide a constructor with two parameters

public Employee(String employeeName, double currentSalary)

and methods public String getName() public double getSalary() public void raiseSalary(double byPercent)

G

G

Programming Exercises

T

bj4_ch03_8.fm Page 119 Thursday, October 22, 2009 8:32 PM

120 Chapter 3 Implementing Classes

These methods return the name and salary, and raise the employee’s salary by a cer- tain percentage. Sample usage:

Employee harry = new Employee("Hacker, Harry", 50000); harry.raiseSalary(10); // Harry gets a 10% raise

Supply an EmployeeTester class that tests all methods.

P3.7 Implement a class Car with the following properties. A car has a certain fuel effi- ciency (measured in miles/gallon or liters/km—pick one) and a certain amount of fuel in the gas tank. The efficiency is specified in the constructor, and the initial fuel level is 0. Supply a method drive that simulates driving the car for a certain distance, reducing the amount of gasoline in the fuel tank. Also supply methods getGasInTank, returning the current amount of gasoline in the fuel tank, and addGas, to add gasoline to the fuel tank. Sample usage:

Car myHybrid = new Car(50); // 50 miles per gallon myHybrid.addGas(20); // Tank 20 gallons myHybrid.drive(100); // Drive 100 miles double gasLeft = myHybrid.getGasInTank(); // Get gas remaining in tank

You may assume that the drive method is never called with a distance that consumes more than the available gas. Supply a CarTester class that tests all methods.

P3.8 Implement a class Student. For the purpose of this exercise, a student has a name and a total quiz score. Supply an appropriate constructor and methods getName(), addQuiz(int score), getTotalScore(), and getAverageScore(). To compute the latter, you also need to store the number of quizzes that the student took. Supply a StudentTester class that tests all methods.

P3.9 Implement a class Product. A product has a name and a price, for example new Prod- uct("Toaster", 29.95). Supply methods getName, getPrice, and reducePrice. Supply a program ProductPrinter that makes two products, prints the name and price, reduces their prices by $5.00, and then prints the prices again.

P3.10 Provide a class for authoring a simple letter. In the constructor, supply the names of the sender and the recipient:

public Letter(String from, String to)

Supply a method public void addLine(String line)

to add a line of text to the body of the letter. Supply a method

public String getText()

that returns the entire text of the letter. The text has the form: Dear recipient name: blank line first line of the body second line of the body . . . last line of the body blank line Sincerely, blank line sender name

bj4_ch03_8.fm Page 120 Thursday, October 22, 2009 8:32 PM

Programming Exercises 121

Also supply a class LetterPrinter that prints this letter. Dear John:

I am sorry we must part. I wish you all the best.

Sincerely,

Mary

Construct an object of the Letter class and call addLine twice. Hints: (1) Use the concat method to form a longer string from two shorter strings. (2) The special string "\n" represents a new line. For example, the statement

body = body.concat("Sincerely,").concat("\n");

adds a line containing the string "Sincerely," to the body.

P3.11 Write a class Bug that models a bug moving along a horizontal line. The bug moves either to the right or left. Initially, the bug moves to the right, but it can turn to change its direction. In each move, its position changes by one unit in the current direction. Provide a constructor

public Bug(int initialPosition)

and methods public void turn() public void move() public int getPosition()

Sample usage: Bug bugsy = new Bug(10); bugsy.move(); // now the position is 11 bugsy.turn(); bugsy.move(); // now the position is 10

Your BugTester should construct a bug, make it move and turn a few times, and print the actual and expected position.

P3.12 Implement a class Moth that models a moth flying across a straight line. The moth has a position, the distance from a fixed origin. When the moth moves toward a point of light, its new position is halfway between its old position and the position of the light source. Supply a constructor

public Moth(double initialPosition)

and methods public void moveToLight(double lightPosition) public double getPosition()

Your MothTester should construct a moth, move it toward a couple of light sources, and check that the moth’s position is as expected.

P3.13 Implement a class RoachPopulation that simulates the growth of a roach population. The constructor takes the size of the initial roach population. The breed method simulates a period in which the roaches breed, which doubles their population. The spray method simulates spraying with insecticide, which reduces the population by

bj4_ch03_8.fm Page 121 Thursday, October 22, 2009 8:32 PM

122 Chapter 3 Implementing Classes

10 percent. The getRoaches method returns the current number of roaches. A pro- gram called RoachSimulation simulates a population that starts out with 10 roaches. Breed, spray, and print the roach count. Repeat three more times.

P3.14 Implement a VotingMachine class that can be used for a simple election. Have meth- ods to clear the machine state, to vote for a Democrat, to vote for a Republican, and to get the tallies for both parties. Extra credit if your program gives the nod to your favored party if the votes are tallied after 8 P.M. on the first Tuesday in November, but acts normally on all other dates. (Hint: Use the GregorianCalendar class—see Pro- gramming Project 2.1.)

P3.15 Draw a “bull’s eye”—a set of concentric rings in alternating black and white colors. Hint: Fill a black circle, then fill a smaller white circle on top, and so on.

Your program should be composed of classes BullsEye, BullsEyeComponent, and Bulls- EyeViewer.

P3.16 Write a program that draws a picture of a house. It could be as simple as the accom- panying figure, or if you like, make it more elaborate (3-D, skyscraper, marble col- umns in the entryway, whatever).

Implement a class House and supply a method draw(Graphics2D g2) that draws the house.

P3.17 Extend Exercise P3.16 by supplying a House constructor for specifying the position and size. Then populate your screen with a few houses of different sizes.

P3.18 Change the car viewer program in Section 3.9 to make the cars appear in different colors. Each Car object should store its own color. Supply modified Car and Car- Component classes.

P3.19 Change the Car class so that the size of a car can be specified in the constructor. Change the CarComponent class to make one of the cars appear twice the size of the original example.

P3.20 Write a program to plot the string “HELLO”, using only lines and circles. Do not call drawString, and do not use System.out. Make classes LetterH, LetterE, LetterL, and LetterO.

G

G

G

G

G

G

bj4_ch03_8.fm Page 122 Thursday, October 22, 2009 8:32 PM

Programming Projects 123

P3.21 Write a program that displays the Olympic rings. Color the rings in the Olympic colors.

Provide a class OlympicRingViewer and a class OlympicRingComponent.

P3.22 Make a bar chart to plot the following data set. Label each bar. Make the bars hori- zontal for easier labeling.

Provide a class BarChartViewer and a class BarChartComponent.

Project 3.1 In this project, you will enhance the BankAccount class and see how abstraction and encapsulation enable evolutionary changes to software. Begin with a simple enhancement: charging a fee for every deposit and withdrawal. Supply a mechanism for setting the fee and modify the deposit and withdraw methods so that the fee is levied. Test your resulting class and check that the fee is computed correctly. Now make a more complex change. The bank will allow a fixed number of free transactions (deposits or withdrawals) every month, and charge for transactions exceeding the free allotment. The charge is not levied immediately but at the end of the month. Supply a new method deductMonthlyCharge to the BankAccount class that deducts the monthly charge and resets the transaction count. (Hint: Use Math.max(actual transac- tion count, free transaction count) in your computation.) Produce a test program that verifies that the fees are calculated correctly over sev- eral months.

Project 3.2 In this project, you will explore an object-oriented alternative to the “Hello, World” program in Chapter 1. Begin with a simple Greeter class that has a single method, sayHello. That method should return a string, not print it. Use BlueJ to create two objects of this class and invoke their sayHello methods.

G

G

Bridge Name Longest Span (ft)

Golden Gate 4,200

Brooklyn 1,595

Delaware Memorial 2,150

Mackinac 3,800

Programming Projects

bj4_ch03_8.fm Page 123 Thursday, October 22, 2009 8:32 PM

124 Chapter 3 Implementing Classes

That is boring—of course, both objects return the same answer. Enhance the Greeter class so that each object produces a customized greeting. For example, the object constructed as new Greeter("Dave") should say "Hello, Dave". (Use the concat method to combine strings to form a longer string, or peek ahead at Sec- tion 4.6 to see how you can use the + operator for the same purpose.) Add a method sayGoodbye to the Greeter class. Finally, add a method refuseHelp to the Greeter class. It should return a string such as "I am sorry, Dave. I am afraid I can't do that." Test your class in BlueJ. Make objects that greet the world and Dave, and invoke methods on them.

1. public void reset() { value = 0; }

2. You can only access them by invoking the methods of the Clock class. 3. In one of the methods of the Counter class. 4. The programmers who designed and implemented the Java library. 5. Other programmers who work on the personal finance application. 6. harrysChecking.withdraw(harrysChecking.getBalance()) 7. The withdraw method has return type void. It doesn’t return a value. Use the

getBalance method to obtain the balance after the withdrawal. 8. Add an accountNumber parameter to the constructors, and add a getAccount-

Number method. There is no need for a setAccountNumber method—the account number never changes after construction.

9. /** This class models a tally counter. */ public class Counter { private int value;

/** Gets the current value of this counter. @return the current value */ public int getValue() { return value; }

/** Advances the value of this counter by 1. */ public void count() { value = value + 1;

Answers to Self-Check Questions

bj4_ch03_8.fm Page 124 Thursday, October 22, 2009 8:32 PM

Answers to Self-Check Questions 125

} }

10. /** Constructs a new bank account with a given initial balance. @param accountNumber the account number for this account @param initialBalance the initial balance for this account */

11. The first sentence of the method description should describe the method—it is dis- played in isolation in the summary table.

12. An instance variable private int accountNumber;

needs to be added to the class. 13. Because the balance instance variable is accessed from the main method of BankRobber.

The compiler will report an error because it is not a method of the BankAccount class. 14. public int getWidth()

{ return width; }

15. There is more than one correct answer. One possible implementation is as follows: public void translate(int dx, int dy) { int newx = x + dx; x = newx; int newy = y + dy; y = newy; }

16. One BankAccount object, no BankAccountTester object. The purpose of the BankAccount- Tester class is merely to hold the main method.

17. In those environments, you can issue interactive commands to construct BankAccount objects, invoke methods, and display their return values.

18. Variables of both categories belong to methods—they come alive when the method is called, and they die when the method exits. They differ in their initialization. Parameter variables are initialized with the call values; local variables must be explicitly initialized.

19. After computing the change due, payment and purchase were set to zero. If the method returned payment - purchase, it would always return zero.

20. One implicit parameter, called this, of type BankAccount, and one explicit parameter, called amount, of type double.

21. It is not a legal expression. this is of type BankAccount and the BankAccount class has no instance variable named amount.

22. No implicit parameter—the main method is not invoked on any object—and one explicit parameter, called args.

23. CarComponent 24. In the draw method of the Car class, call

g2.fill(frontTire); g2.fill(rearTire);

25. Double all measurements in the draw method of the Car class.

bj4_ch03_8.fm Page 125 Thursday, October 22, 2009 8:32 PM

bj4_ch03_8.fm Page 126 Thursday, October 22, 2009 8:32 PM

127

Chapter

4

Fundamental Data Types

C H A P T E R G O A L S

•

To understand integer and floating-point numbers

•

To recognize the limitations of the numeric types

•

To become aware of causes for overflow and roundoff errors

•

To understand the proper use of constants

•

To write arithmetic expressions in Java

•

To use the

String

type to manipulate character strings

•

To learn how to read program input and produce formatted output

This chapter teaches how to manipulate numbers and character

strings in Java. The goal of this chapter is to gain a firm understanding of these fundamental data

types in Java.

You will learn about the properties and limitations of the number types in Java. You will see how

to manipulate numbers and strings in your programs. Finally, we cover the important topic of input

and output, which enables you to implement interactive programs.

bj4_ch04_9.fm Page 127 Thursday, October 22, 2009 9:19 PM

128

CHAPTER CONTENTS

In Java, every value is either a reference to an object, or it belongs to one of the eight

primitive types

shown in Table 1. Six of the primitive types are number types; four of them for integers and two for

floating-point numbers. Each of the integer types has a different range—Special Topic 4.2 on page 130

explains why the range limits are related to powers of two. The largest number that can be represented in an

int

is denoted by

Integer

.

MAX_VALUE

. Its value is about 2.14 billion. Similarly,

Integer.MIN_VALUE

is the smallest integer, about –2.14 billion. Generally, you will use the

int

type for integer quantities. However, occasionally, calculations involving integers can

overflow.

This happens if the result of a compu- tation exceeds the range for the number type. For example:

int n = 1000000; System.out.println(n * n); //

Prints –727379968, which is clearly wrong

The product

n * n

is 10

12

, which is larger than the largest integer (about 2 · 10

9

). The result is truncated to fit into an

int

, yielding a value that is completely wrong. Unfortunately, there is no warning when an integer overflow occurs.

If you run into this problem, the simplest remedy is to use the

long

type. Special Topic 4.1 on page 130 shows you how to use the

BigInteger

type in the unlikely event that even the

long

type overflows. Overflow is not usually a problem for double-precision floating-point numbers.

The

double

type has a range of about ±10

308

and about 15 significant digits. How- ever, you want to avoid the

float

type—it has less than 7 significant digits. (Some programmers use

float

to save on memory if they need to store a huge set of num- bers that do not require much precision.)

4.1 Number Types Java has eight primitive types, including four integer types and two floating- point types.

A numeric computation overflows if the result falls outside the range for the number type.

4.1 Number Types

128

S

PECIAL

T

OPIC

4.1: Big Numbers

130

S

PECIAL

T

OPIC

4.2: Binary Numbers

130

R

ANDOM

F

ACT

4.1: The Pentium Floating-

Point Bug

132

4.2 Constants

133

S

YNTAX

4.1: Constant Declaration

134

Q

UALITY

T

IP

4.1: Do Not Use Magic Numbers

137

4.3 Arithmetic Operations and Mathematical Functions

137

S

YNTAX

4.2: Cast

140

C

OMMON

E

RROR

4.1: Integer Division

142

C

OMMON

E

RROR

4.2: Unbalanced Parentheses

143

Q

UALITY

T

IP

4.2: White Space

144

Q

UALITY

T

IP

4.3: Factor Out Common Code

144

C

OMMON

E

RROR

4.3: Roundoff Errors

144

S

PECIAL

T

OPIC

4.3: Combining Assignment

and Arithmetic

145

4.4 Calling Static Methods

145

S

YNTAX

4.3: Static Method Call

146

H

OW

T

O

4.1: Carrying Out Computations

146

W

ORKED

E

XAMPLE

4.1: Computing the Volume and

Surface Area of a Pyramid

4.5 Strings

149

P

RODUCTIVITY

H

INT

4.1: Reading Exception Reports

152

S

PECIAL

T

OPIC

4.4: Escape Sequences

152

S

PECIAL

T

OPIC

4.5: Strings and the

char

Type

153

R

ANDOM

F

ACT

4.2: International Alphabets

154

4.6 Reading Input

155

W

ORKED

E

XAMPLE

4.2: Extracting Initials

S

PECIAL

T

OPIC

4.6: Formatting Numbers

158

S

PECIAL

T

OPIC

4.7: Using Dialog Boxes for Input

and Output

159

bj4_ch04_9.fm Page 128 Thursday, October 22, 2009 9:19 PM

4.1 Number Types

129

Rounding errors

are a more serious issue with floating-point values. Rounding errors can occur when you convert between binary and decimal numbers, or between integers and floating-point numbers. When a value cannot be converted exactly, it is rounded to the nearest match. Consider this example:

double f = 4.35; System.out.println(100 * f); //

Prints 434.99999999999994

This problem is caused because computers represent numbers in the binary number system. In the binary number system, there is no exact representation of the frac- tion 1/10, just as there is no exact representation of the fraction 1/3

=

0.33333 in the decimal number system. (See Special Topic 4.2 on page 130 for more information.)

For this reason, the

double

type is not appropriate for financial calculations. In this book, we will continue to use

double values for bank balances and other finan- cial quantities so that we keep our programs as simple as possible. However, professional programs need to use the BigDecimal type for this purpose—see Special Topic 4.1 on page 130.

In Java, it is legal to assign an integer value to a floating-point variable: int dollars = 100; double balance = dollars; // OK

But the opposite assignment is an error: You cannot assign a floating-point expres- sion to an integer variable.

double balance = 13.75; int dollars = balance; // Error

You will see in Section 4.3.5 how to convert a value of type double into an integer.

Table 1 Primitive Types

Type Description Size

int The integer type, with range –2,147,483,648 (Integer.MIN_VALUE) . . . 2,147,483,647

(Integer.MAX_VALUE, about 2.14 billion)

4 bytes

byte The type describing a single byte, with range –128 . . . 127 1 byte

short The short integer type, with range –32,768 . . . 32,767 2 bytes

long The long integer type, with range –9,223,372,036,854,775,808 . . . 9,223,372,036,854,775,807

8 bytes

double The double-precision floating-point type, with a range of about ±10308 and about 15 significant decimal digits

8 bytes

float The single-precision floating-point type, with a range of about ±1038 and about 7 significant decimal digits

4 bytes

char The character type, representing code units in the Unicode encoding scheme (see Special Topic 4.5 on page 153)

2 bytes

boolean The type with the two truth values false and true (see Chapter 5) 1 bit

Rounding errors occur when an exact conversion between numbers is not possible.

bj4_ch04_9.fm Page 129 Thursday, October 22, 2009 9:19 PM

130 Chapter 4 Fundamental Data Types

1. Which are the most commonly used number types in Java? 2. Suppose you want to write a program that works with population data from

various countries. Which Java data type should you use? 3. Which of the following initializations are incorrect, and why?

a. int dollars = 100.0; b. double balance = 100;

Big Numbers

If you want to compute with really large numbers, you can use big number objects. Big number objects are objects of the BigInteger and BigDecimal classes in the java.math package. Unlike the number types such as int or double, big number objects have essentially no limits on their size and precision. However, computations with big number objects are much slower than those that involve number types. Perhaps more importantly, you can’t use the familiar arithmetic operators such as (+ - *) with them. Instead, you have to use methods called add, subtract, and multiply. Here is an example of how to create a BigInteger object and how to call the multiply method.

BigInteger n = new BigInteger("1000000"); BigInteger r = n.multiply(n); System.out.println(r); // Prints 1000000000000

The BigDecimal type carries out floating-point computation without roundoff errors. For example,

BigDecimal d = new BigDecimal("4.35"); BigDecimal e = new BigDecimal("100"); BigDecimal f = d.multiply(e); System.out.println(f); // Prints 435.00

Binary Numbers

You are familiar with decimal numbers, which use the digits 0, 1, 2, . . . , 9. Each digit has a place value of 1, 10, 100 = 102, 1000 = 103, and so on. For example,

435 = 4 · 102 + 3 · 101 + 5 · 100 Fractional digits have place values with negative powers of ten: 0.1 = 10–1, 0.01 = 10–2, and so on. For example,

4.35 = 4 · 100 + 3 · 10–1 + 5 · 10–2 Computers use binary numbers instead, which have just two digits (0 and 1) and place values that are powers of 2. Binary numbers are easier for computers to manipulate, because it is easier to build logic circuits that differentiate between “off” and “on” than it is to build cir- cuits that can accurately tell ten different voltage levels apart.

It is easy to transform a binary number into a decimal number. Just compute the powers of two that correspond to ones in the binary number. For example,

1101 binary = 1 · 23 + 1 · 22 + 0 · 21 + 1 · 20 = 8 + 4 + 1 = 13 Fractional binary numbers use negative powers of two. For example,

1.101 binary = 1 · 20 + 1 · 2–1 + 0 · 2–2 + 1 · 2–3 = 1 + 0.5 + 0.125 = 1.625

S E L F C H E C K

Special Topic 4.1

Special Topic 4.2

bj4_ch04_9.fm Page 130 Thursday, October 22, 2009 9:19 PM

4.1 Number Types 131

Converting decimal numbers to binary numbers is a little trickier. Here is an algorithm that converts a decimal integer into its binary equivalent: Keep dividing the integer by 2, keeping track of the remainders. Stop when the number is 0. Then write the remainders as a binary number, starting with the last one. For example,

100 ÷ 2 = 50 remainder 0 50 ÷ 2 = 25 remainder 0 25 ÷ 2 = 12 remainder 1 12 ÷ 2 = 6 remainder 0 6 ÷ 2 = 3 remainder 0 3 ÷ 2 = 1 remainder 1 1 ÷ 2 = 0 remainder 1

Therefore, 100 in decimal is 1100100 in binary. To convert a fractional number < 1 to its binary format, keep multiplying by 2. If the

result is >1, subtract 1. Stop when the number is 0. Then use the digits before the decimal points as the binary digits of the fractional part, starting with the first one. For example,

0.35 · 2 = 0.7 0.7 · 2 = 1.4 0.4 · 2 = 0.8 0.8 · 2 = 1.6 0.6 · 2 = 1.2 0.2 · 2 = 0.4

Here the pattern repeats. That is, the binary representation of 0.35 is 0.01 0110 0110 0110 . . . To convert any floating-point number into binary, convert the whole part and the frac-

tional part separately. For example, 4.35 is 100.01 0110 0110 0110 . . . in binary. You don’t actually need to know about binary numbers to program in Java, but at times it

can be helpful to understand a little about them. For example, knowing that an int is repre- sented as a 32-bit binary number explains why the largest integer that you can represent in Java is 0111 1111 1111 1111 1111 1111 1111 1111 binary = 2,147,483,647 decimal. (The first bit is the sign bit. It is off for positive values.)

To convert an integer into its binary representation, you can use the static toString method of the Integer class. The call Integer.toString(n, 2) returns a string with the binary digits of the integer n. Conversely, you can convert a string containing binary digits into an integer with the call Integer.parseInt(digitString, 2). In both of these method calls, the sec- ond parameter denotes the base of the number system. It can be any number between 0 and 36. You can use these two methods to convert between decimal and binary integers. How- ever, the Java library has no convenient method to do the same for floating-point numbers.

Now you can see why we had to fight with a roundoff error when computing 100 times 4.35. If you actually carry out the long multiplication, you get:

1 1 0 0 1 0 0 * 1 0 0.0 1|0 1 1 0|0 1 1 0|0 1 1 0 . . .

1 0 0.0 1|0 1 1 0|0 1 1 0|0 1 1 0 . . . 1 0 0.0 1|0 1 1 0|0 1 1 0|0 1 1 . . . 0 0 1 0 0.0 1|0 1 1 0|0 1 1 0 . . . 0 0 _____________________________________ 1 1 0 1 1 0 0 1 0.1 1 1 1 1 1 1 1 . . .

bj4_ch04_9.fm Page 131 Thursday, October 22, 2009 9:19 PM

132 Chapter 4 Fundamental Data Types

That is, the result is 434, followed by an infinite number of 1s. The fractional part of the product is the binary equivalent of an infinite decimal fraction 0.999999 . . . , which is equal to 1. But the CPU can store only a finite number of 1s, and it discards some of them when converting the result to a decimal number.

The Pentium Floating-Point Bug

In 1994, Intel Corporation released what was then its most powerful processor, the first of the Pentium series. Unlike previous generations of Intel’s processors, the Pentium had a built-in floating-point unit. Intel’s goal was to compete aggressively with the makers of higher-end processors for engineering workstations. The Pentium was an immediate success.

In the summer of 1994, Dr. Thomas Nicely of Lynchburg College in Virginia ran an extensive set of computations to analyze the sums of reciprocals of certain sequences of prime numbers. The results were not always what his theory predicted, even after he took into account the inevitable roundoff errors. Then Dr. Nicely noted that the same program did produce the correct results when run on the slower 486 processor, which preceded the Pentium in Intel’s lineup. This should not have happened. The roundoff behavior of floating- point calculations had been standardized by the Institute of Electrical and Electronics Engi- neers (IEEE), and Intel claimed to adhere to the IEEE standard in both the 486 and the Pen- tium processors. Upon further checking, Dr. Nicely discovered that indeed there was a very small set of numbers for which the product of two numbers was computed differently on the two processors. For example,

4,195,835 = ((4,195,835 / 3,145,727) × 3,145,727) is mathematically equal to 0, and it did compute as 0 on a 486 processor. On a Pentium pro- cessor, however, the result was 256.

As it turned out, Intel had independently discovered the bug in its testing and had started to produce chips that fixed it. (Subsequent versions of the Pentium, such as the Pentium III and IV, are free of the problem.) The bug was caused by an error in a table that was used to

This graph shows a set of numbers for which the original Pentium processor obtained the wrong quotient.

Random Fact 4.1

1 .4

0

1 .2

0

1 .0

0

0 .8

0

0 .6

0

0 .4

0

0 .2

0

0 .0

0

-0 .2

0

-0 .4

0

-0 .6

0

-0 .8

0

-1 .0

0

-1 .2

0

-1 .4

0

-1 .6

0

-1 .8

0

-2 .0

0

1.40

1.10

0.80

0.50

0.20

-0.10

-0.40

-0.70 -1.00

-1.30

1.333680000

1.333700000

1.333720000

1.333740000

1.333760000

1.333780000

1.333800000

1.333820000

1.333840000

x /y

4195835+

3145727+

Pentium FDIV error

bj4_ch04_9.fm Page 132 Thursday, October 22, 2009 9:19 PM

4.2 Constants

133

speed up the floating-point multiplication algorithm of the processor. Intel determined that the problem was exceedingly rare. They claimed that under normal use a typical consumer would only notice the problem once every 27,000 years. Unfortunately for Intel, Dr. Nicely had not been a normal user.

Now Intel had a real problem on its hands. It figured that replacing all the Pentium pro- cessors that it had already sold would cost it a great deal of money. Intel already had more orders for the chip than it could produce, and it would be particularly galling to have to give out the scarce chips as free replacements instead of selling them. Initially, Intel’s management offered to replace the processors only for those customers who could prove that their work required absolute precision in mathematical calculations. Naturally, that did not go over well with the hundreds of thousands of customers who had paid retail prices of $700 and more for a Pentium chip and did not want to live with the nagging feeling that perhaps, one day, their income tax program would produce a faulty return. In the end, Intel gave in to public demand and replaced the defective chips, at a cost of about 475 million dollars.

In many programs, you need to use numerical

constants

—values that do not change and that have a special significance for a computation.

A typical example for the use of constants is a computation that involves coin values, such as the following:

payment = dollars + quarters * 0.25 + dimes * 0.1 + nickels * 0.05 + pennies * 0.01;

Most of the code is self-documenting. However, the four numeric quantities, 0.25, 0.1, 0.05, and 0.01 are included in the arithmetic expression without any explana- tion. Of course, in this case, you know that the value of a nickel is five cents, which explains the 0.05, and so on. However, the next person who needs to maintain this code may live in another country and may not know that a nickel is worth five cents.

Thus, it is a good idea to use symbolic names for all values, even those that appear obvious. Here is a clearer version of the computation of the total:

double quarterValue = 0.25; double dimeValue = 0.1; double nickelValue = 0.05; double pennyValue = 0.01; payment = dollars + quarters * quarterValue + dimes * dimeValue + nickels * nickelValue + pennies * pennyValue;

There is another improvement we can make. There is a difference between the

nick-

els

and

nickelValue

variables. The

nickels

variable can truly vary over the life of the program, as we calculate different payments. But

nickelValue

is always 0.05. In Java, constants are identified with the reserved word

final

. A variable tagged as

final

can never change after it has been set. If you try to change the value of a

final

variable, the compiler will report an error and your program will not compile. Many programmers use all-uppercase names for constants (

final

variables), such as

NICKEL_VALUE

. That way, it is easy to distinguish between variables (with mostly lowercase letters) and constants. We will follow this convention in this book. How- ever, this rule is a matter of good style, not a requirement of the Java language. The compiler will not complain if you give a

final

variable a name with lowercase letters.

4.2 Constants

A final variable is a constant. Once its value has been set, it cannot be changed.

bj4_ch04_9.fm Page 133 Thursday, November 5, 2009 11:35 AM

134

Chapter 4 Fundamental Data Types

Here is an improved version of the code that computes the value of a payment.

final double QUARTER_VALUE = 0.25; final double DIME_VALUE = 0.1; final double NICKEL_VALUE = 0.05; final double PENNY_VALUE = 0.01; payment = dollars + quarters * QUARTER_VALUE + dimes * DIME_VALUE + nickels * NICKEL_VALUE + pennies * PENNY_VALUE;

Frequently, constant values are needed in several methods. Then you should declare them together with the instance variables of a class and tag them as

static

and

final

. As before,

final

indicates that the value is a constant. The

static

reserved word means that the constant belongs to the class—this is explained in greater detail in Chapter 8.)

public class CashRegister { //

Constants

public static final double QUARTER_VALUE = 0.25; public static final double DIME_VALUE = 0.1; public static final double NICKEL_VALUE = 0.05; public static final double PENNY_VALUE = 0.01;

//

Instance variables

private double purchase; private double payment;

//

Methods

. . . }

We declared the constants as

public

. There is no danger in doing this because con- stants cannot be modified. Methods of other classes can access a public constant by first specifying the name of the class in which it is declared, then a period, then the name of the constant, such as

CashRegister.NICKEL_VALUE

.

Use named constants to make your programs easier to read and maintain.

Syntax 4.1

Constant Declaration

Syntax

Example

final double NICKEL_VALUE = 0.05;

public static final double LITERS_PER_GALLON = 3.785;

The final reserved word

indicates that this

value cannot

be modified.

Declared in a class

Declared in a method: final typeName variableName = expression;

Declared in a class: accessSpecifier static final typeName variableName = expression;

Use uppercase letters for constants.

Declared in a method

bj4_ch04_9.fm Page 134 Thursday, November 5, 2009 11:35 AM

4.2 Constants 135

The Math class from the standard library declares a couple of useful constants: public class Math { . . . public static final double E = 2.7182818284590452354; public static final double PI = 3.14159265358979323846; }

You can refer to these constants as Math.PI and Math.E in any of your methods. For example,

double circumference = Math.PI * diameter;

The sample program at the end of this section puts constants to work. The program shows a refinement of the CashRegister class of How To 3.1. The public interface of that class has been modified in order to solve a common business problem.

Busy cashiers sometimes make mistakes totaling up coin values. Our Cash- Register class features a method whose inputs are the coin counts. For example, the call

register.enterPayment(1, 2, 1, 1, 4);

enters a payment consisting of one dollar, two quarters, one dime, one nickel, and four pennies. The enterPayment method figures out the total value of the payment, $1.69. As you can see from the code listing, the method uses named constants for the coin values.

ch04/cashregister/CashRegister.java

1 /** 2 A cash register totals up sales and computes change due. 3 */ 4 public class CashRegister 5 { 6 public static final double QUARTER_VALUE = 0.25; 7 public static final double DIME_VALUE = 0.1; 8 public static final double NICKEL_VALUE = 0.05; 9 public static final double PENNY_VALUE = 0.01;

10 11 private double purchase; 12 private double payment; 13 14 /** 15 Constructs a cash register with no money in it. 16 */ 17 public CashRegister() 18 { 19 purchase = 0; 20 payment = 0; 21 } 22 23 /** 24 Records the purchase price of an item. 25 @param amount the price of the purchased item 26 */ 27 public void recordPurchase(double amount) 28 { 29 purchase = purchase + amount;

bj4_ch04_9.fm Page 135 Thursday, October 22, 2009 9:19 PM

136 Chapter 4 Fundamental Data Types

ch04/cashregister/CashRegisterTester.java

30 } 31 32 /** 33 Enters the payment received from the customer. 34 @param dollars the number of dollars in the payment 35 @param quarters the number of quarters in the payment 36 @param dimes the number of dimes in the payment 37 @param nickels the number of nickels in the payment 38 @param pennies the number of pennies in the payment 39 */ 40 public void enterPayment(int dollars, int quarters, 41 int dimes, int nickels, int pennies) 42 { 43 payment = dollars + quarters * QUARTER_VALUE + dimes * DIME_VALUE 44 + nickels * NICKEL_VALUE + pennies * PENNY_VALUE; 45 } 46 47 /** 48 Computes the change due and resets the machine for the next customer. 49 @return the change due to the customer 50 */ 51 public double giveChange() 52 { 53 double change = payment - purchase; 54 purchase = 0; 55 payment = 0; 56 return change; 57 } 58 }

1 /** 2 This class tests the CashRegister class. 3 */ 4 public class CashRegisterTester 5 { 6 public static void main(String[] args) 7 { 8 CashRegister register = new CashRegister(); 9

10 register.recordPurchase(0.75); 11 register.recordPurchase(1.50); 12 register.enterPayment(2, 0, 5, 0, 0); 13 System.out.print("Change: "); 14 System.out.println(register.giveChange()); 15 System.out.println("Expected: 0.25"); 16 17 register.recordPurchase(2.25); 18 register.recordPurchase(19.25); 19 register.enterPayment(23, 2, 0, 0, 0); 20 System.out.print("Change: "); 21 System.out.println(register.giveChange()); 22 System.out.println("Expected: 2.0"); 23 } 24 }

bj4_ch04_9.fm Page 136 Thursday, October 22, 2009 9:19 PM

4.3 Arithmetic Operations and Mathematical Functions 137

Program Run

4. What is the difference between the following two statements? final double CM_PER_INCH = 2.54;

and public static final double CM_PER_INCH = 2.54;

5. What is wrong with the following statement sequence? double diameter = . . .; double circumference = 3.14 * diameter;

Do Not Use Magic Numbers

A magic number is a numeric constant that appears in your code without explanation. For example, consider the following scary example that actually occurs in the Java library source:

h = 31 * h + ch;

Why 31? The number of days in January? One less than the number of bits in an integer? Actually, this code computes a “hash code” from a string—a number that is derived from the characters in such a way that different strings are likely to yield different hash codes. The value 31 turns out to scramble the character values nicely.

A better solution is to use a named constant:

final int HASH_MULTIPLIER = 31; h = HASH_MULTIPLIER * h + ch;

You should never use magic numbers in your code. Any number that is not completely self- explanatory should be declared as a named constant. Even the most reasonable cosmic con- stant is going to change one day. You think there are 365 days in a year? Your customers on Mars are going to be pretty unhappy about your silly prejudice. Make a constant

final int DAYS_PER_YEAR = 365;

By the way, the device

final int THREE_HUNDRED_AND_SIXTY_FIVE = 365;

is counterproductive and frowned upon.

In the following sections, you will learn how to carry out arithmetic calculations in Java.

Change: 0.25 Expected: 0.25 Change: 2.0 Expected: 2.0

S E L F C H E C K

Quality Tip 4.1

4.3 Arithmetic Operations and Mathematical Functions

bj4_ch04_9.fm Page 137 Thursday, October 22, 2009 9:19 PM

138 Chapter 4 Fundamental Data Types

Java supports the same four basic arithmetic operations as a calculator—addition, subtraction, multiplication, and division. As you have already seen, addition and subtraction use the familiar + and - operators, and the * operator denotes multiplica- tion. Division is indicated with a /, not a fraction bar. For example,

becomes (a + b) / 2

Parentheses are used just as in algebra: to indicate in which order the subexpressions should be computed. For example, in the expression (a + b) / 2, the sum a + b is computed first, and then the sum is divided by 2. In contrast, in the expression

a + b / 2

only b is divided by 2, and then the sum of a and b / 2 is formed. Just as in regular algebraic notation, multiplication and division bind more strongly than addition and subtraction. For example, in the expression a + b / 2, the / is carried out first, even though the + operation occurs farther to the left.

Incrementing a value by 1 is so common when writing programs that there is a spe- cial shorthand for it, namely

items++;

This statement adds 1 to items. It is easier to type and read than the equivalent assignment statement

items = items + 1;

As you might have guessed, there is also a decrement operator --. The statement items--;

subtracts 1 from items.

Figure 1 Incrementing a Variable

4.3.1 Arithmetic Operators

a b+ 2

4.3.2 Increment and Decrement

The ++ and -- operators increment and decrement a variable.

items =

items + 1

bj4_ch04_9.fm Page 138 Thursday, October 22, 2009 9:19 PM

4.3 Arithmetic Operations and Mathematical Functions 139

Division works as you would expect, as long as at least one of the numbers involved is a floating-point number. That is,

7.0 / 4.0 7 / 4.0 7.0 / 4

all yield 1.75. However, if both numbers are integers, then the result of the division is always an integer, with the remainder discarded. That is,

7 / 4

evaluates to 1, because 7 divided by 4 is 1 with a remainder of 3 (which is discarded). Discarding the remainder is often useful, but it can also be a source of subtle pro- gramming errors—see Common Error 4.1 on page 142.

If you are interested only in the remainder of an integer division, use the % opera- tor:

7 % 4

is 3, the remainder of the integer division of 7 by 4. The % symbol has no analog in algebra. It was chosen because it looks similar to /, and the remainder operation is related to division.

Here is a typical use for the integer / and % operations. Suppose you want to know how much change a cash register should give, using separate values for dollars and cents. You can compute the value as an integer, denominated in cents, and then compute the whole dollar amount and the remaining change:

final int PENNIES_PER_NICKEL = 5; final int PENNIES_PER_DIME = 10; final int PENNIES_PER_QUARTER = 25; final int PENNIES_PER_DOLLAR = 100;

// Compute total value in pennies int total = dollars * PENNIES_PER_DOLLAR + quarters * PENNIES_PER_QUARTER + nickels * PENNIES_PER_NICKEL + dimes * PENNIES_PER_DIME + pennies;

// Use integer division to convert to dollars, cents int dollars = total / PENNIES_PER_DOLLAR; int cents = total % PENNIES_PER_DOLLAR;

For example, if total is 243, then dollars is set to 2 and cents to 43.

To compute xn, you write Math.pow(x, n). However, to compute x2 it is significantly more efficient simply to compute x * x.

To take the square root of a number, you use the Math.sqrt method. For example, is written as Math.sqrt(x).

In algebra, you use fractions, superscripts for exponents, and radical signs for roots to arrange expressions in a compact two-dimensional form. In Java, you have to write all expressions in a linear arrangement.

4.3.3 Integer Division

If both arguments of the / operator are integers, the result is an integer and the remainder is discarded.

The % operator computes the remainder of a division.

4.3.4 Powers and Roots

The Math class contains methods sqrt and pow to compute square roots and powers. x

bj4_ch04_9.fm Page 139 Thursday, October 22, 2009 9:19 PM

140 Chapter 4 Fundamental Data Types

For example, the subexpression

of the quadratic formula becomes (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a)

Figure 2 shows how to analyze such an expression. With complicated expressions like these, it is not always easy to keep the parentheses ( ) matched—see Common Error 4.2 on page 143.

Table 2 shows additional methods of the Math class. Inputs and outputs are floating-point numbers.

Occasionally, you have a value of type double that you need to convert to the type int. Use the cast operator (int) for this purpose. You write the cast operator before the expression that you want to convert:

double balance = total + tax; int dollars = (int) balance;

Figure 2 Analyzing an Expression

(–b + Math.sqrt(b * b – 4 * a * c)) / (2 * a)

b2

b2–4ac

b2–4ac

4ac 2a

2a

–b + b2–4ac

–b + b2–4ac

− + −b b ac a

2 4 2

4.3.5 Casting and Rounding

Syntax 4.2 Cast

Syntax

Example

(int) (balance * 100)

This is the type of the expression after casting.

These parentheses are a

part of the cast operator.

Use parentheses here if

the cast is applied to an expression

with arithmetic operators.

(typeName) expression

bj4_ch04_9.fm Page 140 Thursday, October 22, 2009 9:19 PM

4.3 Arithmetic Operations and Mathematical Functions 141

The cast (int) converts the floating-point value balance to an integer by discarding the fractional part. For example, if balance is 13.75, then dollars is set to 13.

The cast tells the compiler that you agree to information loss, in this case, to the loss of the fractional part. You can also cast to other types, such as (float) or (byte).

If you want to round a floating-point number to the nearest whole number, use the Math.round method. This method returns a long integer, because large floating- point numbers cannot be stored in an int.

long rounded = Math.round(balance);

If balance is 13.75, then rounded is set to 14.

Table 2 Mathematical Methods

Function Returns

Math.sqrt(x) Square root of x (≥ 0)

Math.pow(x, y) xy (x > 0, or x = 0 and y > 0, or x < 0 and y is an integer)

Math.sin(x) Sine of x (x in radians)

Math.cos(x) Cosine of x

Math.tan(x) Tangent of x

Math.asin(x) Arc sine (sin–1x ∈ [–π/2, π/2], x ∈ [–1, 1])

Math.acos(x) Arc cosine (cos–1x ∈ [0, π], x ∈ [–1, 1])

Math.atan(x) Arc tangent (tan–1x ∈ [–π/2, π/2])

Math.atan2(y, x) Arc tangent (tan–1y/x ∈ [–π, π]), x may be 0

Math.toRadians(x) Convert x degrees to radians (i.e., returns x · π/180)

Math.toDegrees(x) Convert x radians to degrees (i.e., returns x · 180/π)

Math.exp(x) ex

Math.log(x) Natural log (ln(x), x > 0)

Math.log10(x) Decimal log (log10(x), x > 0)

Math.round(x) Closest integer to x (as a long)

Math.ceil(x) Smallest integer ≥ x (as a double)

Math.floor(x) Largest integer ≤ x (as a double)

Math.abs(x) Absolute value | x |

Math.max(x, y) The larger of x and y

Math.min(x, y) The smaller of x and y

You use a cast (typeName) to convert a value to a different type.

Use the Math.round method to round a floating-point number to the nearest integer.

bj4_ch04_9.fm Page 141 Thursday, October 22, 2009 9:19 PM

142 Chapter 4 Fundamental Data Types

6. What is the value of n after the following sequence of statements? n--; n++; n--;

7. What is the value of 1729 / 100? Of 1729 % 100? 8. Why doesn’t the following statement compute the average of s1, s2, and s3?

double average = s1 + s2 + s3 / 3; // Error

9. What is the value of Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2)) in mathematical notation?

10. When does the cast (long) x yield a different result from the call Math.round(x)? 11. How do you round the double value x to the nearest int value, assuming that you

know that it is less than 2 · 109?

Integer Division

It is unfortunate that Java uses the same symbol, namely /, for both integer and floating- point division. These are really quite different operations. It is a common error to use integer division by accident. Consider this program segment that computes the average of three integers.

int s1 = 5; // Score of test 1 int s2 = 6; // Score of test 2 int s3 = 3; // Score of test 3 double average = (s1 + s2 + s3) / 3; // Error

Table 3 Arithmetic Expressions

Mathematical Expression

Java Expression

Comments

(x + y) / 2 The parentheses are required;

x + y / 2 computes .

x * y / 2 Parentheses are not required; operators with the same precedence are evaluated left to right.

Math.pow(1 + r / 100, n) Complex formulas are “flattened” in Java.

Math.sqrt(a * a + b * b) a * a is simpler than Math.pow(a, 2).

(i + j + k) / 3.0 If i, j, and k are integers, using a denominator of 3.0 forces floating-point division.

x y+ 2 x

y +

2

xy 2

1 100

+ ⎛ ⎝⎜

⎞ ⎠⎟

r n

a b2 2+

i j k+ + 3

S E L F C H E C K

Common Error 4.1

bj4_ch04_9.fm Page 142 Thursday, October 22, 2009 9:19 PM

4.3 Arithmetic Operations and Mathematical Functions 143

System.out.print("Your average score is "); System.out.println(average);

What could be wrong with that? Of course, the average of s1, s2, and s3 is

Here, however, the / does not mean division in the mathematical sense. It denotes integer division, because the values s1 + s2 + s3 and 3 are both integers. For example, if the scores add up to 14, the average is computed to be 4, the result of the integer division of 14 by 3. That integer 4 is then moved into the floating-point variable average. The remedy is to make either the numerator or denominator into a floating-point number:

double total = s1 + s2 + s3; double average = total / 3;

or

double average = (s1 + s2 + s3) / 3.0;

Unbalanced Parentheses

Consider the expression

1.5 * ((-(b - Math.sqrt(b * b - 4 * a * c)) / (2 * a))

What is wrong with it? Count the parentheses. There are five opening parentheses ( and four closing parentheses ). The parentheses are unbalanced. This kind of typing error is very com- mon with complicated expressions. Now consider this expression.

1.5 * (Math.sqrt(b * b - 4 * a * c))) - ((b / (2 * a))

This expression has five opening parentheses ( and five closing parentheses ), but it is still not correct. In the middle of the expression,

1.5 * (Math.sqrt(b * b - 4 * a * c))) - ((b / (2 * a))

there are only two opening parentheses ( but three closing parentheses ), which is an error. In the middle of an expression, the count of opening parentheses must be greater than or equal to the count of closing parentheses, and at the end of the expression the two counts must be the same.

Here is a simple trick to make the counting easier without using pencil and paper. It is dif- ficult for the brain to keep two counts simultaneously, so keep only one count when scan- ning the expression. Start with 1 at the first opening parenthesis; add 1 whenever you see an opening parenthesis; subtract 1 whenever you see a closing parenthesis. Say the numbers aloud as you scan the expression. If the count ever drops below zero, or if it is not zero at the end, the parentheses are unbalanced. For example, when scanning the previous expression, you would mutter

1.5 * (Math.sqrt(b * b - 4 * a * c) ) ) - ((b / (2 * a)) 1 2 1 0 –1

and you would find the error.

s s s1 2 3 3

+ +

Common Error 4.2

bj4_ch04_9.fm Page 143 Thursday, October 22, 2009 9:19 PM

144

Chapter 4 Fundamental Data Types

White Space

The compiler does not care whether you write your entire program onto a single line or place every symbol onto a separate line. The human reader, though, cares very much. You should use blank lines to group your code visually into sections. For example, you can signal to the reader that an output prompt and the corresponding input statement belong together by inserting a blank line before and after the group. You will find many examples in the source code listings in this book.

White space inside expressions is also important. It is easier to read

x1 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a);

than

x1=(-b+Math.sqrt(b*b-4*a*c))/(2*a);

Simply put spaces around all operators

+ - * / % =

. However, don’t put a space after a unary minus: a

-

used to negate a single quantity, as in

-b

. That way, it can be easily distinguished from a binary minus, as in

a - b

. Don’t put spaces between a method name and the parenthe- ses, but do put a space after every Java reserved word. That makes it easy to see that the

sqrt

in

Math.sqrt(x)

is a method name, whereas the

if

in

if (x > 0) . . .

is a reserved word.

Factor Out Common Code

Suppose you want to find both solutions of the quadratic equation

ax

2

+

bx

+

c

=

0. The qua- dratic formula tells us that the solutions are

In Java, there is no analog to the

±

operation, which indicates how to obtain two solutions simultaneously. Both solutions must be computed separately:

x1 = (-b + Math.sqrt(b * b - 4 * a * c)) / (2 * a); x2 = (-b - Math.sqrt(b * b - 4 * a * c)) / (2 * a);

This approach has two problems. First, the computation of

Math.sqrt(b * b - 4 * a * c)

is carried out twice, which wastes time. Second, whenever the same code is replicated, the pos- sibility of a typing error increases. The remedy is to factor out the common code:

double root = Math.sqrt(b * b - 4 * a * c); x1 = (-b + root) / (2 * a); x2 = (-b - root) / (2 * a);

You could go even further and factor out the computation of

2 * a

, but the gain from factor- ing out very simple computations is too small to warrant the effort.

Roundoff Errors

Roundoff errors are a fact of life when calculating with floating-point numbers. You proba- bly have encountered this phenomenon yourself with manual calculations. If you calculate 1/3 to two decimal places, you get 0.33. Multiplying again by 3, you obtain 0.99, not 1.00.

Quality Tip 4.2

Quality Tip 4.3

x b b ac

a1 2 2 4

2, =

− ± −

Common Error 4.3

bj4_ch04_9.fm Page 144 Thursday, November 5, 2009 11:35 AM

4.4 Calling Static Methods 145

In the processor hardware, numbers are represented in the binary number system, not in decimal. You still get roundoff errors when binary digits are lost. They just may crop up at different places than you might expect. Here is an example:

double f = 4.35; int n = (int) (100 * f); System.out.println(n); // Prints 434!

Of course, one hundred times 4.35 is 435, but the program prints 434. Computers represent numbers in the binary system (see Special Topic 4.2 on page 130). In

the binary system, there is no exact representation for 4.35, just as there is no exact represen- tation for 1/3 in the decimal system. The representation used by the computer is just a little less than 4.35, so 100 times that value is just a little less than 435. When a floating-point value is converted to an integer, the entire fractional part is discarded, even if it is almost 1. As a result, the integer 434 is stored in n. Remedy: Use Math.round to convert floating-point num- bers to integers. The round method returns the closest integer.

int n = (int) Math.round(100 * f); // OK, n is 435

Combining Assignment and Arithmetic

In Java you can combine arithmetic and assignment. For example, the instruction

balance += amount;

is a shortcut for

balance = balance + amount;

Similarly,

items *= 2;

is another way of writing

items = items * 2;

Many programmers find this a convenient shortcut. If you like it, go ahead and use it in your own code. For simplicity, we won’t use it in this book.

In the preceding section, you encountered the Math class, which contains a collection of helpful methods for carrying out mathematical computations. These methods have a special form: they are static methods that do not operate on an object.

That is, you don’t call double root = 100.sqrt(); // Error

In Java, numbers are not objects, so you can never invoke a method on a number. Instead, you pass a number as an explicit parameter to a method, enclosing the number in parentheses after the method name:

double root = Math.sqrt(100);

Special Topic 4.3

4.4 Calling Static Methods

bj4_ch04_9.fm Page 145 Thursday, October 22, 2009 9:19 PM

146 Chapter 4 Fundamental Data Types

This call makes it appear as if the sqrt method is applied to an object called Math. However, Math is a class, not an object. A method such as Math.sqrt that does not operate on any object is called a static method. (The term “static” is a historical holdover from the C and C++ programming languages. It has nothing to do with the usual meaning of the word.) In contrast, a method that is invoked on an object is class, is called an instance method:

harrysChecking.deposit(100); // deposit is an instance method

Static methods do not operate on objects, but they are still declared inside classes. When calling the method, you specify the class to which the sqrt method belongs— hence the call is Math.sqrt(100).

How can you tell that Math is a class and not an object? By convention, class names start with an uppercase letter (such as Math or BankAccount). Objects and meth- ods start with a lowercase letter (such as harrysChecking and println). Therefore, harrysChecking.deposit(100) denotes a call of the deposit method on the harrysChecking object inside the System class. On the other hand, Math.sqrt(100) denotes a call to the sqrt method inside the Math class.

This use of upper- and lowercase letters is merely a convention, not a rule of the Java language. It is, however, a convention that the authors of the Java class libraries follow consistently. You should do the same in your programs so that you don’t confuse your fellow programmers.

12. Why can’t you call x.pow(y) to compute xy? 13. Is the call System.out.println(4) a static method call?

HOW TO 4.1 Carrying Out Computations

Many programming problems require that you use mathematical formulas to compute val- ues. This How To shows how to turn a problem statement into a sequence of mathematical formulas and, ultimately, a class in the Java programming language.

Step 1 Understand the problem: What are the inputs? What are the desired outputs?

For example, suppose you are asked to simulate a postage stamp vending machine. A cus- tomer inserts money into the vending machine. Then the customer pushes a “First class stamps” button. The vending machine gives out as many first-class stamps as the customer paid for. (A first-class stamp cost 44 cents at the time this book was written.) Finally, the

Syntax 4.3 Static Method Call

Syntax

Example

Math.pow(10, 3)

The class where the

pow method is declared.

ClassName.methodName(parameters)

All parameters of a static method

are explicit parameters.

A static method does not operate on an object.

S E L F C H E C K

bj4_ch04_9.fm Page 146 Thursday, October 22, 2009 9:19 PM

4.4 Calling Static Methods 147

customer pushes a “Penny stamps” button. The machine gives the change in penny (1-cent) stamps.

In this problem, there is one input: • The amount of money the customer inserts There are two desired outputs: • The number of first-class stamps the machine returns • The number of penny stamps the machine returns

Step 2 Work out examples by hand.

This is a very important step. If you can’t compute a couple of solutions by hand, it’s unlikely that you’ll be able to write a program that automates the computation.

Let’s assume that a first-class stamp costs 44 cents and the customer inserts $1.00. That’s enough for two stamps (88 cents) but not enough for three stamps ($1.32). Therefore, the machine returns two first-class stamps and 12 penny stamps.

Step 3 Design a class that carries out your computations.

How To 3.1 explains how to develop a class by finding methods and instance variables. In our case, the problem statement yields three methods: • public void insert(int dollars) • public int giveFirstClassStamps() • public int givePennyStamps() A bigger challenge is to determine instance variables that describe the state of the machine. In this example, an excellent choice is to keep a single variable, the customer balance. (See Exer- cise P4.12 for another choice.)

That balance is incremented by the insert method and decremented by the giveFirst- ClassStamps and givePennyStamps methods.

Step 4 Write pseudocode for implementing the methods.

Given an amount of money and the price of a first-class stamp, how can you compute how many first-class stamps can be purchased with the money? Clearly, the answer is related to the quotient

For example, suppose the customer paid $1.00. Use a pocket calculator to compute the quo- tient: $1.00/$0.44 ≈ 2.27.

How do you get “2 stamps” out of 2.27? It’s the integer part. In Java, this is easy to com- pute if both arguments are integers. Therefore, let’s switch our computation to pennies. Then we have

number of first-class stamps = 100 / 44 (integer division, without remainder)

What if the user inputs two dollars? Then the numerator becomes 200. What if the price of a stamp goes up? A more general equation is

input in pennies = 100 x dollars

number of first-class stamps = input in pennies / price of first-class stamps in pennies (without remainder)

How about the remaining balance after dispensing the first class stamps? Here is one way of computing it. When the customer gets the stamps, the remaining balance is the original bal- ance, reduced by the value of the stamps purchased. In our example, the remainder is 12 cents—the difference between 100 and 2 · 44. Here is the general formula:

remaining balance = input in pennies – number of first-class stamps x price of first-class stamp in pennies

amount of money price of first-class stamp

bj4_ch04_9.fm Page 147 Thursday, October 22, 2009 9:19 PM

148 Chapter 4 Fundamental Data Types

Step 5 Implement the class.

In Step 3, we decided that the state of the vending machine can be represented by the cus- tomer balance. In Step 4, it became clear that the balance is best represented in pennies.

It is a good idea to rewrite the pseudocode in terms of this newly found variable. We now use the instance variable balance for what was previously called input in pennies. When money is inserted, the balance increases:

balance = balance + 100 * dollars

When the first class stamps are requested, the balance decreases.

firstClassStamps = balance / FIRST_CLASS_STAMP_PRICE; balance = balance - firstClassStamps * FIRST_CLASS_STAMP_PRICE;

What was previously called remaining balance is now simply the value of the balance instance variable.

Here is the implementation of the StampMachine class:

public class StampMachine { public static final double FIRST_CLASS_STAMP_PRICE = 44; private int balance;

public StampMachine() { balance = 0; }

public void insert(int dollars) { balance = balance + 100 * dollars; }

public int giveFirstClassStamps() { int firstClassStamps = balance / FIRST_CLASS_STAMP_PRICE; balance = balance - firstClassStamps * FIRST_CLASS_STAMP_PRICE; return firstClassStamps; }

public int givePennyStamps() { int pennyStamps = balance; balance = 0; return pennyStamps; } }

Step 6 Test your class.

Run a test program (or use an integrated environment such as BlueJ) to verify that the values that your class computes are the same values that you computed by hand.

Here is a test program:

public class StampMachineTester { public static void main(String[] args) { StampMachine machine = new StampMachine(); machine.insert(1); System.out.print("First class stamps: "); System.out.println(machine.giveFirstClassStamps());

bj4_ch04_9.fm Page 148 Thursday, October 22, 2009 9:19 PM

4.5 Strings 149

Available online in WileyPLUS and at www.wiley.com/college/horstmann.

System.out.println("Expected: 2"); System.out.print("Penny stamps: "); System.out.println(machine.givePennyStamps()); System.out.println("Expected: 12”); } }

Program Run

First class stamps: 2 Expected: 2 Penny stamps: 12 Expected: 12

Computing the Volume and Surface Area of a Pyramid

This Worked Example shows how to design a class for com- puting the volume and surface area of a pyramid.

Many programs process text that consists of characters: letters, numbers, punctua- tion, spaces, and so on. A string is a sequence of characters, such as "Hello, World!". In the following sections, you will learn how to work with strings in Java.

In Java, strings are objects that belong to the class String. (You can tell that String is a class name because it starts with an uppercase letter. The primitive types int and double start with lowercase letters.)

You do not need to call a constructor to create a string object. You can obtain a string literal simply by enclosing a sequence of characters in double quotation marks. For example, the string literal "Harry" is an object of the String class.

The number of characters in a string is called the length of the string. As you have seen in Chapter 2, you can use the length method to obtain the length of a string. For example, "Hello".length() is 5, and the length of "Hello, World!" is 13. (The quotation marks are not part of the string and do not contribute to the length, but you must count spaces and punctuation marks.)

A string of length zero, containing no characters, is called the empty string and is written as "".

You can use the + operator to put strings together to form a longer string. String name = "Dave"; String message = "Hello, " + name;

Worked Example 4.1

4.5 Strings

4.5.1 The String Class

A string is a sequence of characters. Strings are objects of the String class.

4.5.2 Concatenation

bj4_ch04_9.fm Page 149 Thursday, October 22, 2009 9:19 PM

150 Chapter 4 Fundamental Data Types

This process is called concatenation. The + operator concatenates two strings, provided one of the expressions, either

to the left or the right of a + operator, is a string. The other one is automatically forced to become a string as well, and both strings are concatenated.

For example, consider this code: String a = "Agent"; int n = 7; String bond = a + n;

Because a is a string, n is converted from the integer 7 to the string "7". Then the two strings "Agent" and "7" are concatenated to form the string "Agent7".

This concatenation is very useful to reduce the number of System.out.print instructions. For example, you can combine

System.out.print("The total is "); System.out.println(total);

to the single call System.out.println("The total is " + total);

The concatenation "The total is " + total computes a single string that consists of the string "The total is ", followed by the string equivalent of the number total.

Sometimes you have a string that contains a number, usually from user input. For example, suppose that the string variable input has the value "19". To get the integer value 19, you use the static parseInt method of the Integer class.

int count = Integer.parseInt(input); // count is the integer 19

To convert a string containing floating-point digits to its floating-point value, use the static parseDouble method of the Double class. For example, suppose input is the string "3.95".

double price = Double.parseDouble(input); // price is the floating-point number 3.95

However, if the string contains spaces or other characters that cannot occur inside numbers, an error occurs. For now, we will always assume that user input does not contain invalid characters.

The substring method computes substrings of a string. The call s.substring(start, pastEnd)

returns a string that is made up of the characters in the string s, starting at position start, and containing all characters up to, but not including, the position pastEnd. Here is an example:

String greeting = "Hello, World!"; String sub = greeting.substring(0, 5); // sub is "Hello"

Strings can be concatenated, that is, put end to end to yield a new longer string. String concatenation is denoted by the + operator.

Whenever one of the arguments of the + operator is a string, the other argument is converted to a string.

4.5.3 Converting Strings to Numbers

If a string contains the digits of a number, you use the Integer.parseInt or Double.parseDouble method to obtain the number value.

4.5.4 Substrings

Use the substring method to extract a part of a string.

bj4_ch04_9.fm Page 150 Thursday, October 22, 2009 9:19 PM

4.5 Strings 151

The substring operation makes a string that consists of five characters taken from the string greeting. A curious aspect of the substring operation is the numbering of the starting and ending positions. The first string position is labeled 0, the second one 1, and so on. For example, Figure 3 shows the position numbers in the greeting string.

The position number of the last character (12 for the string "Hello, World!") is always 1 less than the length of the string.

Let us figure out how to extract the substring "World". Count characters starting at 0, not 1. You find that W, the eighth character, has position number 7. The first character that you don’t want, !, is the character at position 12 (see Figure 4).

Therefore, the appropriate substring command is String sub2 = greeting.substring(7, 12);

It is curious that you must specify the position of the first character that you do want and then the first character that you don’t want. There is one advantage to this setup. You can easily compute the length of the substring: It is pastEnd - start. For example, the string "World" has length 12 – 7 = 5.

If you omit the second parameter of the substring method, then all characters from the starting position to the end of the string are copied. For example,

String tail = greeting.substring(7); // Copies all characters from position 7 on

sets tail to the string "World!". If you supply an illegal string position (a negative number, or a value that is

larger than the length of the string), then your program terminates with an error message.

In this section, we have made the assumption that each character in a string occu- pies a single position. Unfortunately, that assumption is not quite correct. If you process strings that contain characters from international alphabets or special sym- bols, some characters may occupy two positions—see Special Topic 4.5 on page 153.

14. Assuming the String variable s holds the value "Agent", what is the effect of the assignment s = s + s.length()?

15. Assuming the String variable river holds the value "Mississippi", what is the value of river.substring(1, 2)? Of river.substring(2, river.length() - 3)?

Figure 3 String Positions

Figure 4 Extracting a Substring

String positions are counted starting with 0.

0 1 2 3 4 5 6 7 8 9 10 11 12

H e l l o , W o r l d !

0 1 2 3 4 5 6 7 8 9 10 11 12

H e l l o , W o r l d !

5

S E L F C H E C K

bj4_ch04_9.fm Page 151 Thursday, October 22, 2009 9:19 PM

152 Chapter 4 Fundamental Data Types

Reading Exception Reports

You will often have programs that terminate and display an error message, such as

Exception in thread "main" java.lang.StringIndexOutOfBoundsException: String index out of range: -4 at java.lang.String.substring(String.java:1444) at Homework1.main(Homework1.java:16)

An amazing number of students simply give up at that point, saying “it didn’t work”, or “my program died”, without ever reading the error message. Admittedly, the format of the exception report is not very friendly. But it is actually easy to decipher it.

When you have a close look at the error message, you will notice two pieces of useful information:

1. The name of the exception, such as StringIndexOutOfBoundsException 2. The line number of the code that contained the statement that caused the exception,

such as Homework1.java:16

The name of the exception is always in the first line of the report, and it ends in Exception. If you get a StringIndexOutOfBoundsException, then there was a problem with accessing an invalid position in a string. That is useful information.

The line number of the offending code is a little harder to determine. The exception report contains the entire stack trace—that is, the names of all methods that were pending when the exception hit. The first line of the stack trace is the method that actually generated the exception. The last line of the stack trace is a line in main. Often, the exception was thrown by a method that is in the standard library. Look for the first line in your code that appears in the exception report. For example, skip the line that refers to

java.lang.String.substring(String.java:1444)

The next line in our example mentions a line number in your code, Homework1.java. Once you have the line number in your code, open up the file, go to that line, and look at it! Also look at the name of the exception. In most cases, these two pieces of information will make it completely obvious what went wrong, and you can easily fix your error.

Escape Sequences

Suppose you want to display a string containing quotation marks, such as

Hello, "World"!

You can’t use

System.out.println("Hello, "World"!");

As soon as the compiler reads "Hello, ", it thinks the string is finished, and then it gets all confused about World followed by two quotation marks. A human would probably realize that the second and third quotation marks were supposed to be part of the string, but a com- piler has a one-track mind. If a simple analysis of the input doesn’t make sense to it, it just refuses to go on, and reports an error. Well, how do you then display quotation marks on the screen? You precede the quotation marks inside the string with a backslash character. Inside a string, the sequence \" denotes a literal quote, not the end of a string. The correct display statement is, therefore

System.out.println("Hello, \"World\"!");

Productivity Hint 4.1

Special Topic 4.4

bj4_ch04_9.fm Page 152 Thursday, October 22, 2009 9:19 PM

4.5 Strings 153

The backslash character is used as an escape character; the character sequence \" is called an escape sequence. The backslash does not denote itself; instead, it is used to encode other characters that would otherwise be difficult to include in a string.

Now, what do you do if you actually want to print a backslash (for example, to specify a Windows file name)? You must enter two \\ in a row, like this:

System.out.println("The secret message is in C:\\Temp\\Secret.txt");

This statement prints

The secret message is in C:\Temp\Secret.txt

Another escape sequence occasionally used is \n, which denotes a newline or line feed char- acter. Printing a newline character causes the start of a new line on the display. For example, the statement

System.out.print("*\n**\n***\n");

prints the characters

* ** ***

on three separate lines. Of course, you could have achieved the same effect with three sepa- rate calls to println.

Finally, escape sequences are useful for including international characters in a string. For example, suppose you want to print “All the way to San José!”, with an accented letter (é). If you use a U.S. keyboard, you may not have a key to generate that letter. Java uses the Uni- code encoding scheme to denote international characters. For example, the é character has Unicode encoding 00E9. You can include that character inside a string by writing \u, followed by its Unicode encoding:

System.out.println("All the way to San Jos\u00E9!");

You can look up the codes for the U.S. English and Western European characters in Appen- dix A, and codes for thousands of characters at www.unicode.org.

Strings and the char Type

Strings are sequences of Unicode characters (see Random Fact 4.2 on page 154). Character literals look like string literals, except that character literals are delimited by single quotes: 'H' is a character, "H" is a string containing a single character.

Characters have numeric values. For example, if you look at Appendix A, you can see that the character 'H' is actually encoded as the number 72.

You can use escape sequences (see Special Topic 4.4 on page 152) inside character literals. For example, '\n' is the newline character, and '\u00E9' is the character é.

When Java was first designed, each Unicode character was encoded as a two-byte quan- tity. The char type was intended to hold the code of a Unicode character. However, as of 2003, Unicode had grown so large that some characters needed to be encoded as pairs of char values. Thus, you can no longer think of a char value as a character. Technically speaking, a char value is a code unit in the UTF-16 encoding of Unicode. That encoding represents the most common characters as a single char value, and less common or supplementary charac- ters as a pair of char values.

Special Topic 4.5

bj4_ch04_9.fm Page 153 Thursday, October 22, 2009 9:19 PM

154 Chapter 4 Fundamental Data Types

The charAt method of the String class returns a code unit from a string. As with the sub- string method, the positions in the string are counted starting at 0. For example, the statement

String greeting = "Hello"; char ch = greeting.charAt(0);

sets ch to the value 'H'. However, if you use char variables, your programs may fail with some strings that contain

international or symbolic characters. For example, the single character � (the mathematical symbol for the set of integers) is encoded by the two code units '\uD835' and '\uDD6B'.

If you call charAt(0) on the string containing the single character � (that is, the string "\uD835\uDD6B"), you only get the first half of a supplementary character.

Therefore, you should only use char values if you are absolutely sure that you won’t need to encode supplementary characters.

International Alphabets

The English alphabet is pretty simple: upper- and lowercase a to z. Other European lan- guages have accent marks and special characters. For example, German has three umlaut characters (ä, ö, ü) and a double-s character (ß). These are not optional frills; you couldn’t write a page of German text without using these characters. German computer keyboards have keys for these characters.

Many countries don’t use the Roman script at all. Russian, Greek, Hebrew, Arabic, and Thai letters, to name just a few, have completely different shapes (see The Thai Alphabet). To complicate matters, scripts like Hebrew and Arabic are written from right to left instead of from left to right, and many of these scripts have characters that stack above or below other characters, as those marked with a dotted circle do in Thai. Each of these alphabets has between 30 and 100 letters.

The situation is much more dramatic in languages that use Chinese script: the Chinese dialects, Japanese, and Korean. The Chinese script is not alphabetic but ideographic—a char- acter represents an idea or thing rather than a single sound. Tens of thousands of ideographs are in active use.

The inconsistencies among character encodings have been a major nuisance for interna- tional electronic communication and for software manufacturers vying for a global market. Between 1988 and 1991 a consortium of hardware and software manufacturers developed a uniform encoding scheme called Unicode that is expressly designed to encode text in all

A German Keyboard

Random Fact 4.2

Q W E R T Z U I O P

A S D F G H J K L

Y X C V B N M ; ,

: .

_ -

Ö Ä

Ü *+ ~ ´ #

? ß /

= 0 }

) 9 ]

( 8 [

/ 7 {

& 6

% 5

$ 4

§ 3 3

" 2 2

! 1

Strg Strg Alt Alt Gr > | < |

• ^

` ´

bj4_ch04_9.fm Page 154 Thursday, October 22, 2009 9:19 PM

4.6 Reading Input 155

written languages of the world (see www.unicode.org). In the first version of Unicode, about 39,000 characters were given codes, including 21,000 Chinese ideographs. A 2-byte code (which can encode over 65,000 characters) was chosen. It was thought to leave ample space for expansion for esoteric scripts, such as Egyptian hieroglyphs and the ancient script used on the island of Java.

Java was one of the first programming languages to embrace Unicode. All Unicode char- acters can be stored in Java strings, but which ones can actually be displayed depends on your computer system. The primitive type char denotes a 2-byte Unicode character.)

Unfortunately, in 2003, the inevitable happened. Another large batch of Chinese ideo- graphs had to be added to Unicode, pushing it beyond the 16-bit limit. Now, some charac- ters need to be encoded with a pair of char values (see Special Topic 4.5).

The Java programs that you have made so far have constructed objects, called meth- ods, printed results, and exited. They were not interactive and took no user input. In this section, you will learn one method for reading user input.

Because output is sent to System.out, you might think that you use System.in for input. Unfortunately, it isn’t quite that simple. When Java was first designed, not

The Thai Alphabet

Chinese Ideographs

4.6 Reading Input

bj4_ch04_9.fm Page 155 Thursday, October 22, 2009 9:19 PM

156 Chapter 4 Fundamental Data Types

much attention was given to reading keyboard input. It was assumed that all pro- grammers would produce graphical user interfaces with text fields and menus. Sys- tem.in was given a minimal set of features—it can only read one byte at a time. Finally, in Java version 5, a Scanner class was added that lets you read keyboard input in a convenient manner.

To construct a Scanner object, simply pass the System.in object to the Scanner con- structor:

Scanner in = new Scanner(System.in);

You can create a scanner out of any input stream (such as a file), but you will usu- ally want to use a scanner to read keyboard input from System.in.

Once you have a scanner, you use the nextInt or nextDouble methods to read the next integer or floating-point number.

System.out.print("Enter quantity: "); int quantity = in.nextInt();

System.out.print("Enter price: "); double price = in.nextDouble();

When the nextInt or nextDouble method is called, the program waits until the user types a number and hits the Enter key. You should always provide instructions for the user (such as "Enter quantity:") before calling a Scanner method. Such an instruc- tion is called a prompt.

If the user supplies an input that is not a number, then a run-time exception occurs. You will see in the next chapter how you can check whether the user sup- plied a numeric input.

The nextLine method returns the next line of input (until the user hits the Enter key) as a String object. The next method returns the next word, terminated by any white space, that is, a space, the end of a line, or a tab.

System.out.print("Enter city: "); String city = in.nextLine();

System.out.print("Enter state code: "); String state = in.next();

Here, we use the nextLine method to read a city name that may consist of multiple words, such as San Francisco. We use the next method to read the state code (such as CA), which consists of a single word.

Here is an example of a program that takes user input. This program uses the CashRegister class and simulates a transaction in which a user purchases an item, pays for it, and receives change.

We call this class CashRegisterSimulator, not CashRegisterTester. We reserve the Tester suffix for classes whose sole purpose is to test other classes.

ch04/cashregister/CashRegisterSimulator.java

Use the Scanner class to read keyboard input in a console window.

1 import java.util.Scanner; 2 3 /** 4 This program simulates a transaction in which a user pays for an item 5 and receives change. 6 */ 7 public class CashRegisterSimulator 8 {

bj4_ch04_9.fm Page 156 Thursday, October 22, 2009 9:19 PM

4.6 Reading Input 157

Available online in WileyPLUS and at www.wiley.com/college/horstmann.

Program Run

16. Why can’t input be read directly from System.in? 17. Suppose in is a Scanner object that reads from System.in, and your program calls

String name = in.next();

What is the value of name if the user enters John Q. Public?

Extracting Initials

This Worked Example shows how to read names and print a set of corresponding initials.

9 public static void main(String[] args) 10 { 11 Scanner in = new Scanner(System.in); 12 13 CashRegister register = new CashRegister(); 14 15 System.out.print("Enter price: "); 16 double price = in.nextDouble(); 17 register.recordPurchase(price); 18 19 System.out.print("Enter dollars: "); 20 int dollars = in.nextInt(); 21 System.out.print("Enter quarters: "); 22 int quarters = in.nextInt(); 23 System.out.print("Enter dimes: "); 24 int dimes = in.nextInt(); 25 System.out.print("Enter nickels: "); 26 int nickels = in.nextInt(); 27 System.out.print("Enter pennies: "); 28 int pennies = in.nextInt(); 29 register.enterPayment(dollars, quarters, dimes, nickels, pennies); 30 31 System.out.print("Your change: "); 32 System.out.println(register.giveChange()); 33 } 34 }

Enter price: 7.55 Enter dollars: 10 Enter quarters: 2 Enter dimes: 1 Enter nickels: 0 Enter pennies: 0 Your change: 3.05

S E L F C H E C K

Worked Example 4.2

bj4_ch04_9.fm Page 157 Thursday, October 22, 2009 9:19 PM

158 Chapter 4 Fundamental Data Types

Formatting Numbers

The default format for printing numbers is not always what you would like. For example, consider the following code segment:

double total = 3.50; final double TAX_RATE = 8.5; // Tax rate in percent double tax = total * TAX_RATE / 100; // tax is 0.2975 System.out.println("Total: " + total); System.out.println("Tax: " + tax);

The output is

Total: 3.5 Tax: 0.2975

You may prefer the numbers to be printed with two digits after the decimal point, like this:

Total: 3.50 Tax: 0.30

You can achieve this with the printf method of the PrintStream class. (Recall that System.out is an instance of PrintStream.) The first parameter of the printf method is a format string that shows how the output should be formatted. The format string contains characters that are simply printed, and format specifiers: codes that start with a % character and end with a letter that indicates the format type. There are quite a few formats—Table 4 shows the most important ones. The remaining parameters of printf are the values to be formatted. For example,

System.out.printf("Total:%5.2f", total);

prints the string Total:, followed by a floating-point number with a width of 5 and a preci- sion of 2. The width is the total number of characters to be printed: in our case, a space, the digit 3, a period, and two digits. If you increase the width, more spaces are added. The preci- sion is the number of digits after the decimal point.

Special Topic 4.6

Table 4 Format Types

Code Type Example

d Decimal integer 123

x Hexadecimal integer 7B

o Octal integer 173

f Fixed floating-point 12.30

e Exponential floating-point 1.23e+1

g General floating-point (exponential notation is used for very large or very small values)

12.3

s String Tax:

n Platform-independent line end

bj4_ch04_9.fm Page 158 Thursday, October 22, 2009 9:19 PM

4.6 Reading Input 159

This simple use of printf is sufficient for most formatting needs. Once in a while, you may see a more complex example, such as this one:

System.out.printf("%-6s%5.2f%n", "Tax:", total);

Here, we have three format specifiers. The first one is %-6s. The s indicates a string. The hyphen is a flag, modifying the format. (See Table 5 for the most common format flags. The flags immediately follow the % character.) The hyphen indicates left alignment. If the string to be formatted is shorter than the width, it is placed to the left, and spaces are added to the right. (The default is right alignment, with spaces added to the left.) Thus, %-6s denotes a left- aligned string of width 6.

You have already seen %5.2f: a floating-point number of width 5 and precision 2. The final specifier is %n, indicating a platform-independent line end. In Windows, lines need to be ter- minated by two characters: a carriage return '\r' and a newline '\n'. In other operating sys- tems, a '\n' suffices. The %n format emits the appropriate line terminators.

Moreover, this call to printf has two parameters. You can supply any number of parame- ter values to the printf method. Of course, they must match the format specifiers in the for- mat string.

The format method of the String class is similar to the printf method. However, it returns a string instead of producing output. For example, the call

String message = String.format("Total:%5.2f", total);

sets the message variable to the string "Total: 3.50".

Using Dialog Boxes for Input and Output

Most program users find the console window rather old-fashioned. The easiest alternative is to create a separate pop-up window for each input (see the figure).

Table 5 Format Flags

Flag Meaning Example

- Left alignment 1.23 followed by spaces

0 Show leading zeroes 001.23

+ Show a plus sign for positive numbers +1.23

( Enclose negative numbers in parentheses (1.23)

, Show decimal separators 12,300

^ Convert letters to uppercase 1.23E+1

An Input Dialog Box

Special Topic 4.7

bj4_ch04_9.fm Page 159 Thursday, October 22, 2009 9:19 PM

160 Chapter 4 Fundamental Data Types

Call the static showInputDialog method of the JOptionPane class, and supply the string that prompts the input from the user. For example,

String input = JOptionPane.showInputDialog("Enter price:");

That method returns a String object. Of course, often you need the input as a number. Use the Integer.parseInt and Double.parseDouble methods to convert the string to a number:

double price = Double.parseDouble(input);

You can also display output in a dialog box:

JOptionPane.showMessageDialog(null, "Price: " + price);

Finally, whenever you call the showInputDialog or showMessageDialog method in a program that does not show any other frame windows, you need to add a line

System.exit(0);

to the end of your main method. The showInputDialog method starts a user interface thread to handle user input. When the main method reaches the end, that thread is still running, and your program won’t exit automatically. To force the program to exit, you need to call the exit method of the System class. The parameter of the exit method is the status code of the program. A code of 0 denotes successful completion; you can use nonzero status codes to denote various error conditions.

Choose appropriate types for representing numeric data.

• Java has eight primitive types, including four integer types and two floating-point types.

• A numeric computation overflows if the result falls outside the range for the number type.

• Rounding errors occur when an exact conversion between numbers is not possible.

Write code that uses constants to document the purpose of numeric values.

• A final variable is a constant. Once its value has been set, it cannot be changed. • Use named constants to make your programs easier to read and maintain.

Write arithmetic expressions in Java.

• The ++ and -- operators increment and decrement a variable. • If both arguments of the / operator are integers, the result is an integer and the

remainder is discarded. • The % operator computes the remainder of a division. • The Math class contains methods sqrt and pow to compute square roots and powers. • You use a cast (typeName) to convert a value to a different type. • Use the Math.round method to round a floating-point number to the nearest integer.

Distinguish between static methods and instance methods.

• A static method does not operate on an object.

Summary of Learning Objectives

bj4_ch04_9.fm Page 160 Thursday, October 22, 2009 9:19 PM

Media Resources

161

Process strings in Java programs.

•

A string is a sequence of characters. Strings are objects of the

String

class.

•

Strings can be concatenated, that is, put end to end to yield a new longer string. String concatenation is denoted by the

+

operator.

•

Whenever one of the arguments of the

+

operator is a string, the other argument is converted to a string.

•

If a string contains the digits of a number, you use the

Integer.parseInt

or

Double.parseDouble

method to obtain the number value.

•

Use the

substring

method to extract a part of a string.

•

String positions are counted starting with 0.

Write programs that read user input.

•

Use the

Scanner

class to read keyboard input in a console window.

•

Worked Example

Computing the Volume and Surface Area of a Pyramid

•

Worked Example

Extracting Initials

•

Lab Exercises Practice Quiz Code Completion Exercises

Classes, Objects, and Methods Introduced in this Chapter java.io.PrintStream printf java.lang.Double parseDouble java.lang.Integer MAX_VALUE MIN_VALUE parseInt toString java.lang.Math E PI abs acos asin atan atan2 ceil cos exp floor log log10

max min pow round sin sqrt tan toDegrees toRadians java.lang.String format substring java.lang.System in java.math.BigDecimal add multiply subtract java.math.BigInteger add multiply subtract

java.util.Scanner next nextDouble nextInt nextLine javax.swing.JOptionPane showInputDialog showMessageDialog

Media Resources

www.wiley.com/ college/ horstmann

bj4_ch04.fm Page 161 Sunday, November 15, 2009 4:32 PM

162 Chapter 4 Fundamental Data Types

R4.1 Write the following mathematical expressions in Java.

R4.2 Write the following Java expressions in mathematical notation. a. dm = m * (Math.sqrt(1 + v / c) / (Math.sqrt(1 - v / c) - 1)); b. volume = Math.PI * r * r * h; c. volume = 4 * Math.PI * Math.pow(r, 3) / 3; d. p = Math.atan2(z, Math.sqrt(x * x + y * y));

R4.3 What is wrong with this version of the quadratic formula? x1 = (-b - Math.sqrt(b * b - 4 * a * c)) / 2 * a; x2 = (-b + Math.sqrt(b * b - 4 * a * c)) / 2 * a;

R4.4 Give an example of integer overflow. Would the same example work correctly if you used floating-point?

R4.5 Give an example of a floating-point roundoff error. Would the same example work correctly if you used integers and switched to a sufficiently small unit, such as cents instead of dollars, so that the values don’t have a fractional part?

R4.6 Consider the following code: CashRegister register = new CashRegister(); register.recordPurchase(19.93); register.enterPayment(20, 0, 0, 0, 0); System.out.print("Change: "); System.out.println(register.giveChange());

The code segment prints the total as 0.07000000000000028. Explain why. Give a rec- ommendation to improve the code so that users will not be confused.

R4.7 Let n be an integer and x a floating-point number. Explain the difference between n = (int) x;

and n = (int) Math.round(x);

R4.8 Let n be an integer and x a floating-point number. Explain the difference between n = (int) (x + 0.5);

and n = (int) Math.round(x);

Review Exercises

s s v t gt

G a

P m m

= + +

= +( )

= ⋅ +

0 0 1 2

2

2 3

2 1 2

10

4

1

π

FV PV INT 00

2 2 2

( ) = + −

YRS

c a b abcosγ

bj4_ch04_9.fm Page 162 Thursday, October 22, 2009 9:19 PM

Review Exercises 163

For what values of x do they give the same result? For what values of x do they give different results?

R4.9 Consider the vending machine implementation in How To 4.1 on page 146. What happens if the givePennyStamps method is invoked before the giveFirstClassStamps method?

R4.10 Explain the differences between 2, 2.0, '2', "2", and "2.0".

R4.11 Explain what each of the following two program segments computes: int x = 2; int y = x + x;

and String s = "2"; String t = s + s;

R4.12 True or false? (x is an int and s is a String) a. Integer.parseInt("" + x) is the same as x b. "" + Integer.parseInt(s) is the same as s c. s.substring(0, s.length()) is the same as s

R4.13 How do you get the first character of a string? The last character? How do you remove the first character? The last character?

R4.14 How do you get the last digit of an integer? The first digit? That is, if n is 23456, how do you find out that the first digit is 2 and the last digit is 6? Do not convert the number to a string. Hint: %, Math.log.

R4.15 This chapter contains several recommendations regarding variables and constants that make programs easier to read and maintain. Summarize these recommenda- tions.

R4.16 What is a final variable? Can you declare a final variable without supplying its value? (Try it out.)

R4.17 What are the values of the following expressions? In each line, assume that double x = 2.5; double y = -1.5; int m = 18; int n = 4;

a. x + n * y - (x + n) * y

b. m / n + m % n

c. 5 * x - n / 5

d. Math.sqrt(Math.sqrt(n))

e. (int) Math.round(x)

f. (int) Math.round(x) + (int) Math.round(y)

g. 1 - (1 - (1 - (1 - (1 - n))))

bj4_ch04_9.fm Page 163 Thursday, October 22, 2009 9:19 PM

164 Chapter 4 Fundamental Data Types

R4.18 What are the values of the following expressions? In each line, assume that int n = 4; String s = "Hello"; String t = "World";

a. s + t b. s + n c. n + t d. s.substring(1, n) e. s.length() + t.length()

P4.1 Enhance the CashRegister class by adding separate methods enterDollars, enterQuar- ters, enterDimes, enterNickels, and enterPennies. Use this tester class:

public class CashRegisterTester { public static void main (String[] args) { CashRegister register = new CashRegister(); register.recordPurchase(20.37); register.enterDollars(20); register.enterQuarters(2); System.out.println("Change: " + register.giveChange()); System.out.println("Expected: 0.13"); } }

P4.2 Enhance the CashRegister class so that it keeps track of the total number of items in a sale. Count all recorded purchases and supply a method

int getItemCount()

that returns the number of items of the current purchase. Remember to reset the count at the end of the purchase.

P4.3 Implement a class IceCreamCone with methods getSurfaceArea() and getVolume(). In the constructor, supply the height and radius of the cone. Be careful when looking up the formula for the surface area—you should only include the outside area along the side of the cone since the cone has an opening on the top to hold the ice cream.

P4.4 Write a program that prompts the user for two numbers, then prints • The sum • The difference • The product • The average • The distance (absolute value of the difference) • The maximum (the larger of the two) • The minimum (the smaller of the two)

Programming Exercises

bj4_ch04_9.fm Page 164 Thursday, October 22, 2009 9:19 PM

Programming Exercises 165

To do so, implement a class public class Pair { /** Constructs a pair. @param aFirst the first value of the pair @param aSecond the second value of the pair */ public Pair(double aFirst, double aSecond) { . . . }

/** Computes the sum of the values of this pair. @return the sum of the first and second values */ public double getSum() { . . . } . . . }

Then implement a class PairTester that constructs a Pair object, invokes its methods, and prints the results.

P4.5 Declare a class DataSet that computes the sum and average of a sequence of integers. Supply methods

• void addValue(int x) • int getSum() • double getAverage()

Hint: Keep track of the sum and the count of the values. Then write a test program DataSetTester that calls addValue four times and prints the expected and actual results.

P4.6 Write a class DataSet that computes the largest and smallest values in a sequence of numbers. Supply methods

• void addValue(int x) • int getLargest() • int getSmallest()

Keep track of the smallest and largest values that you’ve seen so far. Then use the Math.min and Math.max methods to update them in the addValue method. What should you use as initial values? Hint: Integer.MIN_VALUE, Integer.MAX_VALUE. Write a test program DataSetTester that calls addValue four times and prints the expected and actual results.

P4.7 Write a program that prompts the user for a measurement in meters and then con- verts it into miles, feet, and inches. Use a class

public class Converter { /** Constructs a converter that can convert between two units. @param aConversionFactor the factor by which to multiply to convert to the target unit */ public Converter(double aConversionFactor) { . . . }

bj4_ch04_9.fm Page 165 Thursday, October 22, 2009 9:19 PM

166 Chapter 4 Fundamental Data Types

/** Converts from a source measurement to a target measurement. @param fromMeasurement the measurement @return the input value converted to the target unit */ public double convertTo(double fromMeasurement) { . . . }

/** Converts from a target measurement to a source measurement. @param toMeasurement the target measurement @return the value whose conversion is the target measurement */ public double convertFrom(double toMeasurement) { . . . } }

In your ConverterTester class, construct and test the following Converter object: final double MILE_TO_KM = 1.609; Converter milesToMeters = new Converter(1000 * MILE_TO_KM);

P4.8 Write a class Square whose constructor receives the length of the sides. Then supply methods to compute

• The area and perimeter of the square • The length of the diagonal (use the Pythagorean theorem)

P4.9 Implement a class SodaCan whose constructor receives the height and diameter of the soda can. Supply methods getVolume and getSurfaceArea. Supply a SodaCanTester class that tests your class.

P4.10 Implement a class Balloon that models a spherical balloon that is being filled with air. The constructor constructs an empty balloon. Supply these methods:

• void addAir(double amount) adds the given amount of air • double getVolume() gets the current volume • double getSurfaceArea() gets the current surface area • double getRadius() gets the current radius

Supply a BalloonTester class that constructs a balloon, adds 100 cm3 of air, tests the three accessor methods, adds another 100 cm3 of air, and tests the accessor methods again.

P4.11 Giving change. Enhance the CashRegister class so that it directs a cashier how to give change. The cash register computes the amount to be returned to the customer, in pennies. Add the following methods to the CashRegister class:

• int giveDollars() • int giveQuarters() • int giveDimes() • int giveNickels() • int givePennies()

Each method computes the number of dollar bills or coins to return to the cus- tomer, and reduces the change due by the returned amount. You may assume that the methods are called in this order. Here is a test class:

bj4_ch04_9.fm Page 166 Thursday, October 22, 2009 9:19 PM

Programming Exercises 167

public class CashRegisterTester { public static void main(String[] args) { CashRegister register = new CashRegister();

register.recordPurchase(8.37); register.enterPayment(10, 0, 0, 0, 0); System.out.println("Dollars: " + register.giveDollars()); System.out.println("Expected: 1"); System.out.println("Quarters: " + register.giveQuarters()); System.out.println("Expected: 2"); System.out.println("Dimes: " + register.giveDimes()); System.out.println("Expected: 1"); System.out.println("Nickels: " + register.giveNickels()); System.out.println("Expected: 0"); System.out.println("Pennies: " + register.givePennies()); System.out.println("Expected: 3"); } }

P4.12 In How To 4.1 on page 146, we represented the state of the vending machine by storing the balance in pennies. This is ingenious, but it is perhaps not the most obvi- ous solution. Another possibility is to store the number of dollars that the customer inserted and the change that remains after giving out the first class stamps. Reimple- ment the vending machine in this way. Of course, the public interface should remain unchanged.

P4.13 Write a program that reads in an integer and breaks it into a sequence of individual digits in reverse order. For example, the input 16384 is displayed as

4 8 3 6 1

You may assume that the input has no more than five digits and is not negative. Declare a class DigitExtractor:

public class DigitExtractor { /** Constructs a digit extractor that gets the digits of an integer in reverse order. @param anInteger the integer to break up into digits */ public DigitExtractor(int anInteger) { . . . }

/** Returns the next digit to be extracted. @return the next digit */ public int nextDigit() { . . . } }

In your main class DigitPrinter, call System.out.println(myExtractor.nextDigit()) five times.

bj4_ch04_9.fm Page 167 Thursday, October 22, 2009 9:19 PM

168 Chapter 4 Fundamental Data Types

P4.14 Implement a class QuadraticEquation whose constructor receives the coefficients a, b, c of the quadratic equation ax2 + bx + c = 0. Supply methods getSolution1 and getSolution2 that get the solutions, using the quadratic formula. Write a test class QuadraticEquationTester that constructs a QuadraticEquation object, and prints the two solutions.

P4.15 Write a program that reads two times in military format (0900, 1730) and prints the number of hours and minutes between the two times. Here is a sample run. User input is in color.

Please enter the first time: 0900 Please enter the second time: 1730 8 hours 30 minutes

Extra credit if you can deal with the case where the first time is later than the second: Please enter the first time: 1730 Please enter the second time: 0900 15 hours 30 minutes

Implement a class TimeInterval whose constructor takes two military times. The class should have two methods getHours and getMinutes.

P4.16 Writing large letters. A large letter H can be produced like this: * * * * ***** * * * *

Use the class public class LetterH { public String toString() { return "* *\n* *\n*****\n* *\n* *\n"; } }

Declare similar classes for the letters E, L, and O. Then write the message H E L L O

in large letters.

P4.17 Write a class ChristmasTree whose toString method yields a string depicting a Christmas tree:

/\ / \ / \ / \ -------- " " " " " "

Remember to use escape sequences.

bj4_ch04_9.fm Page 168 Thursday, October 22, 2009 9:19 PM

Programming Projects 169

P4.18 Your job is to transform numbers 1, 2, 3, . . ., 12 into the corresponding month names January, February, March, . . ., December. Implement a class Month whose con- structor parameter is the month number and whose getName method returns the month name. Hint: Make a very long string "January February March . . . ", in which you add spaces such that each month name has the same length. Then use substring to extract the month you want.

P4.19 Write a class to compute the date of Easter Sunday. Easter Sunday is the first Sun- day after the first full moon of spring. Use this algorithm, invented by the mathe- matician Carl Friedrich Gauss in 1800:

1. Let y be the year (such as 1800 or 2001). 2. Divide y by 19 and call the remainder a. Ignore the quotient. 3. Divide y by 100 to get a quotient b and a remainder c. 4. Divide b by 4 to get a quotient d and a remainder e. 5. Divide 8 * b + 13 by 25 to get a quotient g. Ignore the remainder. 6. Divide 19 * a + b - d - g + 15 by 30 to get a remainder h. Ignore the quotient. 7. Divide c by 4 to get a quotient j and a remainder k. 8. Divide a + 11 * h by 319 to get a quotient m. Ignore the remainder. 9. Divide 2 * e + 2 * j - k - h + m + 32 by 7 to get a remainder r. Ignore the

quotient. 10. Divide h - m + r + 90 by 25 to get a quotient n. Ignore the remainder. 11. Divide h - m + r + n + 19 by 32 to get a remainder p. Ignore the quotient.

Then Easter falls on day p of month n. For example, if y is 2001:

Therefore, in 2001, Easter Sunday fell on April 15. Write a class Easter with methods getEasterSundayMonth and getEasterSundayDay.

Project 4.1 In this project, you will perform calculations with triangles. A triangle is defined by the x- and y-coordinates of its three corner points. Your job is to compute the following properties of a given triangle:

Of course, you should implement a Triangle class with appropriate methods. Supply a program that prompts a user for the corner point coordinates and produces a nicely formatted table of the triangle properties. This is a good team project for two students. Both students should agree on the Triangle interface. One student implements the Triangle class, the other simulta- neously implements the user interaction and formatting.

a = 6 b = 20 c = 1 d = 5, e = 0

g = 6 h = 18 j = 0, k = 1 m = 0

r = 6 n = 4 p = 15

Programming Projects

• the lengths of all sides • the angles at all corners

• the perimeter • the area

bj4_ch04_9.fm Page 169 Thursday, October 22, 2009 9:19 PM

170 Chapter 4 Fundamental Data Types

Project 4.2 The CashRegister class has an unfortunate limitation: It is closely tied to the coin sys- tem in the United States and Canada. Research the system used in most of Europe. Your goal is to produce a cash register that works with euros and cents. Rather than designing another limited CashRegister implementation for the European market, you should design a separate Coin class and a cash register that can work with coins of all types.

1. int and double. 2. The world’s most populous country, China, has about 1.2 x 109 inhabitants. There-

fore, individual population counts could be held in an int. However, the world pop- ulation is over 6 × 109. If you compute totals or averages of multiple countries, you can exceed the largest int value. Therefore, double is a better choice. You could also use long, but there is no benefit because the exact population of a country is not known at any point in time.

3. The first initialization is incorrect. The right hand side is a value of type double, and it is not legal to initialize an int variable with a double value. The second initializa- tion is correct—an int value can always be converted to a double.

4. The first declaration is used inside a method, the second inside a class. 5. (1) You should use a named constant, not the “magic number” 3.14.

(2) 3.14 is not an accurate representation of π. 6. One less than it was before. 7. 17 and 29. 8. Only s3 is divided by 3. To get the correct result, use parentheses. Moreover, if s1,

s2, and s3 are integers, you must divide by 3.0 to avoid integer division: (s1 + s2 + s3) / 3.0

9.

10. When the fractional part of x is ≥ 0.5. 11. By using a cast: (int) Math.round(x). 12. x is a number, not an object, and you cannot invoke methods on numbers. 13. No—the println method is called on the object System.out. 14. s is set to the string “Agent5”. 15. The strings "i" and "ssissi". 16. The class only has a method to read a single byte. It would be very tedious to form

characters, strings, and numbers from those bytes. 17. The value is "John". The next method reads the next word.

Answers to Self-Check Questions

x y2 2+

bj4_ch04_9.fm Page 170 Thursday, October 22, 2009 9:19 PM

171

Chapter

5

Decisions

C H A P T E R G O A L S

•

To be able to implement decisions using

if

statements

•

To effectively group statements into blocks

•

To learn how to compare integers, floating-point numbers, strings, and objects

•

To correctly order decisions in multiple branches and nested branches

•

To program conditions using Boolean operators and variables

T

To be able to design tests that cover all parts of a program

The programs we have seen so far were able to do fast computations

and render graphs, but they were very inflexible. Except for variations in the input, they worked the

same way with every program run. One of the essential features of nontrivial computer programs is

their ability to make decisions and to carry out different actions, depending on the nature of the

inputs. The goal of this chapter is to learn how to program simple and complex decisions.

bj4_ch05_9.fm Page 171 Friday, October 23, 2009 11:32 AM

172

CHAPTER CONTENTS

Computer programs often need to make

decisions

, taking different actions depend- ing on a condition.

Consider the bank account class of Chapter 3. The

withdraw

method allows you to withdraw as much money from the account as you like. The balance just moves ever further into the negatives. That is not a realistic model for a bank account. Let’s implement the

withdraw

method so that you cannot withdraw more money than you have in the account. That is, the

withdraw

method must make a

decision:

whether to allow the withdrawal or not.

The

if

statement is used to implement a decision. The

if

statement has two parts: a condition and a body. If the

condition

is true, the

body

of the statement is exe- cuted. The body of the

if

statement consists of a statement:

if (amount <= balance) //

Condition

balance = balance - amount; //

Body

The assignment statement is carried out only when the amount to be withdrawn is less than or equal to the balance (see Figure 1).

Let us make the

withdraw

method of the

BankAccount

class even more realistic. Most banks not only disallow withdrawals that exceed your account balance; they also charge you a penalty for every attempt to do so.

This operation can’t be programmed simply by providing two complementary

if

statements, such as:

if (amount <= balance) balance = balance - amount; if (amount > balance) //

Use

if/else

instead

balance = balance - OVERDRAFT_PENALTY;

5.1 The if Statement

The if statement lets a program carry out different actions depending on a condition.

5.1 The

if

Statement

172

S

YNTAX

5.1: The

if

Statement

174

Q

UALITY

T

IP

5.1: Brace Layout

174

P

RODUCTIVITY

H

INT

5.1: Indentation and Tabs

175

C

OMMON

E

RROR

5.1: A Semicolon After the

if

Condition

176

S

PECIAL

T

OPIC

5.1: The Conditional Operator

176

5.2 Comparing Values

177

S

YNTAX

5.2: Comparisons

178

C

OMMON

E

RROR

5.2: Using

==

to Compare Strings

180

Q

UALITY

T

IP

5.2: Avoid Conditions with

Side Effects

183

H

OW

T

O

5.1: Implementing an

if

Statement

183

W

ORKED

E

XAMPLE

5.1: Extracting the Middle

5.3 Multiple Alternatives

185

S

PECIAL

T

OPIC

5.2: The

switch

Statement

187

C

OMMON

E

RROR

5.3: The Dangling

else

Problem

191

P

RODUCTIVITY

H

INT

5.2: Hand-Tracing

192

P

RODUCTIVITY

H

INT

5.3: Make a Schedule and Make

Time for Unexpected Problems

193

S

PECIAL

T

OPIC

5.3: Enumeration Types

194

S

YNTAX

5.3: Declaring an Enumeration Type

194

5.4 Using Boolean Expressions

195

C

OMMON

E

RROR

5.4: Multiple Relational

Operators

199

C

OMMON

E

RROR

5.5: Confusing

&&

and

||

Conditions

199

S

PECIAL

T

OPIC

5.4: Lazy Evaluation of

Boolean Operators

200

S

PECIAL

T

OPIC

5.5: De Morgan’s Law

200

R

ANDOM

F

ACT

5.1: Artificial Intelligence

201

5.5T Code Coverage

202

Q

UALITY TIP 5.3: Calculate Sample Data Manually 203 QUALITY TIP 5.4: Prepare Test Cases Ahead

of Time 204 SPECIAL TOPIC 5.6: Logging 204

bj4_ch05_9.fm Page 172 Friday, October 23, 2009 11:32 AM

5.1 The if Statement 173

There are two problems with this approach. First, if you need to modify the condi- tion amount <= balance for some reason, you must remember to update the condition amount > balance as well. If you do not, the logic of the program will no longer be correct. More importantly, if you modify the value of balance in the body of the first if statement (as in this example), then the second condition uses the new value.

To implement a choice between alternatives, use the if/else statement: if (amount <= balance) balance = balance - amount; else balance = balance - OVERDRAFT_PENALTY;

Now there is only one condition. If it is satisfied, the first statement is executed. Otherwise, the second is executed. The flowchart in Figure 2 gives a graphical rep- resentation of the branching behavior.

Quite often, however, the body of the if statement consists of multiple state- ments that must be executed in sequence whenever the condition is true. These statements must be grouped together to form a block statement by enclosing them in braces { }. Here is an example.

if (amount <= balance) { double newBalance = balance - amount; balance = newBalance; }

In general, the body of an if statement must be a block statement, a simple state- ment, such as

balance = balance - amount;

or a compound statement (another if statement or a loop—see Chapter 6). The else alternative also must be a statement—that is, a simple statement, a compound state- ment, or a block statement.

Figure 1 Flowchart for an if Statement

Figure 2 Flowchart for an if/else Statement

amount ≤ balance?

True

False

balance = balance - amount

Condition

Body

amount ≤ balance?

True False

balance = balance - amount

balance = balance – OVERDRAFT_PENALTY

Condition

A block statement groups several statements together.

bj4_ch05_9.fm Page 173 Friday, October 23, 2009 11:32 AM

174 Chapter 5 Decisions

1. Why did we use the condition amount <= balance and not amount < balance in the example for the if/else statement?

2. What is logically wrong with the statement if (amount <= balance) newBalance = balance - amount; balance = newBalance;

and how do you fix it?

Brace Layout

The compiler doesn’t care where you place braces, but we strongly recommend that you fol- low a simple rule: Line up { and }.

if (amount <= balance) { double newBalance = balance - amount; balance = newBalance; }

This scheme makes it easy to spot matching braces.

Syntax 5.1 The if Statement

if (amount <= balance) { balance = balance - amount; } else { System.out.println("Insufficient funds"); balance = balance - OVERDRAFT_PENALTY; }

A condition that is true or false.

Often uses relational operators: == != < <= > >= (See page 177.)

If the condition is true, the statement(s)

in this branch are executed in sequence;

if the condition is false, they are skipped.

Braces are not required

if the body contains a

single statement.

If condition is false, the statement(s)

in this branch are executed in sequence;

if the condition is true, they are skipped.

Don’t put a semicolon here!

See page 176.

Lining up braces

is a good idea.

See page 174.

Omit the else branch if there is nothing to do.

if (condition) statement

if (condition) statement1 else statement2

Syntax

Example

S E L F C H E C K

Quality Tip 5.1

bj4_ch05_9.fm Page 174 Friday, October 23, 2009 11:32 AM

5.1 The if Statement 175

Some programmers put the opening brace on the same line as the if:

if (amount <= balance) { double newBalance = balance - amount; balance = newBalance; }

This saves a line of code, but it makes it harder to match the braces. It is important that you pick a layout scheme and stick with it. Which scheme you choose

may depend on your personal preference or a coding style guide that you must follow.

Indentation and Tabs

When writing Java programs, use indentation to indicate nesting levels:

public class BankAccount { | . . . | public void withdraw(double amount) | { | | if (amount <= balance) | | { | | | double newBalance = balance - amount; | | | balance = newBalance; | | } | } | . . . } 0 1 2 3 Indentation level

How many spaces should you use per indentation level? Some programmers use eight spaces per level, but that isn’t a good choice:

public class BankAccount { . . . public void withdraw(double amount) { if (amount <= balance) { double newBalance = balance - amount; balance = newBalance; } } . . . }

It crowds the code too much to the right side of the screen. As a consequence, long expres- sions frequently must be broken into separate lines. More common values are two, three, or four spaces per indentation level.

How do you move the cursor from the leftmost column to the appropriate indentation level? A perfectly reasonable strategy is to hit the space bar a sufficient number of times. However, many programmers use the Tab key instead. A tab moves the cursor to the next tab stop. By default, there are tab stops every eight columns, but most editors let you change

Productivity Hint 5.1

bj4_ch05_9.fm Page 175 Friday, October 23, 2009 11:32 AM

176 Chapter 5 Decisions

that value; you should find out how to set your editor’s tab stops to, say, every three columns.

Some editors help you out with an autoindent feature. They automatically insert as many tabs or spaces as the preceding line because the new line is quite likely to belong to the same logical indentation level. If it isn’t, you must add or remove a tab, but that is still faster than tabbing all the way from the left margin.

While the Tab key is nice, some editors use tab characters for alignment, which is not so nice. Tab characters can lead to problems when you send your file to another person or a printer. There is no universal agreement on the width of a tab character, and some software will ignore tab characters altogether. It is therefore best to save your files with spaces instead of tabs. Most editors have settings to automatically convert all tabs to spaces. Look at your development environment’s documentation to find out how to activate this useful setting.

A Semicolon After the if Condition

The following code fragment has an unfortunate error:

if (input < 0) ; // ERROR System.out.println("Bad input);

There should be no semicolon after the if condition. The compiler interprets this statement as follows: If input is less than 0, execute the statement that is denoted by a single semicolon, that is, the do-nothing statement. The statement that follows the semicolon is no longer a part of the if statement. It is always executed—the error message appears for all inputs.

The Conditional Operator

Java has a conditional operator of the form

condition ? value1 : value2

The value of that expression is either value1 if the condition is true or value2 if it is false. For example, we can compute the absolute value as

y = x >= 0 ? x : -x;

which is a convenient shorthand for

if (x >= 0) y = x; else y = -x;

The conditional operator is similar to the if/else statement, but it works on a different syn- tactical level. The conditional operator combines values and yields another value. The if/ else statement combines statements and yields another statement.

For example, it would be an error to write

y = if (x > 0) x; else -x; // Error

The if/else construct is a statement, not a value, and you cannot assign it to a variable. We don’t use the conditional operator in this book, but it is a convenient and legitimate

construct that you will find in many Java programs.

Common Error 5.1

Special Topic 5.1

bj4_ch05_9.fm Page 176 Friday, October 23, 2009 11:32 AM

5.2 Comparing Values 177

A relational operator tests the relationship between two values. An example is the <= operator that we used in the test

if (amount <= balance)

Java has six relational operators:

As you can see, only two relational operators (> and <) look as you would expect from the mathematical notation. Computer keyboards do not have keys for ≥, ≤, or ≠, but the >=, <=, and != operators are easy to remember because they look similar.

The == operator is initially confusing to most newcomers to Java. In Java, the = symbol already has a meaning, namely assignment. The == operator denotes equal- ity testing:

a = 5; // Assign 5 to a if (a == 5) . . . // Test whether a equals 5

You will have to remember to use == for equality testing, and to use = for assignment.

The relational operators have a lower precedence than the arithmetic operators. That means, you can write arithmetic expressions on either side of the relational operator without using parentheses. For example, in the expression

amount + fee <= balance

both sides (amount + fee and balance) of the < operator are evaluated, and the results are compared. Appendix B shows a table of the Java operators and their precedence.

You have to be careful when comparing floating-point numbers, in order to cope with roundoff errors. For example, the following code multiplies the square root of 2 by itself and then subtracts 2.

5.2 Comparing Values 5.2.1 Relational Operators

Relational operators compare values. The == operator tests for equality.

Java Math Notation Description

> > Greater than

>= ≥ Greater than or equal

< < Less than

<= ≤ Less than or equal

== = Equal

!= ≠ Not equal

5.2.2 Comparing Floating-Point Numbers

bj4_ch05_9.fm Page 177 Friday, October 23, 2009 11:32 AM

178 Chapter 5 Decisions

double r = Math.sqrt(2); double d = r * r - 2; if (d == 0) System.out.println("sqrt(2) squared minus 2 is 0"); else System.out.println( "sqrt(2) squared minus 2 is not 0 but " + d);

Even though the laws of mathematics tell us that equals 0, this program fragment prints

sqrt(2) squared minus 2 is not 0 but 4.440892098500626E-16

Unfortunately, such roundoff errors are unavoidable. It plainly does not make sense in most circumstances to compare floating-point numbers exactly. Instead, test whether they are close enough.

To test whether a number x is close to zero, you can test whether the absolute value | x| (that is, the number with its sign removed) is less than a very small thresh- old number. That threshold value is often called ε (the Greek letter epsilon). It is common to set ε to 10–14 when testing double numbers.

Similarly, you can test whether two numbers are approximately equal by check- ing whether their difference is close to 0.

In Java, we program the test as follows: final double EPSILON = 1E-14; if (Math.abs(x - y) <= EPSILON) // x is approximately equal to y

2 2 2( ) −

When comparing floating-point numbers, don’t test for equality. Instead, check whether they are close enough.

x y− ≤ ε

Syntax 5.2 Comparisons

floor > 13

floor == 13

String input; if (input.equals("Y"))

double x; double y; final double EPSILON = 1E-14; if (Math.abs(x - y) < EPSILON)

These quantities are compared.

Checks for equality.

Check that you have

the right direction:

> (greater) or < (less)

Use ==, not =.

One of: == != < <= > >= (See page 177.)

Use equals to compare strings. (See page 180.)

Checks that these floating-point numbers are very close.

See page 178.

Check the boundary condition:

Do you want to include (>=) or exclude (>)?

Examples

bj4_ch05_9.fm Page 178 Friday, October 23, 2009 11:32 AM

5.2 Comparing Values 179

To test whether two strings are equal to each other, you must use the method called equals:

if (string1.equals(string2)) . . .

Do not use the == operator to compare strings. The expression if (string1 == string2) // Not useful

has an unrelated meaning. It tests whether the two string variables refer to the iden- tical string object. You can have strings with identical contents stored in different objects, so this test never makes sense in actual programming; see Common Error 5.2 on page 180.

In Java, letter case matters. For example, "Harry" and "HARRY" are not the same string. To ignore the letter case, use the equalsIgnoreCase method:

if (string1.equalsIgnoreCase(string2)) . . .

If two strings are not identical to each other, you still may want to know the relation- ship between them. The compareTo method compares strings in dictionary order. If

string1.compareTo(string2) < 0

then the string string1 comes before the string string2 in the dictionary. For exam- ple, this is the case if string1 is "Harry", and string2 is "Hello". If

string1.compareTo(string2) > 0

then string1 comes after string2 in dictionary order. Finally, if string1.compareTo(string2) == 0

then string1 and string2 are equal. Actually, the “dictionary” ordering used by Java is slightly different from that of

a normal dictionary. Java is case sensitive and sorts characters by putting numbers first, then uppercase characters, then lowercase characters. For example, 1 comes before B, which comes before a. The space character comes before all other characters.

Let us investigate the comparison process closely. When Java compares two strings, corresponding letters are compared until one of the strings ends or the first difference is encountered. If one of the strings ends, the longer string is considered the later one. If a character mismatch is found, the characters are compared to deter- mine which string comes later in the dictionary sequence. This process is called lex- icographic comparison. For example, let’s compare "car" with "cargo". The first three letters match, and we reach the end of the first string. Therefore "car" comes before "cargo" in the lexicographic ordering. Now compare "cathode" with "cargo". The first two letters match. In the third character position, t comes after r, so the string "cathode" comes after "cargo" in lexicographic ordering. (See Figure 3.)

Figure 3 Lexicographic Comparison

5.2.3 Comparing Strings

Do not use the == operator to compare strings. Use the equals method instead.

The compareTo method compares strings in dictionary order.

c a r g o

c a t h o d

Letters match

e

r comes before t

bj4_ch05_9.fm Page 179 Friday, October 23, 2009 11:32 AM

180 Chapter 5 Decisions

Using == to Compare Strings

It is an extremely common error in Java to write == when equals is intended. This is particu- larly true for strings. If you write

if (nickname == "Rob")

then the test succeeds only if the variable nickname refers to the exact same string object as the string constant "Rob". For efficiency, Java makes only one string object for every string con- stant. Therefore, the following test will pass:

String nickname = "Rob"; . . . if (nickname == "Rob") // Test is true

Table 1 Relational Operator Examples

Expression Value Comment

3 <= 4 true 3 is less than 4; <= tests for “less than or equal”.

3 =< 4 Error The “less than or equal” operator is <=, not =<, with the “less than” symbol first.

3 > 4 false > is the opposite of <=.

4 < 4 false The left-hand side must be strictly smaller than the right-hand side.

4 <= 4 true Both sides are equal; <= tests for “less than or equal”.

3 == 5 - 2 true == tests for equality.

3 != 5 - 1 true != tests for inequality. It is true that 3 is not 5 – 1.

3 = 6 / 2 Error Use == to test for equality.

1.0 / 3.0 == 0.333333333 false Although the values are very close to one another, they are not exactly equal. See Common Error 4.3.

"10" > 5 Error You cannot compare a string to a number.

"Tomato".substring(0, 3).equals("Tom") true Always use the equals method to check whether two strings have the same contents.

"Tomato".substring(0, 3) == ("Tom") false Never use == to compare strings; it only checks whether the strings are stored in the same location. See Common Error 5.2 on page 180.

"Tom".equalsIgnoreCase("TOM") true Use the equalsIgnoreCase method if you don’t want to distinguish between uppercase and lowercase letters.

Common Error 5.2

bj4_ch05_9.fm Page 180 Friday, October 23, 2009 11:32 AM

5.2 Comparing Values 181

However, if the string with the letters R o b has been assembled in some other way, then the test will fail:

String name = "Robert"; String nickname = name.substring(0, 3); . . . if (nickname == "Rob") // Test is false

This is a particularly distressing situation: The wrong code will sometimes do the right thing, sometimes the wrong thing. Because string objects are always constructed by the compiler, you never have an interest in whether two string objects are shared. You must remember never to use == to compare strings. Always use equals or compareTo to compare strings.

If you compare two object references with the == operator, you test whether the ref- erences refer to the same object. Here is an example:

Rectangle box1 = new Rectangle(5, 10, 20, 30); Rectangle box2 = box1; Rectangle box3 = new Rectangle(5, 10, 20, 30);

The comparison box1 == box2

is true. Both object variables refer to the same object. But the comparison box1 == box3

is false. The two object variables refer to different objects (see Figure 4). It does not matter that the objects have identical contents.

You can use the equals method to test whether two rectangles have the same con- tents, that is, whether they have the same upper-left corner and the same width and height. For example, the test

box1.equals(box3)

is true.

5.2.4 Comparing Objects

The == operator tests whether two object references are identical. To compare the contents of objects, you need to use the equals method.

Figure 4 Comparing Object References

box1 =

box2 = x =

Rectangle

y =

width =

height =

5

10

20

g

30

box3 =

x =

Rectangle

y =

width =

height =

5

10

20

g

30

bj4_ch05_9.fm Page 181 Friday, October 23, 2009 11:32 AM

182 Chapter 5 Decisions

However, you must be careful when using the equals method. It works correctly only if the implementors of the class have supplied it. The Rectangle class has an equals method that is suitable for comparing rectangles.

For your own classes, you need to supply an appropriate equals method. You will learn how to do that in Chapter 10. Until that point, you should not use the equals method to compare objects of your own classes.

An object reference can have the special value null if it refers to no object at all. It is common to use the null value to indicate that a value has never been set. For example,

String middleInitial = null; // Not set if ( . . . ) middleInitial = middleName.substring(0, 1);

You use the == operator (and not equals) to test whether an object reference is a null reference:

if (middleInitial == null) System.out.println(firstName + " " + lastName); else System.out.println(firstName + " " + middleInitial + ". " + lastName);

Note that the null reference is not the same as the empty string "". The empty string is a valid string of length 0, whereas a null indicates that a string variable refers to no string at all.

3. What is the value of s.length() if s is a. the empty string ""? b. the string " " containing a space? c. null?

4. Which of the following comparisons are syntactically incorrect? Which of them are syntactically correct, but logically questionable? String a = "1"; String b = "one"; double x = 1; double y = 3 * (1.0 / 3);

a. a == "1" b. a == null c. a.equals("") d. a == b e. a == x f. x == y g. x - y == null h. x.equals(y)

5.2.5 Testing for null

The null reference refers to no object.

S E L F C H E C K

bj4_ch05_9.fm Page 182 Friday, October 23, 2009 11:32 AM

5.2 Comparing Values 183

Avoid Conditions with Side Effects

In Java, it is legal to nest assignments inside test conditions:

if ((d = b * b - 4 * a * c) >= 0) r = Math.sqrt(d);

It is legal to use the decrement operator inside other expressions:

if (n–– > 0) . . .

These are bad programming practices, because they mix a test with another activity. The other activity (setting the variable d, decrementing n) is called a side effect of the test.

As you will see in Special Topic 6.3, conditions with side effects can occasionally be help- ful to simplify loops; for if statements they should always be avoided.

HOW TO 5.1 Implementing an if Statement

This How To walks you through the process of implementing an if statement. We will illus- trate the steps with the following example problem:

The university bookstore has a Kilobyte Day sale every October 24, giving an 8 percent discount on all computer accessory purchases if the price is less than $128, and a 16 percent discount if the price is at least $128. Write a program that asks the cashier for the original price and then prints the discounted price.

Step 1 In our sample problem, the obvious choice for the condition is:

original price < 128?

That is just fine, and we will use that condition in our solution. But you could equally well come up with a correct solution if you choose the opposite

condition: Is the original price at least $128? You might choose this condition if you put yourself into the position of a shopper who wants to know when the bigger discount applies.

Step 2 Give pseudocode for the work that needs to be done when the condition is fulfilled.

In this step, you list the action or actions that are taken in the “positive” branch. The details depend on your problem. You may want to print a message, compute values, or even exit the program.

In our example, we need to apply an 8 percent discount:

discounted price = 0.92 x original price

Step 3 Give pseudocode for the work (if any) that needs to be done when the condition is not ful- filled.

What do you want to do in the case that the condition of Step 1 is not fulfilled? Sometimes, you want to do nothing at all. In that case, use an if statement without an else branch.

In our example, the condition tested whether the price was less than $128. If that condi- tion is not fulfilled, the price is at least $128, so the higher discount of 16 percent applies to the sale:

discounted price = 0.84 x original price

Step 4 Double-check relational operators.

First, be sure that the test goes in the right direction. It is a common error to confuse > and <. Next, consider whether you should use the < operator or its close cousin, the <= operator.

Quality Tip 5.2

bj4_ch05_9.fm Page 183 Friday, October 23, 2009 11:32 AM

184 Chapter 5 Decisions

What should happen if the original price is exactly $128? Reading the problem carefully, we find that the lower discount applies if the original price is less than $128, and the higher discount applies when it is at least $128. A price of $128 should therefore not fulfill our con- dition, and we must use <, not <=.

Step 5 Remove duplication.

Check which actions are common to both branches, and move them outside. (See Quality Tip 4.3.)

In our example, we have two statements of the form

discounted price = ___ x original price

They only differ in the discount rate. It is best to just set the rate in the branches, and to do the computation afterwards:

If original price < 128

discount rate = 0.92

Else

discount rate = 0.84

discounted price = discount rate x original price

Step 6 Test both branches.

Formulate two test cases, one that fulfills the condition of the if statement, and one that does not. Ask yourself what should happen in each case. Then follow the pseudocode and act each of them out.

In our example, let us consider two scenarios for the original price: $100 and $200. We expect that the first price is discounted by $8, the second by $32.

When the original price is 100, then the condition 100 < 128 is true, and we get

discount rate = 0.92

discounted price = 0.92 x 100 = 92

When the original price is 200, then the condition 200 < 128 is false, and

discount rate = 0.84

discounted price = 0.84 x 200 = 168

In both cases, we get the expected answer.

Step 7 Assemble the if statement in Java.

Type the skeleton

if () { } else { }

and fill it in, as shown in Syntax 5.1 on page 174. Omit the else branch if it is not needed. In our example, the completed statement is

double HIGH_DISCOUNT_THRESHOLD = 128; double HIGH_DISCOUNT = 0.92; double LOW_DISCOUNT = 0.84;

if (originalPrice < HIGH_DISCOUNT_THRESHOLD) { discountRate = HIGH_DISCOUNT; } else {

bj4_ch05_9.fm Page 184 Friday, October 23, 2009 11:32 AM

5.3 Multiple Alternatives

185

Available online in WileyPLUS and at

www.wiley.com/college/horstmann

.

discountRate = LOW_DISCOUNT; } discountedPrice = discountRate * originalPrice;

Here we used named constants to make the program more maintainable (see Quality Tip 4.1).

Extracting the Middle

This Worked Example shows how to extract the middle character from a string, or the two middle characters if the length of the string is even.

Many computations require more than a single

if/else

decision. Sometimes, you need to make a series of related comparisons.

The following program asks for a value describing the magnitude of an earth- quake on the Richter scale and prints a description of the likely impact of the quake. The Richter scale is a measurement for the strength of an earthquake. Every step in the scale, for example from 6.0 to 7.0, signifies a tenfold increase in the strength of the quake. The 1989 Loma Prieta earthquake that damaged the Bay Bridge in San Francisco and destroyed many buildings in several Bay area cities registered 7.1 on the Richter scale.

ch05/quake/Earthquake.java

Worked Example 5.1

0 1 2 3 4

c r a t e

5.3 Multiple Alternatives 5.3.1 Sequences of Comparisons

Multiple conditions can be combined to evaluate complex decisions. The correct arrangement depends on the logic of the problem to be solved.

1 /** 2 A class that describes the effects of an earthquake. 3 */ 4 public class Earthquake 5 { 6 private double richter; 7 8 /** 9 Constructs an Earthquake object.

10 @param magnitude the magnitude on the Richter scale 11 */ 12 public Earthquake(double magnitude) 13 { 14 richter = magnitude; 15 } 16 17 /** 18 Gets a description of the effect of the earthquake. 19 @return the description of the effect 20 */ 21 public String getDescription() 22 {

bj4_ch05_9.fm Page 185 Thursday, November 5, 2009 11:38 AM

186 Chapter 5 Decisions

ch05/quake/EarthquakeRunner.java

Program Run

Here we must sort the conditions and test against the largest cutoff first. Suppose we reverse the order of tests:

if (richter >= 0) // Tests in wrong order r = "Generally not felt by people"; else if (richter >= 3.5) r = "Felt by many people, no destruction"; else if (richter >= 4.5) r = "Damage to poorly constructed buildings"; else if (richter >= 6.0) r = "Many buildings considerably damaged, some collapse"; else if (richter >= 7.0) r = "Many buildings destroyed"; else if (richter >= 8.0) r = "Most structures fall";

23 String r; 24 if (richter >= 8.0) 25 r = "Most structures fall"; 26 else if (richter >= 7.0) 27 r = "Many buildings destroyed"; 28 else if (richter >= 6.0) 29 r = "Many buildings considerably damaged, some collapse"; 30 else if (richter >= 4.5) 31 r = "Damage to poorly constructed buildings"; 32 else if (richter >= 3.5) 33 r = "Felt by many people, no destruction"; 34 else if (richter >= 0) 35 r = "Generally not felt by people"; 36 else 37 r = "Negative numbers are not valid"; 38 return r; 39 } 40 }

1 import java.util.Scanner; 2 3 /** 4 This program prints a description of an earthquake of a given magnitude. 5 */ 6 public class EarthquakeRunner 7 { 8 public static void main(String[] args) 9 {

10 Scanner in = new Scanner(System.in); 11 12 System.out.print("Enter a magnitude on the Richter scale: "); 13 double magnitude = in.nextDouble(); 14 Earthquake quake = new Earthquake(magnitude); 15 System.out.println(quake.getDescription()); 16 } 17 }

Enter a magnitude on the Richter scale: 7.1 Many buildings destroyed

bj4_ch05_9.fm Page 186 Friday, October 23, 2009 11:32 AM

5.3 Multiple Alternatives 187

This does not work. All nonnegative values of richter fall into the first case, and the other tests will never be attempted.

In this example, it is also important that we use an if/else if/else test, not just multiple independent if statements. Consider this sequence of independent tests:

if (richter >= 8.0) // Didn’t use else r = "Most structures fall"; if (richter >= 7.0) r = "Many buildings destroyed"; if (richter >= 6.0) r = "Many buildings considerably damaged, some collapse"; if (richter >= 4.5) r = "Damage to poorly constructed buildings"; if (richter >= 3.5) r = "Felt by many people, no destruction"; if (richter >= 0) r = "Generally not felt by people";

Now the alternatives are no longer exclusive. If richter is 6.0, then the last four tests all match, and r is set four times.

The switch Statement

A sequence of if/else if/else that compares a single value against several constant alterna- tives can be implemented as a switch statement. For example,

int digit; . . . switch (digit) { case 1: System.out.print("one"); break; case 2: System.out.print("two"); break; case 3: System.out.print("three"); break; case 4: System.out.print("four"); break; case 5: System.out.print("five"); break; case 6: System.out.print("six"); break; case 7: System.out.print("seven"); break; case 8: System.out.print("eight"); break; case 9: System.out.print("nine"); break; default: System.out.print("error"); break; }

This is a shortcut for

int digit; . . . if (digit == 1) System.out.print("one"); else if (digit == 2) System.out.print("two"); else if (digit == 3) System.out.print("three"); else if (digit == 4) System.out.print("four"); else if (digit == 5) System.out.print("five"); else if (digit == 6) System.out.print("six"); else if (digit == 7) System.out.print("seven"); else if (digit == 8) System.out.print("eight"); else if (digit == 9) System.out.print("nine"); else System.out.print("error");

Special Topic 5.2

bj4_ch05_9.fm Page 187 Friday, October 23, 2009 11:32 AM

188 Chapter 5 Decisions

Using the switch statement has one advantage. It is obvious that all branches test the same value, namely digit.

The switch statement can be applied only in narrow circumstances. The values in the case clauses must be constants. They must be integers, characters, or enumeration constants—or, as of Java 7, strings. You cannot use a switch to branch on floating-point values.

Note how every branch of the switch was terminated by a break instruction. If the break is missing, execution falls through to the next branch, and so on, until finally a break or the end of the switch is reached. For example, consider the following switch statement:

switch (digit) { case 1: System.out.print("one"); // Oops—no break case 2: System.out.print("two"); break; . . . }

If digit has the value 1, then the statement after the case 1: label is executed. Because there is no break, the statement after the case 2: label is executed as well. The program prints "onetwo".

There are a few cases in which this fall-through behavior is actually useful, but they are very rare. Peter van der Linden (Expert C Programming, Prentice-Hall 1994, p. 38) describes an analysis of the switch statements in the Sun C compiler front end. Of the 244 switch state- ments, each of which had an average of 7 cases, only 3 percent used the fall-through behav- ior. That is, the default—falling through to the next case unless stopped by a break—was wrong 97 percent of the time. Forgetting to type the break is an exceedingly common error, yielding incorrect code.

We leave it to you to decide whether or not to use the switch statement. At any rate, you need to have a reading knowledge of switch in case you find it in the code of other programmers.

Some computations have multiple levels of decision making. You first make one decision, and each of the outcomes leads to another decision. Here is a typical example.

In the United States, taxpayers pay federal income tax at different rates depend- ing on their incomes and marital status. There are two main tax schedules: one for single taxpayers and one for married taxpayers “filing jointly”, meaning that the married taxpayers add their incomes together and pay taxes on the total. Table 2 gives the tax rate computations for each of the filing categories, using a simplified version of the values for the 2008 federal tax return.

5.3.2 Nested Branches

Table 2 Federal Tax Rate Schedule (2008, simplified)

If your filing status is Single: If your filing status is Married:

Tax Bracket Percentage Tax Bracket Percentage

$0 . . . $32,000 10% $0 . . . $64,000 10%

Amount over $32,000 25% Amount over $64,000 25%

bj4_ch05_9.fm Page 188 Friday, October 23, 2009 11:32 AM

5.3 Multiple Alternatives 189

Now let us compute the taxes due, given a filing status and an income figure. First, we must branch on the filing status. Then, for each filing status, we must have another branch on income level.

The two-level decision process is reflected in two levels of if statements. We say that the income test is nested inside the test for filing status. (See Figure 5 for a flowchart.)

ch05/tax/TaxReturn.java

Figure 5 Income Tax Computation Using Simplified 2008 Schedule

10% bracket

25% bracket

Single

income ≤ 32,000

10% bracket

25% bracket

income ≤ 64,000

FalseTrue

True

False

True

False

1 /** 2 A tax return of a taxpayer in 2008. 3 */ 4 public class TaxReturn 5 { 6 public static final int SINGLE = 1; 7 public static final int MARRIED = 2; 8 9 private static final double RATE1 = 0.10;

10 private static final double RATE2 = 0.25; 11 private static final double RATE1_SINGLE_LIMIT = 32000; 12 private static final double RATE1_MARRIED_LIMIT = 64000; 13 14 private double income; 15 private int status; 16 17 /** 18 Constructs a TaxReturn object for a given income and 19 marital status. 20 @param anIncome the taxpayer income 21 @param aStatus either SINGLE or MARRIED 22 */ 23 public TaxReturn(double anIncome, int aStatus) 24 { 25 income = anIncome; 26 status = aStatus; 27 } 28

bj4_ch05_9.fm Page 189 Friday, October 23, 2009 11:32 AM

190 Chapter 5 Decisions

ch05/tax/TaxCalculator.java

29 public double getTax() 30 { 31 double tax1 = 0; 32 double tax2 = 0; 33 34 if (status == SINGLE) 35 { 36 if (income <= RATE1_SINGLE_LIMIT) 37 { 38 tax1 = RATE1 * income; 39 } 40 else 41 { 42 tax1 = RATE1 * RATE1_SINGLE_LIMIT; 43 tax2 = RATE2 * (income - RATE1_SINGLE_LIMIT); 44 } 45 } 46 else 47 { 48 if (income <= RATE1_MARRIED_LIMIT) 49 { 50 tax1 = RATE1 * income; 51 } 52 else 53 { 54 tax1 = RATE1 * RATE1_MARRIED_LIMIT; 55 tax2 = RATE2 * (income - RATE1_MARRIED_LIMIT); 56 } 57 } 58 59 return tax1 + tax2; 60 } 61 }

1 import java.util.Scanner; 2 3 /** 4 This program calculates a simple tax return. 5 */ 6 public class TaxCalculator 7 { 8 public static void main(String[] args) 9 {

10 Scanner in = new Scanner(System.in); 11 12 System.out.print("Please enter your income: "); 13 double income = in.nextDouble(); 14 15 System.out.print("Are you married? (Y/N) "); 16 String input = in.next(); 17 int status; 18 if (input.equalsIgnoreCase("Y")) 19 status = TaxReturn.MARRIED; 20 else 21 status = TaxReturn.SINGLE; 22 TaxReturn aTaxReturn = new TaxReturn(income, status); 23

bj4_ch05_9.fm Page 190 Friday, October 23, 2009 11:32 AM

5.3 Multiple Alternatives 191

Program Run

5. The if/else/else statement for the earthquake strength first tested for higher values, then descended to lower values. Can you reverse that order?

6. Some people object to higher tax rates for higher incomes, claiming that you might end up with less money after taxes when you get a raise for working hard. What is the flaw in this argument?

The Dangling else Problem

When an if statement is nested inside another if statement, the following error may occur.

if (richter >= 0) if (richter <= 4) System.out.println("The earthquake is harmless"); else // Pitfall! System.out.println("Negative value not allowed");

The indentation level seems to suggest that the else is grouped with the test richter >= 0. Unfortunately, that is not the case. The compiler ignores all indentation and follows the rule that an else always belongs to the closest if, like this:

if (richter >= 0) if (richter <= 4) System.out.println("The earthquake is harmless"); else // Pitfall! System.out.println("Negative value not allowed");

That isn’t what we want. We want to group the else with the first if. For that, we must use braces.

if (richter >= 0) { if (richter <= 4) System.out.println("The earthquake is harmless"); } else System.out.println("Negative value not allowed");

To avoid having to think about the pairing of the else, we recommend that you always use a set of braces when the body of an if contains another if. In the following example, the braces are not strictly necessary, but they help clarify the code:

if (richter >= 0) { if (richter <= 4) System.out.println("The earthquake is harmless");

24 System.out.println("Tax: " 25 + aTaxReturn.getTax()); 26 } 27 }

Please enter your income: 80000 Are you married? (Y/N) Y Tax: 10400.0

S E L F C H E C K

Common Error 5.3

bj4_ch05_9.fm Page 191 Friday, October 23, 2009 11:32 AM

192 Chapter 5 Decisions

else System.out.println("Damage may occur"); }

The ambiguous else is called a dangling else, and it is enough of a syntactical blemish that some programming language designers developed an improved syntax that avoids it alto- gether. For example, Algol 68 uses the construction

if condition then statement else statement fi;

The else part is optional, but since the end of the if statement is clearly marked, the group- ing is unambiguous if there are two ifs and only one else. Here are the two possible cases:

if c1 then if c2 then s1 else s2 fi fi; if c1 then if c2 then s1 fi else s2 fi;

By the way, fi is just if backwards. Other languages use endif, which has the same purpose but is less fun.

Hand-Tracing

A very useful technique for understanding whether a program works correctly is called hand-tracing. You simulate the program’s activity on a sheet of paper. You can use this method with pseudocode or Java code.

Get an index card, a cocktail napkin, or whatever sheet of paper is within reach. Make a column for each variable. Have the program code ready. Use a marker, such as a paper clip, to mark the current statement. In your mind, execute statements one at a time. Every time the value of a variable changes, cross out the old value and write the new value below the old one.

For example, let’s trace the getTax method with the data from the program run on page 191.

When the TaxReturn object is constructed, the income instance variable is set to 80,000 and status is set to MARRIED. Then the getTax method is called. In lines 31 and 32 of TaxReturn.java, tax1 and tax2 are initialized to 0.

29 public double getTax() 30 { 31 double tax1 = 0; 32 double tax2 = 0; 33

Because status is not SINGLE, we move to the else branch of the outer if statement (line 46).

34 if (status == SINGLE) 35 { 36 if (income <= RATE1_SINGLE_LIMIT) 37 { 38 tax1 = RATE1 * income; 39 } 40 else 41 { 42 tax1 = RATE1 * RATE1_SINGLE_LIMIT; 43 tax2 = RATE2 * (income - RATE1_SINGLE_LIMIT); 44 } 45 } 46 else 47 {

Since income is not <= 64000, we move to the else branch of the inner if statement (line 52).

48 if (income <= RATE1_MARRIED_LIMIT) 49 { 50 tax1 = RATE1 * income; 51 }

Productivity Hint 5.2

income status tax1 tax2

80000 MARRIED 0 0

bj4_ch05_9.fm Page 192 Friday, October 23, 2009 11:32 AM

5.3 Multiple Alternatives 193