Three new chapters. Improved case studies. Reorganization of using objects material. iii

Transcription

1 Preface The newly revised Building Java Programs textbook is designed for use in an introductory course in computer science. The new chapters in this edition will make it useful in a more advanced course in computer science as well. We have class-tested it with thousands of undergraduates at the University of Washington, most of whom were not computer science majors. Introductory computer science courses have a long history at many universities of being killer courses with high failure rates. But as Douglas Adams says in The Hitchhiker s Guide to the Galaxy, Don t panic. Students can master this material if they can learn it gradually. The introductory courses at the University of Washington are experiencing record enrollments and other schools that have adopted our textbook report that students are succeeding with our approach. Since the publication of our first edition, there has been a movement toward the objects later approach that we have championed (as opposed to the objects early approach). We know from years of experience that a broad range of scientists, engineers, and others can learn how to program in a procedural manner. Once we have built a solid foundation of procedural techniques, we turn to object-oriented programming. By the end of the course, students will have learned about both styles of programming. Here are some of the changes that we have made in the second edition: Three new chapters. We have created three new chapters that extend the coverage of the book, using material that we present in our second course in computer science. Chapter 15 explores the issues that arise in the course of implementing a robust and powerful collection class. Chapter 16 explores programming with linked lists, and Chapter 17 explores programming with binary trees. Improved case studies. Chapters 6 and 7 contain new case studies that are more interesting than those included in the first edition. The other case studies throughout the textbook have been expanded to better explain subtle points with which students often struggle. Reorganization of using objects material. Material in Chapters 3, 4, and 6 has been reorganized into a new section in Chapter 7 on reference semantics. We have found that this approach works better for explaining these important concepts. iii

2 iv Preface New section on procedural design heuristics. Chapter 4 now includes a discussion of design guidelines for procedural programming. New section on de Morgan s laws. Chapter 5 has been updated to include a section on de Morgan s laws and their application to programming with boolean expressions. Rebalancing of object coverage. We have adjusted Chapters 8 and 9, which cover objects and inheritance, to provide more coherent coverage of these topics. New appendix on Java language features. A new appendix describes language details not covered in the chapters such as enumerated types and packages. Arrays class coverage. A new section in Chapter 7 includes coverage of the utility methods available from the Arrays class. Expanded self-checks and programming exercises. We have significantly increased the number and quality of self-check exercises and programming exercises incorporating new problems in each chapter. The following features have been retained from the first edition: Focus on problem solving. Many textbooks focus on language details when they introduce new constructs. We focus instead on problem solving. What new problems can be solved with each construct? What pitfalls are novices likely to encounter along the way? What are the most common ways to use a new construct? Emphasis on algorithmic thinking. Our procedural approach allows us to emphasize algorithmic problem solving: breaking a large problem into smaller problems, using pseudocode to refine an algorithm, and grappling with the challenge of expressing a large program algorithmically. Layered approach. Programming in Java involves many concepts that are difficult to learn all at once. Teaching Java to a novice is like trying to build a house of cards. Each new card has to be placed carefully. If the process is rushed and you try to place too many cards at once, the entire structure collapses. We teach new concepts gradually, layer by layer, allowing students to expand their understanding at a manageable pace. Case studies. We end most chapters with a significant case study that shows students how to develop a complex program in stages and how to test it as it is being developed. This structure allows us to demonstrate each new programming construct in a rich context that can t be achieved with short code examples.

3 Preface v Layers and Dependencies Many introductory computer science books are language-oriented, but the early chapters of our book are layered. For example, Java has many control structures (including for loops, while loops, and if/else statements), and many books include all of these control structures in a single chapter. While that might make sense to someone who already knows how to program, it can be overwhelming for a novice who is learning how to program. We find that it is much more effective to spread these control structures into different chapters so that students learn one structure at a time rather than trying to learn them all at once. The following table shows how the layered approach works in the first six chapters: The Layers Programming Chapter Control flow Data techniques Input/Output 1 methods String literals procedural println, print decomposition 2 definite loops (for) variables local variables expressions class constants int, double pseudocode 3 return values using objects parameters console input graphics (optional) 4 conditional char pre/post conditions printf (if/else) throwing exceptions 5 indefinite loops boolean assertions (while) robust programs 6 Scanner token-based processing file input/output line-based processing Chapters 1 6 are designed to be worked through in order, with greater flexibility of study then beginning in Chapter 7. Chapter 6 may be skipped, although the case study in Chapter 7 involves reading from a file, a topic that is covered in Chapter 6.

4 vi Preface The following is a dependency chart for the book: Chapters 1 6 Programming Fundamentals Chapter 7 Arrays Chapter 8 Classes Chapter 12 Recursion Chapter 9 Inheritance and Interfaces Chapter 13 Searching and Sorting Chapter 10 ArrayLists Chapter 14 Graphical User Interfaces Chapter 11 Java Collections Framework Chapter 15 Implementing a Collection Class Chapter 16 Linked Lists Chapter 17 Binary Trees Supplements Answers to all self-check problems appear in Appendix A. In addition, students can access the following resources at or our web site at Source code and data files for all case studies and other complete program examples. The DrawingPanel class used in the optional graphics Supplement 3G. The Practice-It! web programming practice system.

5 Preface vii Instructors can access the following resources from our web site at buildingjavaprograms.com/: PowerPoint slides suitable for lectures. Solutions to exercises and programming projects, along with homework specification documents for many projects. Sample Exams and solution keys. Additional Lab Exercises and Programming Exercises with solution keys. To access protected instructor resources, contact us at The same materials are also available at com/regesstepp/. To receive a password for this site or to ask other questions related to resources, contact your Addison-Wesley sales representative or send to computing@aw.com. Practice-It! For the second edition, we have written a web application called Practice-It! that is available from our web site at This application allows students to practice the exercises from the book and from our introductory programming courses. The system presents a menu of exercises and allows the user to type a solution to a problem and submit it to our server. The system will test the solution and report whether the code solves the problem correctly. For self-checks and University of Washington problems, you may also view the instructor s solutions. Many of our own students have reported that they find this system useful, especially when they are studying for exams. VideoNotes We have recorded a series of instructional videos to accompany the second edition of the textbook. They are available at Roughly 3 4 videos are posted for each chapter. An icon in the margin of the page indicates when a VideoNote is available for a given topic. In each video, we spend 5 15 minutes walking through a particular concept or problem, talking about the challenges and methods necessary to solve it. These videos make a good supplement to the instruction given in lecture classes and in the textbook. Your new copy of the second edition has an access code that will allow you to view the videos. Acknowledgments First, we would like to thank the many students and teaching assistants who have used and commented on early drafts of this text. We could not have written this book without their input. Special thanks go to Hélène Martin, who pored over early versions of these chapters to find errors and to identify rough patches that needed work. We would

6 viii Preface also like to thank instructor Benson Limketkai for spending many hours performing a technical proofread of the second edition. Second, we would like to thank the talented pool of reviewers who guided us in the process of creating this textbook: Greg Anderson, Weber State University Delroy A. Brinkerhoff, Weber State University Ed Brunjes, Miramar Community College Tom Capaul, Eastern Washington University Tom Cortina, Carnegie Mellon University Charles Dierbach, Towson University H.E. Dunsmore, Purdue University Michael Eckmann, Skidmore College Mary Anne Egan, Siena College Leonard J. Garrett, Temple University Ahmad Ghafarian, North Georgia College & State University Raj Gill, Anne Arundel Community College Michael Hostetler, Park University David Hovemeyer, York College of Pennsylvania Chenglie Hu, Carroll College Philip Isenhour, Virginia Polytechnic Institute Andree Jacobson, University of New Mexico David C. Kamper, Sr., Northeastern Illinois University Simon G.M. Koo, University of San Diego Evan Korth, New York University Joan Krone, Denison University John H.E.F. Lasseter, Fairfield University Eric Matson, Wright State University Kathryn S. McKinley, University of Texas, Austin Jerry Mead, Bucknell University George Medelinskas, Northern Essex Community College John Neitzke, Truman State University Dale E. Parson, Kutztown University Richard E. Pattis, Carnegie Mellon University Frederick Pratter, Eastern Oregon University Roger Priebe, University of Texas, Austin Dehu Qi, Lamar University

7 Preface ix John Rager, Amherst College Amala V.S. Rajan, Middlesex University Craig Reinhart, California Lutheran University Mike Scott, University of Texas, Austin Alexa Sharp, Oberlin College Tom Stokke, University of North Dakota Leigh Ann Sudol, Fox Lane High School Ronald F. Taylor, Wright State University Andy Ray Terrel, University of Chicago Scott Thede, DePauw University Megan Thomas, California State University, Stanislaus Dwight Tuinstra, SUNY Potsdam Jeannie Turner, Sayre School Tammy VanDeGrift, University of Portland Thomas John VanDrunen, Wheaton College Neal R. Wagner, University of Texas, San Antonio Jiangping Wang, Webster University Yang Wang, Missouri State University Stephen Weiss, University of North Carolina at Chapel Hill Laurie Werner, Miami University Dianna Xu, Bryn Mawr College Carol Zander, University of Washington, Bothell We would also like to thank the dedicated University of Washington teaching assistants who have added many problems to our Practice-It system: Robert Baxter, Whitaker Brand, Leslie Ferguson, Lisa Fiedler, Jason Ganzhorn, Stefanie Hatcher, Roy McElmurry, Jeff Prouty, Stephanie Smallman, Eric Spishak, and Kimberly Todd. Finally, we would like to thank the great staff at Addison-Wesley who helped produce the book. Michelle Brown, Jeff Holcomb, Maurene Goo, Patty Mahtani, Nancy Kotary, and Kathleen Kenny did great work preparing the first edition. Our copy editors and the staff of Aptara Corp, including Heather Sisan, Brian Baker, Brendan Short, and Rachel Head, caught many errors and improved the quality of the writing. Marilyn Lloyd and Chelsea Bell served well as project manager and editorial assistant respectively. Special thanks go to our editor Matt Goldstein, who has believed in the concept of our book from day one. We couldn t have finished this job without all of their support. Stuart Reges Marty Stepp

8 LOCATION OF VIDEO NOTES IN THE TEXT Chapter 1 Pages, 31, 40 Chapter 2 Pages, 63, 72, 87, 95, 108 Chapter 3 Pages, 136, 151, 156, 162 Chapter 3G Pages, 189, 205 Chapter 4 Pages, 231, 239, 266 Chapter 5 Pages, 310, 313, 315, 319, 342 Chapter 6 Pages, 382, 395, 409 Chapter 7 Pages, 440, 447, 464, 481 Chapter 8 Pages, 505, 517, 525, 538 Chapter 9 Pages, 565, 578, 594 Chapter 10 Pages, 638, 643, 652 Chapter 11 Pages, 680, 693, 701 Chapter 12 Pages, 728, 736, 756 Chapter 13 Pages, 776, 779, 785 Chapter 14 Pages, 823, 836, 855 Chapter 15 Pages, 894, 900, 904 Chapter 16 Pages, 936, 943, 956 Chapter 17 Pages, 1001, 1002, 1012 x

9 Brief Preface iii Chapter 1 Introduction to Java Programming 1 Chapter 2 Primitive Data and Definite Loops 61 Chapter 3 Introduction to Parameters and Objects 132 Supplement 3G Graphics (Optional) 188 Chapter 4 Conditional Execution 226 Chapter 5 Program Logic and Indefinite Loops 301 Chapter 6 File Processing 373 Chapter 7 Arrays 425 Chapter 8 Classes 500 Chapter 9 Inheritance and Interfaces 555 Chapter 10 ArrayLists 628 Chapter 11 Java Collections Framework 679 Chapter 12 Recursion 718 Chapter 13 Searching and Sorting 774 Chapter 14 Graphical User Interfaces 822 Chapter 15 Implementing a Collection Class 886 Chapter 16 Linked Lists 929 Chapter 17 Binary Trees 981 Appendix A Answers to Self-Check Problems 1035 Appendix B Java Summary 1107 Appendix C Javadoc Comments and the Java API Specification 1122 Appendix D Additional Java Syntax 1128 Index 1137 xi

10

11 Preface iii Chapter 1 Introduction to Java Programming Basic Computing Concepts 2 Why Programming? 2 Hardware and Software 3 The Digital Realm 4 The Process of Programming 6 Why Java? 7 The Java Programming Environment And Now Java 10 String Literals (Strings) 14 System.out.println 15 Escape Sequences 15 print versus println 17 Identifiers and Keywords 18 A Complex Example: DrawFigures1 20 Comments and Readability Program Errors 24 Syntax Errors 24 Logic Errors (Bugs) Procedural Decomposition 28 Static Methods 31 Flow of Control 34 Methods that Call Other Methods 36 An Example Runtime Error Case Study: DrawFigures 40 Structured Version 41 Final Version without Redundancy 43 Analysis of Flow of Execution 44 xiii

12 xiv Chapter 2 Primitive Data and Definite Loops Basic Data Concepts 62 Primitive Types 62 Expressions 63 Literals 65 Arithmetic Operators 66 Precedence 68 Mixing Types and Casting Variables 72 Assignment/Declaration Variations 77 String Concatenation 80 Increment/Decrement Operators 82 Variables and Mixing Types The for Loop 87 Tracing for Loops 89 for Loop Patterns 93 Nested for Loops Managing Complexity 97 Scope 97 Pseudocode 103 Class Constants Case Study: Hourglass Figure 108 Problem Decomposition and Pseudocode 109 Initial Structured Version 111 Adding a Class Constant 112 Further Variations 115 Chapter 3 Introduction to Parameters and Objects Parameters 133 The Mechanics of Parameters 136 Limitations of Parameters 140 Multiple Parameters 143 Parameters versus Constants 146 Overloading of Methods Methods That Return Values 147 The Math Class 148 Defining Methods That Return Values 151

13 xv 3.3 Using Objects 155 String Objects 156 Interactive Programs and Scanner Objects 162 Sample Interactive Program Case Study: Projectile Trajectory 168 Unstructured Solution 172 Structured Solution 174 Supplement 3G Graphics (Optional) 188 3G.1 Introduction to Graphics 189 DrawingPanel 189 Drawing Lines and Shapes 190 Colors 195 Drawing with Loops 198 Text and Fonts 202 3G.2 Procedural Decomposition with Graphics 205 A Larger Example: DrawDiamonds 206 3G.3 Case Study: Pyramids 209 Unstructured Partial Solution 210 Generalizing the Drawing of Pyramids 212 Complete Structured Solution 213 Chapter 4 Conditional Execution if/else Statements 227 Relational Operators 229 Nested if/else Statements 231 Object Equality 238 Factoring if/else Statements 239 Multiple Conditions Cumulative Algorithms 242 Cumulative Sum 242 Min/Max Loops 244 Cumulative Sum with if 248 Roundoff Errors Text Processing 253 The char Type 253 char versus int 254

14 xvi Cumulative Text Algorithms 255 System.out.printf Methods with Conditional Execution 262 Preconditions and Postconditions 262 Throwing Exceptions 262 Revisiting Return Values 266 Reasoning about Paths Case Study: Body Mass Index 273 One-Person Unstructured Solution 274 Two-Person Unstructured Solution 277 Two-Person Structured Solution 279 Procedural Design Heuristics 283 Chapter 5 Program Logic and Indefinite Loops The while Loop 302 A Loop to Find the Smallest Divisor 303 Random Numbers 306 Simulations 310 do/while Loop Fencepost Algorithms 313 Sentinel Loops 315 Fencepost with if The boolean Type 319 Logical Operators 321 Short-Circuited Evaluation 324 boolean Variables and Flags 328 Boolean Zen 330 Negating Boolean Expressions User Errors 334 Scanner Lookahead 335 Handling User Errors Assertions and Program Logic 339 Reasoning about Assertions 341 A Detailed Assertions Example Case Study: NumberGuess 347 Initial Version without Hinting 347 Randomized Version with Hinting 349 Final Robust Version 353

15 xvii Chapter 6 File Processing File-Reading Basics 374 Data, Data Everywhere 374 Files and File Objects 374 Reading a File with a Scanner Details of Token-Based Processing 382 Structure of Files and Consuming Input 384 Scanner Parameters 389 Paths and Directories 390 A More Complex Input File Line-Based Processing 395 String Scanners and Line/Token Combinations Advanced File Processing 401 Output Files with PrintStream 401 Guaranteeing That Files Can Be Read Case Study: Zip Code Lookup 409 Chapter 7 Arrays Array Basics 426 Constructing and Traversing an Array 426 Accessing an Array 430 A Complete Array Program 433 Random Access 437 Arrays and Methods 440 The For-Each Loop 443 Initializing Arrays 445 The Arrays Class Array-Traversal Algorithms 447 Printing an Array 448 Searching and Replacing 450 Testing for Equality 453 Reversing an Array 454 String Traversal Algorithms Reference Semantics 460 Multiple Objects 462

16 xviii 7.4 Advanced Array Techniques 464 Shifting Values in an Array 464 Arrays of Objects 469 Command-Line Arguments 470 Nested Loop Algorithms Multidimensional Arrays 473 Rectangular Two-Dimensional Arrays 473 Jagged Arrays Case Study: Benford s Law 479 Tallying Values 481 Completing the Program 485 Chapter 8 Classes Object-Oriented Programming 501 Classes and Objects 502 Point Objects Object State and Behavior 505 Object State: Fields 506 Object Behavior: Methods 508 The Implicit Parameter 511 Mutators and Accessors 513 The tostring Method Object Initialization: Constructors 517 The Keyword this 522 Multiple Constructors Encapsulation 525 Private Fields 526 Class Invariants 532 Changing Internal Implementations Case Study: Designing a Stock Class 538 Object-Oriented Design Heuristics 539 Stock Fields and Method Headers 541 Stock Method and Constructor Implementation 543 Chapter 9 Inheritance and Interfaces Inheritance Basics 556 Nonprogramming Hierarchies 557

17 xix Extending a Class 559 Overriding Methods Interacting with the Superclass 565 Calling Overridden Methods 565 Accessing Inherited Fields 566 Calling a Superclass s Constructor 568 DividendStock Behavior 570 The Object Class 572 The equals Method 573 The instanceof Keyword Polymorphism 578 Polymorphism Mechanics 581 Interpreting Inheritance Code 583 Interpreting Complex Calls Inheritance and Design 588 A Misuse of Inheritance 588 Is-a Versus Has-a Relationships 591 Graphics2D Interfaces 594 An Interface for Shapes 595 Implementing an Interface 597 Benefits of Interfaces Case Study: Financial Class Hierarchy 602 Designing the Classes 603 Redundant Implementation 607 Abstract Classes 610 Chapter 10 ArrayLists ArrayLists 629 Basic ArrayList Operations 630 ArrayList Searching Methods 633 A Complete ArrayList Program 636 Adding to and Removing from an ArrayList 638 Using the For-Each Loop with ArrayLists 642 Wrapper Classes The Comparable Interface 646 Natural Ordering and compareto 648 Implementing the Comparable Interface 652

18 xx 10.3 Case Study: Vocabulary Comparison 656 Some Efficiency Considerations 657 Version 1: Compute Vocabulary 659 Version 2: Compute Overlap 664 Version 3: Complete Program 669 Chapter 11 Java Collections Framework Lists 680 Collections 680 LinkedList versus ArrayList 681 Iterators 684 Abstract Data Types (ADTs) 687 LinkedList Case Study: Sieve Sets 693 Set Concepts 694 TreeSet versus HashSet 696 Set Operations 697 Set Case Study: Lottery Maps 701 Basic Map Operations 702 Map Views (keyset and values) 704 TreeMap versus HashMap 705 Map Case Study: WordCount 706 Collection Overview 709 Chapter 12 Recursion Thinking Recursively 719 A Nonprogramming Example 719 An Iterative Solution Converted to Recursion 722 Structure of Recursive Solutions A Better Example of Recursion 726 Mechanics of Recursion Recursive Functions and Data 736 Integer Exponentiation 736 Greatest Common Divisor 739 Directory Crawler 745 Helper Methods Recursive Graphics (Optional) 752

19 xxi 12.5 Case Study: Prefix Evaluator 756 Infix, Prefix, and Postfix Notation 757 Evaluating Prefix Expressions 757 Complete Program 761 Chapter 13 Searching and Sorting Searching and Sorting in the Java Class Libraries 775 Binary Search 776 Sorting 779 Shuffling 780 Custom Ordering with Comparators Program Complexity 785 Empirical Analysis 788 Complexity Classes Implementing Searching and Sorting Algorithms 794 Sequential Search 795 Binary Search 796 Recursive Binary Search 799 Searching Objects 802 Selection Sort Case Study: Implementing Merge Sort 806 Splitting and Merging Arrays 807 Recursive Merge Sort 810 Complete Program 813 Chapter 14 Graphical User Interfaces GUI Basics 823 Graphical Input and Output with Option Panes 823 Working with Frames 826 Buttons, Text Fields, and Labels 831 Changing a Frame s Layout 833 Handling an Event Laying Out Components 836 Layout Managers 837 Composite Layouts Interaction Between Components 845 Example 1: BMI GUI 845

20 xxii Object-Oriented GUIs 846 Example 2: Credit Card GUI Additional Components and Events 855 Text Areas, Scrollbars, and Fonts 856 Icons 858 Mouse Events Two-Dimensional Graphics 865 Drawing onto Panels 865 Animation with Timers Case Study: Implementing DrawingPanel 872 Initial Version without Events 872 Second Version with Events 874 Chapter 15 Implementing a Collection Class Simple ArrayIntList 887 Adding and Printing 887 Thinking about Encapsulation 893 Dealing with the Middle of the List 894 Another Constructor and a Constant 899 Preconditions and Postconditions A More Complete ArrayIntList 904 Throwing Exceptions 904 Convenience Methods Advanced Features 910 Resizing When Necessary 910 Adding an Iterator ArrayList<E> 918 Chapter 16 Linked Lists Working with Nodes 930 Constructing a List 931 List Basics 933 Manipulating Nodes 936 Traversing a List A Linked List Class 943 Simple LinkedIntList 943

21 xxiii Appending add 945 The Middle of the List A Complex List Operation 956 Inchworm Approach An IntList Interface LinkedList<E> 965 Linked List Variations 966 Linked List Iterators 969 Other Code Details 971 Chapter 17 Binary Trees Binary Tree Basics 982 Node and Tree Classes Tree Traversals 986 Constructing and Viewing a Tree Common Tree Operations 1001 Sum of a Tree 1001 Counting Levels 1002 Counting Leaves Binary Search Trees 1005 The Binary Search Tree Property 1006 Building a Binary Search Tree 1008 The Pattern x = change(x) 1012 Searching the Tree 1015 Binary Search Tree Complexity SearchTree<E> 1020 Appendix A Answers to Self-Check Problems 1035 Appendix B Java Summary 1107 Appendix C Javadoc Comments and the Java API Specification 1122 Appendix D Additional Java Syntax 1128 Index 1137