javanotes7 linked


1 Introduction to Programming Using Java Version 7.0, August 2014 ( Version 7.0.2, with just a few corrections, December 2016 ) David J. Eck Hobart and William Smith Colleges This is a PDF version of a free on-line book that is available a t . The PDF does not include source code files, solutions to exercises, or answers to quiz zes, but it does have external links to these resources, shown in blue . The PDF also has internal links, shown in red. These links can be used in Acrobat Reader and some other PDF reader programs.

2 ii c © 1996–2016, David J. Eck David J. Eck ([email protected]) Department of Mathematics and Computer Science Hobart and William Smith Colleges Geneva, NY 14456 This book can be distributed in unmodified form for non-comme rcial purposes. Modified versions can be made and distributed for non-commer cial purposes provided they are distributed under the same license as the o riginal. More specifically: This work is licensed under the Creative Commo ns Attribution- NonCommercial-ShareAlike 3.0 License. To view a copy of thi s license, visit O ther uses require permission from the author. The web site for this book is: es

3 Contents Preface xi 1 1 The Mental Landscape 1.1 Machine Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.2 Asynchronous Events 1.3 The Java Virtual Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 1.4 Building Blocks of Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 1.5 Object-oriented Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 1.6 The Modern User Interface 1.7 The Internet and Beyond . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 Quiz on Chapter 1 19 2 Names and Things . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.1 The Basic Java Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.2 Variables and Types 2.2.1 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 2.2.2 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.2.3 Literals 2.2.4 Strings and String Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 2.2.5 Variables in Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 2.3 Objects and Subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 2.3.1 Built-in Subroutines and Functions . . . . . . . . . . . . . . . . . . . . . . 30 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 2.3.2 Classes and Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 2.3.3 Operations on Strings 2.3.4 Introduction to Enums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37 2.4 Text Input and Output . . . . . . . . . . . . . . . . . . . . . 38 2.4.1 Basic Output and Formatted Output 2.4.2 A First Text Input Example . . . . . . . . . . . . . . . . . . . . . . . . . . 39 2.4.3 Basic TextIO Input Functions . . . . . . . . . . . . . . . . . . . . . . . . . 41 2.4.4 Introduction to File I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 2.4.5 Other TextIO Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 2.4.6 Using Scanner for Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 2.5 Details of Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 2.5.1 Arithmetic Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 2.5.2 Increment and Decrement . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 2.5.3 Relational Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 2.5.4 Boolean Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 2.5.5 Conditional Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 i

4 CONTENTS ii . . . . . . . . . . . . . . . . 51 2.5.6 Assignment Operators and Type Conversion 2.5.7 Precedence Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 2.6 Programming Environments 2.6.1 Java Development Kit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54 2.6.2 Command Line Environment . . . . . . . . . . . . . . . . . . . . . . . . . 55 2.6.3 Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 2.6.4 NetBeans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 2.6.5 BlueJ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 2.6.6 The Problem of Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 Exercises for Chapter 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 Quiz on Chapter 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 3 Control 67 3.1 Blocks, Loops, and Branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 3.1.1 Blocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 3.1.2 The Basic While Loop 3.1.3 The Basic If Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 3.1.4 Definite Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 3.2 Algorithm Development . . . . . . . . . . . . . . . . . . . . 74 3.2.1 Pseudocode and Stepwise Refinement 3.2.2 The 3N+1 Problem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77 3.2.3 Coding, Testing, Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . 80 3.3 while and do..while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 3.3.1 The while Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 3.3.2 The do..while Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 3.3.3 break and continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 3.4 The for Statement 3.4.1 For Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88 3.4.2 Example: Counting Divisors . . . . . . . . . . . . . . . . . . . . . . . . . . 91 3.4.3 Nested for Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 3.5 The if Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 3.5.1 The Dangling else Problem . . . . . . . . . . . . . . . . . . . . . . . . . . 96 3.5.2 Multiway Branching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97 3.5.3 If Statement Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 3.5.4 The Empty Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 3.6 The switch Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 3.6.1 The Basic switch Statement . . . . . . . . . . . . . . . . . . . . . . . . . . 104 3.6.2 Menus and switch Statements . . . . . . . . . . . . . . . . . . . . . . . . . 106 3.6.3 Enums in switch Statements . . . . . . . . . . . . . . . . . . . . . . . . . 108 3.6.4 Definite Assignment and switch Statements . . . . . . . . . . . . . . . . . 108 3.7 Exceptions and try..catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 3.7.1 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 3.7.2 try..catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 3.7.3 Exceptions in TextIO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 3.8 Introduction to Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 3.8.1 Creating and Using Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . 114 3.8.2 Arrays and For Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

5 CONTENTS iii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 3.8.3 Random Access 3.8.4 Partially Full Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 3.8.5 Two-dimensional Arrays 3.9 GUI Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 3.9.1 Drawing Shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 3.9.2 Drawing in a Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 3.9.3 Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Exercises for Chapter 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 Quiz on Chapter 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 4 Subroutines 135 4.1 Black Boxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 4.2 Static Subroutines and Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 4.2.1 Subroutine Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 4.2.2 Calling Subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 4.2.3 Subroutines in Programs 4.2.4 Member Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143 4.3 Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 4.3.1 Using Parameters . . . . . . . . . . . . . . . . . . . . . . . . 147 4.3.2 Formal and Actual Parameters 4.3.3 Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 4.3.4 Subroutine Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 4.3.5 Array Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 4.3.6 Command-line Arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . 152 4.3.7 Throwing Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 . . . . . . . . . . . . . . . . . . . . . . . . . . 154 4.3.8 Global and Local Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 4.4 Return Values 4.4.1 The return statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 4.4.2 Function Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156 4.4.3 3N+1 Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 4.5 APIs, Packages, and Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 4.5.1 Toolboxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 4.5.2 Java’s Standard Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . 162 4.5.3 Using Classes from Packages . . . . . . . . . . . . . . . . . . . . . . . . . 163 4.5.4 Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 4.5.5 Static Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 4.6 More on Program Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 4.6.1 Preconditions and Postconditions . . . . . . . . . . . . . . . . . . . . . . . 168 4.6.2 A Design Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168 4.6.3 The Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173 4.7 The Truth About Declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 4.7.1 Initialization in Declarations . . . . . . . . . . . . . . . . . . . . . . . . . 175 4.7.2 Named Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 4.7.3 Naming and Scope Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . 180 Exercises for Chapter 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183 Quiz on Chapter 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

6 CONTENTS iv 189 5 Objects and Classes 5.1 Objects and Instance Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 . . . . . . . . . . . . . . . . . . . . . . . . 190 5.1.1 Objects, Classes, and Instances 5.1.2 Fundamentals of Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 5.1.3 Getters and Setters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 5.1.4 Arrays and Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 5.2 Constructors and Object Initialization . . . . . . . . . . . . . . . . . . . . . . . . 199 5.2.1 Initializing Instance Variables . . . . . . . . . . . . . . . . . . . . . . . . . 199 5.2.2 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 5.2.3 Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 5.3 Programming with Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 5.3.1 Some Built-in Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 5.3.2 The class “Object” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 5.3.3 Writing and Using a Class . . . . . . . . . . . . . . . . . . . . . 212 5.3.4 Object-oriented Analysis and Design 5.4 Programming Example: Card, Hand, Deck . . . . . . . . . . . . . . . . . . . . . . 213 5.4.1 Designing the classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 5.4.2 The Card Class . . . . . . . . . . . . . . . . . . . . . . . . 220 5.4.3 Example: A Simple Card Game 5.5 Inheritance and Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 5.5.1 Extending Existing Classes . . . . . . . . . . . . . . . . . . . . . . . . . . 223 5.5.2 Inheritance and Class Hierarchy . . . . . . . . . . . . . . . . . . . . . . . 225 5.5.3 Example: Vehicles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 5.5.4 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 5.5.5 Abstract Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 5.6 this and super 5.6.1 The Special Variable this . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 5.6.2 The Special Variable super . . . . . . . . . . . . . . . . . . . . . . . . . . 235 5.6.3 super and this As Constructors . . . . . . . . . . . . . . . . . . . . . . . . 236 5.7 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 5.7.1 Defining and Implementing Interfaces . . . . . . . . . . . . . . . . . . . . 238 5.7.2 Interfaces as Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 5.7.3 Interfaces in Java 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 5.8 Nested Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 5.8.1 Static Nested Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 5.8.2 Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 5.8.3 Anonymous Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 5.8.4 Java 8 Lambda Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . 245 Exercises for Chapter 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 Quiz on Chapter 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 6 Introduction to GUI Programming 253 6.1 The Basic GUI Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 6.1.1 JFrame and JPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255 6.1.2 Components and Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 6.1.3 Events and Listeners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 6.1.4 Some Java GUI History . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

7 CONTENTS v . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 6.2 Graphics and Painting 6.2.1 Coordinates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262 6.2.2 Colors 6.2.3 Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 6.2.4 Shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 6.2.5 Graphics2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 6.2.6 An Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 6.2.7 Where is main()? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 6.3 Mouse Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 6.3.1 Event Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 6.3.2 MouseEvent and MouseListener . . . . . . . . . . . . . . . . . . . . . . . . 272 6.3.3 MouseEvent Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275 6.3.4 MouseMotionListeners and Dragging . . . . . . . . . . . . . . . . . . . . . 278 . . . . . . . . . . . . . . . . . . . . . . . . . . 281 6.3.5 Anonymous Event Handlers . . . . . . . . . . . . . . . . . . . . . . . 283 6.4 Timers, KeyEvents, and State Machines 6.4.1 Timers and Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 6.4.2 Keyboard Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 6.4.3 Focus Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 6.4.4 State Machines 6.5 Basic Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 6.5.1 JButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 6.5.2 JLabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 6.5.3 JCheckBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 6.5.4 JTextField and JTextArea . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298 6.5.5 JSlider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299 6.6 Basic Layout 6.6.1 Basic Layout Managers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300 6.6.2 Borders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303 6.6.3 SliderAndButtonDemo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305 6.6.4 A Simple Calculator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307 6.6.5 Using a null Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309 6.6.6 A Little Card Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 6.7 Menus and Dialogs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 6.7.1 Menus and Menubars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 6.7.2 Dialogs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 6.7.3 Fine Points of Frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320 6.7.4 Creating Jar Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321 Exercises for Chapter 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324 Quiz on Chapter 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 7 Arrays and ArrayLists 331 7.1 Array Details . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331 7.1.1 For-each Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 7.1.2 Variable Arity Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333 7.1.3 Array Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 7.2 Array Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337 7.2.1 Some Processing Examples . . . . . . . . . . . . . . . . . . . . . . . . . . 337

8 CONTENTS vi . . . . . . . . . . . . . . . . . . . . . . . . 340 7.2.2 Some Standard Array Methods 7.2.3 RandomStrings Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . 341 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345 7.2.4 Dynamic Arrays 7.3 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 7.3.1 ArrayList and Parameterized Types . . . . . . . . . . . . . . . . . . . . . 347 7.3.2 Wrapper Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348 7.3.3 Programming With ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . 350 7.3.4 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353 7.4 Searching and Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 7.4.1 Searching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355 7.4.2 Association Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357 7.4.3 Insertion Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359 7.4.4 Selection Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 7.4.5 Unsorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363 7.5 Two-dimensional Arrays 7.5.1 The Truth About 2D Arrays . . . . . . . . . . . . . . . . . . . . . . . . . 364 7.5.2 Conway’s Game Of Life . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370 7.5.3 Checkers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377 Exercises for Chapter 7 Quiz on Chapter 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381 8 Correctness, Robustness, Efficiency 383 8.1 Introduction to Correctness and Robustness . . . . . . . . . . . . . . . . . . . . . 383 8.1.1 Horror Stories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384 8.1.2 Java to the Rescue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 . . . . . . . . . . . . . . . . . . . . . . . . . . . 387 8.1.3 Problems Remain in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388 8.2 Writing Correct Programs 8.2.1 Provably Correct Programs . . . . . . . . . . . . . . . . . . . . . . . . . . 388 8.2.2 Robust Handling of Input . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 8.3 Exceptions and try..catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 8.3.1 Exceptions and Exception Classes . . . . . . . . . . . . . . . . . . . . . . 396 8.3.2 The try Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398 8.3.3 Throwing Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401 8.3.4 Mandatory Exception Handling . . . . . . . . . . . . . . . . . . . . . . . . 403 8.3.5 Programming with Exceptions . . . . . . . . . . . . . . . . . . . . . . . . 404 8.4 Assertions and Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408 8.4.1 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408 8.4.2 Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411 8.5 Analysis of Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 412 Exercises for Chapter 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418 Quiz on Chapter 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422 9 Linked Data Structures and Recursion 423 9.1 Recursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423 9.1.1 Recursive Binary Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424 9.1.2 Towers of Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426 9.1.3 A Recursive Sorting Algorithm . . . . . . . . . . . . . . . . . . . . . . . . 429 9.1.4 Blob Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431

9 CONTENTS vii . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 9.2 Linked Data Structures 9.2.1 Recursive Linking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437 9.2.2 Linked Lists 9.2.3 Basic Linked List Processing . . . . . . . . . . . . . . . . . . . . . . . . . 438 9.2.4 Inserting into a Linked List . . . . . . . . . . . . . . . . . . . . . . . . . . 441 9.2.5 Deleting from a Linked List . . . . . . . . . . . . . . . . . . . . . . . . . . 443 9.3 Stacks, Queues, and ADTs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444 9.3.1 Stacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445 9.3.2 Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448 9.3.3 Postfix Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453 9.4 Binary Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456 9.4.1 Tree Traversal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 457 9.4.2 Binary Sort Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 459 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463 9.4.3 Expression Trees . . . . . . . . . . . . . . . . . . . . . . . . . . 466 9.5 A Simple Recursive Descent Parser 9.5.1 Backus-Naur Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467 9.5.2 Recursive Descent Parsing . . . . . . . . . . . . . . . . . . . . . . . . . . . 468 . . . . . . . . . . . . . . . . . . . . . . . . . . 472 9.5.3 Building an Expression Tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475 Exercises for Chapter 9 Quiz on Chapter 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478 10 Generic Programming and Collection Classes 481 10.1 Generic Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481 10.1.1 Generic Programming in Smalltalk . . . . . . . . . . . . . . . . . . . . . . 482 10.1.2 Generic Programming in C++ . . . . . . . . . . . . . . . . . . . . . . . . 483 . . . . . . . . . . . . . . . . . . . . . . . . . 484 10.1.3 Generic Programming in Java . . . . . . . . . . . . . . . . . . . . . . . . 485 10.1.4 The Java Collection Framework 10.1.5 Iterators and for-each Loops . . . . . . . . . . . . . . . . . . . . . . . . . . 487 10.1.6 Equality and Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . 489 10.1.7 Generics and Wrapper Classes . . . . . . . . . . . . . . . . . . . . . . . . 491 10.2 Lists and Sets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 10.2.1 ArrayList and LinkedList . . . . . . . . . . . . . . . . . . . . . . . . . . . 492 10.2.2 Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496 10.2.3 TreeSet and HashSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496 10.2.4 EnumSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499 10.2.5 Priority Queues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500 10.3 Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 10.3.1 The Map Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502 10.3.2 Views, SubSets, and SubMaps . . . . . . . . . . . . . . . . . . . . . . . . 503 10.3.3 Hash Tables and Hash Codes . . . . . . . . . . . . . . . . . . . . . . . . . 506 10.4 Programming with the JFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508 10.4.1 Symbol Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 508 10.4.2 Sets Inside a Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510 10.4.3 Using a Comparator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513 10.4.4 Word Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514 10.5 Writing Generic Classes and Methods . . . . . . . . . . . . . . . . . . . . . . . . 517 10.5.1 Simple Generic Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517

10 CONTENTS viii . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519 10.5.2 Simple Generic Methods 10.5.3 Type Wildcards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 524 10.5.4 Bounded Types Exercises for Chapter 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 528 Quiz on Chapter 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532 11 Streams, Files, and Networking 533 11.1 Streams, Readers, and Writers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533 11.1.1 Character and Byte Streams . . . . . . . . . . . . . . . . . . . . . . . . . 534 11.1.2 PrintWriter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535 11.1.3 Data Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 537 11.1.4 Reading Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538 11.1.5 The Scanner Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541 11.1.6 Serialized Object I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 542 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543 11.2 Files . . . . . . . . . . . . . . . . . . . . . . . . . . . 543 11.2.1 Reading and Writing Files 11.2.2 Files and Directories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548 11.2.3 File Dialog Boxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553 11.3 Programming With Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553 11.3.1 Copying a File 11.3.2 Persistent Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556 11.3.3 Files in GUI Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 558 11.3.4 Storing Objects in Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 559 11.4 Networking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567 11.4.1 URLs and URLConnections . . . . . . . . . . . . . . . . . . . . . . . . . . 567 . . . . . . . . . . . . . . . . . . . . . . . . . . 569 11.4.2 TCP/IP and Client/Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571 11.4.3 Sockets in Java 11.4.4 A Trivial Client/Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573 11.4.5 A Simple Network Chat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 577 11.5 A Brief Introduction to XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 580 11.5.1 Basic XML Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581 11.5.2 Working With the DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582 Exercises for Chapter 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588 Quiz on Chapter 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591 12 Threads and Multiprocessing 593 12.1 Introduction to Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593 12.1.1 Creating and Running Threads . . . . . . . . . . . . . . . . . . . . . . . . 594 12.1.2 Operations on Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598 12.1.3 Mutual Exclusion with “synchronized” . . . . . . . . . . . . . . . . . . . . 601 12.1.4 Volatile Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604 12.2 Programming with Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606 12.2.1 Threads Versus Timers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606 12.2.2 Recursion in a Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607 12.2.3 Threads for Background Computation . . . . . . . . . . . . . . . . . . . . 609 12.2.4 Threads for Multiprocessing . . . . . . . . . . . . . . . . . . . . . . . . . . 611 12.2.5 The SwingUtilities Approach . . . . . . . . . . . . . . . . . . . . . . . . . 613 12.3 Threads and Parallel Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . 614

11 CONTENTS ix . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614 12.3.1 Problem Decomposition 12.3.2 Thread Pools and Task Queues . . . . . . . . . . . . . . . . . . . . . . . . 615 . . . . . . . . . . . . . . . . . . 618 12.3.3 Producer/Consumer and Blocking Queues 12.3.4 Wait and Notify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622 12.4 Threads and Networking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 628 12.4.1 The Blocking I/O Problem . . . . . . . . . . . . . . . . . . . . . . . . . . 628 12.4.2 An Asynchronous Network Chat Program . . . . . . . . . . . . . . . . . . 629 12.4.3 A Threaded Network Server . . . . . . . . . . . . . . . . . . . . . . . . . . 633 12.4.4 Using a Thread Pool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635 12.4.5 Distributed Computing . . . . . . . . . . . . . . . . . . . . . . . . . . . . 637 12.5 Network Programming Example . . . . . . . . . . . . . . . . . . . . . . . . . . . 643 12.5.1 The Netgame Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . 644 12.5.2 A Simple Chat Room . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648 . . . . . . . . . . . . . . . . . . . . . . . . 650 12.5.3 A Networked TicTacToe Game . . . . . . . . . . . . . . . . . . . . . . . . . . . 653 12.5.4 A Networked Poker Game Exercises for Chapter 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654 Quiz on Chapter 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 658 659 13 Advanced GUI Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659 13.1 Images and Resources 13.1.1 Images and BufferedImages . . . . . . . . . . . . . . . . . . . . . . . . . . 659 13.1.2 Working With Pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666 13.1.3 Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668 13.1.4 Cursors and Icons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669 13.1.5 Image File I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 671 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672 13.2 Fancier Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 673 13.2.1 Measuring Text 13.2.2 Transparency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 675 13.2.3 Antialiasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677 13.2.4 Strokes and Paints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678 13.2.5 Transforms and Shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 681 13.3 Actions and Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684 13.3.1 Action and AbstractAction . . . . . . . . . . . . . . . . . . . . . . . . . . 684 13.3.2 Icons on Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686 13.3.3 Making Choices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 687 13.3.4 Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 691 13.3.5 Keyboard Accelerators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692 13.3.6 HTML on Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 694 13.4 Complex Components and MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . 695 13.4.1 Model-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695 13.4.2 Lists and ListModels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696 13.4.3 Tables and TableModels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699 13.4.4 Documents and Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703 13.4.5 Custom Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704 13.5 Finishing Touches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709 13.5.1 The Mandelbrot Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 709 13.5.2 Design of the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711

12 CONTENTS x 13.5.3 Internationalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 713 13.5.4 Events, Events, Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 715 13.5.5 Custom Dialogs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 717 13.5.6 Preferences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718 Exercises for Chapter 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720 Quiz on Chapter 13 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723 Appendix: Source Files 725 Glossary 735

13 Preface I is a free introductory computer programming ntroduction to Programming Using Java suitable for use in an introductory textbook that uses Java as the language of instruction. It is gramming on their own. There programming course and for people who are trying to learn pro are no prerequisites beyond a general familiarity with the i deas of computers and programs. There is enough material for a full year of college-level pro gramming. Chapters 1 through 7 can be used as a textbook in a one-semester college-level cou rse or in a year-long high school course. The remaining chapters can be covered in a second cou rse. nt version of Java is 8, but The Seventh Edition of the book covers “Java 7.” The most rece this book has only a few very short mentions of the new feature s in Java 8. . The page at that The home web site for this book is address contains links for downloading a copy of the web site and for downloading PDF versions source code for the sample of the book. The web site—and the web site download—includes hapter quizzes and a discussion and programs that are discussed in the text, answers to end-of-c solution for each end-of-chapter exercises. Readers are en couraged to download the source code he book. Readers are also for the examples and to read and run the programs as they read t strongly encouraged to read the exercise solutions if they w ant to get the most out of this book. In style, this is a textbook rather than a tutorial. That is, i t concentrates on explaining concepts rather than giving step-by-step how-to-do-it gui des. I have tried to use a conversa- tional writing style that might be closer to classroom lectu re than to a typical textbook. This is certainly not a Java reference book, and it is not a compreh ensive survey of all the features of Java. It is not y know another written as a quick introduction to Java for people who alread ds people who are learning program- programming language. Instead, it is directed mainly towar ming concepts as it is about ming for the first time, and it is as much about general program Introduction to Programming using Java is fully competitive Java in particular. I believe that with the conventionally published, printed programming te xtbooks that are available on the market. (Well, all right, I’ll confess that I think it’s bett er.) There are several approaches to teaching Java. One approach uses graphical user interface programming from the very beginning. Some people believe th at object oriented programming should also be emphasized from the very beginning. This is not the approach that I take. The approach that I favor starts with the more basic building blo cks of programming and builds from there. After an introductory chapter, I cover procedur al programming in Chapters 2, 3, and 4. Object-oriented programming is introduced in Chap ter 5. Chapter 6 covers the closely related topic of event-oriented programming and gr aphical user interfaces. Arrays are introduced in Chapter 3 with a full treatment in Chapter 7. Ch apter 8 is a short chapter that marks a turning point in the book, moving beyond the fundamen tal ideas of programming to cover more advanced topics. Chapter 8 is about writing robus t, correct, and efficient programs. Chapters 9 and 10 cover recursion and data structures, inclu ding the Java Collection Framework. Chapter 11 is about files and networking. Chapter 12 covers th reads and parallel processing. xi

14 Preface xii Finally, Chapter 13 returns to the topic of graphical user in terface programming to cover some of Java’s more advanced capabilities. ∗ ∗ ∗ The Seventh Edition of “Introduction to Programming using J ava” is not a huge update from the sixth edition. In fact, my main motivation for the ne w version was to remove any use of applets or coverage of applets from the book. Applets are J ava programs that run on a web page. When Java first came out, they were exciting, and it seem ed like they would become a major way of creating active content for the Web. Up until the sixth edition, the web pages programs. However, because for this book included applets for running many of the sample of security issues and the emergence of other technologies, applets are no longer widely used. Furthermore, the most recent versions of Java made it fairly difficult and unpleasant to use the applets in the book. In place of applets, I have tried to make i t as easy as possible for readers to download the sample programs and run them on their own comp uters. ays are now introduced in Another significant change in the seventh edition is that arr e chapters. Previously, arrays Chapter 3 in a basic form that is used throughout the next thre ogramming had already been were not introduced until Chapter 7, after objects and GUI pr covered. Much of the more advanced coverage of arrays is stil l in Chapter 7. Aside from that, there are many small improvements througho ut, mostly related to features that were new in Java 7. Version 7.0.2 is the final release of th e seventh edition. ∗ ∗ ∗ Introduction to Programming using Java is available on line at The latest complete edition of . The first version of the book was written in 1996, and there ived (at least until my retirement) have been several editions since then. All editions are arch at the following Web addresses: (Covers Java 1.0.) First edition: • (Covers Java 1.1.) • Second edition: • Third edition: (Covers Java 1.1.) (Covers Java 1.4.) Fourth edition: • (Covers Java 5.0.) • Fifth edition: Sixth edition: • (Covers Java 5.0, with a bit of 6.0.) • Seventh edition: (Covers Java 7.) Introduction to Programming using Java is free , but it is not in the pub- lic domain. Version 7 is published under the terms of the Crea tive Commons Attribution-NonCommercial-ShareAlike 3.0 License. To vi ew a copy of this license, visit . For example, you can: • Post an unmodified copy of the on-line version on your own Web s ite (including the parts that list the author and state the license under which it is di stributed!). • Give away unmodified copies of this book or sell them at cost of production, as long as they meet the requirements of the license. • Make modified copies of the complete book or parts of it and pos t them on the web or otherwise distribute them non-commercially, provided tha t attribution to the author is given, the modifications are clearly noted, and the modified c opies are distributed under the same license as the original. This includes translation s to other languages.

15 Preface xiii sion of the author is required. For uses of the book in ways not covered by the license, permis ate hearing from people who While it is not actually required by the license, I do appreci are using or distributing my work. ∗ ∗ ∗ A technical note on production: The on-line and PDF versions of this book are created uce the PDF version, the XML from a single source, which is written largely in XML. To prod g program. In addition to XML is processed into a form that can be used by the TeX typesettin files, the source includes DTDs, XSLT transformations, Java source code files, image files, a TeX macro file, and a couple of scripts that are used in process ing. The scripts work on Linux and on Mac OS. I have made the complete source files available for download at the following address: These files were not originally meant for publication, and th erefore are not very cleanly written. Furthermore, it requires a fair amount of expertis e to use them. However, I have had several requests for the sources and have made them availabl e on an “as-is” basis. For more information about the sources and how they are used see the RE ADME file from the source download. ∗ ∗ ∗ Professor David J. Eck Department of Mathematics and Computer Science Hobart and William Smith Colleges 300 Pulteney Street Geneva, New York 14456, USA Email: [email protected] WWW:

16 Chapter 1 Overview: The Mental Landscape hen you begin a journey, it’s a good idea to have a mental map of the terrain y W ou’ll be y, such as learning to write computer passing through. The same is true for an intellectual journe programs. In this case, you’ll need to know the basics of what computers are and how they work. You’ll want to have some idea of what a computer program is and how one is created. Since you will be writing programs in the Java programming la nguage, you’ll want to know dern computing environment for something about that language in particular and about the mo which Java is designed. As you read this chapter, don’t worry if you can’t understand everything in detail. (In fact, it would be impossible for you to learn all the details from th e brief expositions in this chapter.) Concentrate on learning enough about the big ideas to orient yourself, in preparation for the e covered in much greater detail rest of the book. Most of what is covered in this chapter will b later in the book. 1.1 The Fetch and Execute Cycle: Machine Language computer is a complex system consisting of many different components. But at the A heart—or the brain, if you want—of the computer is a single co mponent that does the actual computing. This is the Central Processing Unit , or CPU. In a modern desktop computer, the CPU is a single “chip” on the order of one square inch in siz e. The job of the CPU is to execute programs. A program owed mechanically is simply a list of unambiguous instructions meant to be foll hat are written in a very simple by a computer. A computer is built to carry out instructions t machine language . Each type of computer has its own machine type of language called ly if the program is expressed in language, and the computer can directly execute a program on guages if they are first translated that language. (It can execute programs written in other lan into machine language.) When the CPU executes a program, that program is stored in the computer’s main mem- ory (also called the RAM or random access memory). In addition to the program, memory can also hold data that is being used or processed by the progr am. Main memory consists of a sequence of locations . These locations are numbered, and the sequence number of a l ocation is called its address . An address provides a way of picking out one particular piec e of informa- tion from among the millions stored in memory. When the CPU ne eds to access the program instruction or data in a particular location, it sends the ad dress of that information as a sig- nal to the memory; the memory responds by sending back the dat a contained in the specified 1

17 CHAPTER 1. THE MENTAL LANDSCAPE 2 cifying the information to be location. The CPU can also store information in memory by spe stored and the address of the location where it is to be stored . airly straightforward (al- On the level of machine language, the operation of the CPU is f though it is very complicated in detail). The CPU executes a p rogram that is stored as a sequence of machine language instructions in main memory. I t does this by repeatedly reading, , an instruction from memory and then carrying out, or executing , that instruc- or fetching another instruction, execute it, and so tion. This process—fetch an instruction, execute it, fetch on forever—is called the fetch-and-execute cycle . With one exception, which will be covered in the next section, this is all that the CPU ever does. The details of the fetch-and-execute cycle are not terribly important, but there are a few basic things you should know. The CPU contains a few internal , which are small registers memory units capable of holding a single number or machine la nguage instruction. The CPU program counter uses one of these registers—the , or PC—to keep track of where it is in the program it is executing. The PC simply stores the memory addr ess of the next instruction that the CPU should execute. At the beginning of each fetch-and-e xecute cycle, the CPU checks the PC to see which instruction it should fetch. During the cours e of the fetch-and-execute cycle, the number in the PC is updated to indicate the instruction th at is to be executed in the next cycle. (Usually, but not always, this is just the instructio n that sequentially follows the current instruction in the program.) ∗ ∗ ∗ A computer executes machine language programs mechanicall y—that is without under- standing them or thinking about them—simply because of the w ay it is physically put together. This is not an easy concept. A computer is a machine built of mi llions of tiny switches called transistors , which have the property that they can be wired together in su ch a way that an mputer computes, these output from one switch can turn another switch on or off. As a co by the way they are wired switches turn each other on or off in a pattern determined both together and by the program that the computer is executing. Machine language instructions are expressed as binary numb ers. A binary number is made s called a bit . So, a machine up of just two possible digits, zero and one. Each zero or one i ch particular sequence encodes language instruction is just a sequence of zeros and ones. Ea some particular instruction. The data that the computer man ipulates is also encoded as binary numbers. In modern computers, each memory location holds a byte , which is a sequence of eight bits. (A machine language instruction or a piece of dat a generally consists of several bytes, stored in consecutive memory locations.) A computer can work directly with binary numbers because swi tches can readily represent such numbers: Turn the switch on to represent a one; turn it off to represent a zero. Machine itches turned on or off. When a language instructions are stored in memory as patterns of sw machine language instruction is loaded into the CPU, all tha t happens is that certain switches on. The CPU is built to respond are turned on or off in the pattern that encodes that instructi to this pattern by executing the instruction it encodes; it d oes this simply because of the way all the other switches in the CPU are wired together. So, you should understand this much about how computers work : Main memory holds machine language programs and data. These are encoded as bin ary numbers. The CPU fetches machine language instructions from memory one after anothe r and executes them. It does this mechanically, without thinking about or understandin g what it does—and therefore the program it executes must be perfect, complete in all details , and unambiguous because the CPU can do nothing but execute it exactly as written. Here is a sch ematic view of this first-stage

18 CHAPTER 1. THE MENTAL LANDSCAPE 3 understanding of the computer: Memory 10001010 (Location 0) 00110100 (Location 1) 01110111 (Location 2) Data to Memory 10100100 (Location 3) 11010010 (Location 4) Data from Memory CPU 10000110 (Location 5) 01001111 (Location 6) 10100000 (Location 7) Program 00000010 (Location 8) counter: Address for 10100010 (Location 9) 0010110111001000 reading/writing 00010100 (Location 10) data . . . 1.2 Asynchronous Events: Polling Loops and Interrupts he CPU spends almost all of its time fetching instructions from memory and executing T components in a real them. However, the CPU and main memory are only two out of many uch as: computer system. A complete system contains other devices s A hard disk or solid state drive for storing programs and data files. (Note that main • memory holds only a comparatively small amount of informati on, and holds it only as long as the power is turned on. A hard disk or solid state drive is used for permanent storage of larger amounts of information, but programs have to be loaded from there into main memory before they can actually be executed. A hard disk stores data on a spinning magnetic disk, while a solid state drive is a purely electron ic device with no moving parts.) • A and mouse for user input. keyboard A and printer which can be used to display the computer’s output. • monitor An audio output device • that allows the computer to play sounds. • A network interface that allows the computer to communicate with other computer s that are connected to it on a network, either wirelessly or by wire. • A scanner that converts images into coded binary numbers that can be st ored and manipulated on the computer. ems are built so that they can The list of devices is entirely open ended, and computer syst easily be expanded by adding new devices. Somehow the CPU has to communicate with and control all these devices. The CPU can only do this by executi ng machine language instructions (which is all it can do, period). The way this works is that for each device in a system, there is a device driver , which consists of software that the CPU executes when it has to deal with the device. Installing a new device on a system generall y has two steps: plugging the device physically into the computer, and installing the dev ice driver software. Without the device driver, the actual physical device would be useless, since the CPU would not be able to communicate with it.

19 CHAPTER 1. THE MENTAL LANDSCAPE 4 ∗ ∗ ∗ A computer system consisting of many devices is typically or ganized by connecting those busses devices to one or more . A bus is a set of wires that carry various sorts of information between the devices connected to those wires. The wires carr y data, addresses, and control signals. An address directs the data to a particular device a nd perhaps to a particular register or location within that device. Control signals can be used, for example, by one device to alert another that data is available for it on the data bus. A fairly simple computer system might be organized like this: Empty Slot CPU for future Memory Disk Drive Expansion Data Input/ Address Output Control Controller Display Keyboard Network Interface Now, devices such as keyboard, mouse, and network interface can produce input that needs to be processed by the CPU. How does the CPU know that the data i s there? One simple idea, which turns out to be not very satisfactory, is for the CPU to k eep checking for incoming data over and over. Whenever it finds data, it processes it. This me thod is called polling , since the CPU polls the input devices continually to see whether th ey have any input data to report. ery inefficient. The CPU can waste Unfortunately, although polling is very simple, it is also v an awful lot of time just waiting for input. To avoid this inefficiency, interrupts are generally used instead of polling. An interrupt is a signal sent by another device to the CPU. The CPU responds to an interrupt signal by nterrupt. Once it has handled putting aside whatever it is doing in order to respond to the i rrupt occurred. For example, when the interrupt, it returns to what it was doing before the inte you press a key on your computer keyboard, a keyboard interru pt is sent to the CPU. The CPU responds to this signal by interrupting what it is doing, reading the key that you pressed, processing it, and then returning to the task it was performi ng before you pressed the key. Again, you should understand that this is a purely mechanica l process: A device signals an interrupt simply by turning on a wire. The CPU is built so that when that wire is turned on, the CPU saves enough information about what it is currently d oing so that it can return to the same state later. This information consists of the conte nts of important internal registers such as the program counter. Then the CPU jumps to some predet ermined memory location and begins executing the instructions stored there. Those i nstructions make up an interrupt handler that does the processing necessary to respond to the interru pt. (This interrupt handler is part of the device driver software for the device that sign aled the interrupt.) At the end of the interrupt handler is an instruction that tells the CPU to jump back to what it was doing; it does that by restoring its previously saved state.

20 CHAPTER 1. THE MENTAL LANDSCAPE 5 asynchronous events . In the regular fetch-and- Interrupts allow the CPU to deal with execute cycle, things happen in a predetermined order; ever ything that happens is “synchro- nized” with everything else. Interrupts make it possible fo r the CPU to deal efficiently with events that happen “asynchronously,” that is, at unpredict able times. As another example of how interrupts are used, consider what happens when the CPU needs to access data that is stored on a hard disk. The CPU can access data directly only if it is in main memory. Data on the disk has to be copied into memory be fore it can be accessed. Unfortunately, on the scale of speed at which the CPU operate s, the disk drive is extremely slow. When the CPU needs data from the disk, it sends a signal t o the disk drive telling it to locate the data and get it ready. (This signal is sent synch ronously, under the control of a regular program.) Then, instead of just waiting the long an d unpredictable amount of time that the disk drive will take to do this, the CPU goes on with so me other task. When the disk drive has the data ready, it sends an interrupt signal to the C PU. The interrupt handler can then read the requested data. ∗ ∗ ∗ Now, you might have noticed that all this only makes sense if t he CPU actually has several tasks to perform. If it has nothing better to do, it might as we ll spend its time polling for input or waiting for disk drive operations to complete. All modern computers use to multitasking perform several tasks at once. Some computers can be used by s everal people at once. Since the CPU is so fast, it can quickly switch its attention from one us er to another, devoting a fraction of a second to each user in turn. This application of multitas king is called timesharing . But a modern personal computer with just a single user also uses mu ltitasking. For example, the user might be typing a paper while a clock is continuously display ing the time and a file is being downloaded over the network. Each of the individual tasks that the CPU is working on is call ed a thread . (Or a process ; there are technical differences between threads and process es, but they are not important here, ally execute more than one since it is threads that are used in Java.) Many CPUs can liter ” each of which can run a thread— thread simultaneously—such CPUs contain multiple “cores, but there is always a limit on the number of threads that can be executed at the same time. Since there are often more threads than can be executed simul taneously, the computer has to be able switch its attention from one thread to another, just as a timesharing computer switches its attention from one user to another. In general, a thread t hat is being executed will continue to run until one of several things happens: • The thread might voluntarily yield control, to give other threads a chance to run. • The thread might have to wait for some asynchronous event to o ccur. For example, the thread might request some data from the disk drive, or it migh t wait for the user to press a key. While it is waiting, the thread is said to be blocked , and other threads, if any, have e up” the thread so that a chance to run. When the event occurs, an interrupt will “wak it can continue running. The thread might use up its allotted slice of time and be suspe nded to allow other threads • to run. Not all computers can “forcibly” suspend a thread in t his way; those that can are said to use preemptive multitasking . To do preemptive multitasking, a computer needs a special timer device that generates an interrupt at regula r intervals, such as 100 times per second. When a timer interrupt occurs, the CPU has a chanc e to switch from one thread to another, whether the thread that is currently runn ing likes it or not. All modern desktop and laptop computers, and even typical smartphones and tablets, use preemptive

21 CHAPTER 1. THE MENTAL LANDSCAPE 6 multitasking. Ordinary users, and indeed ordinary programmers, have no ne ed to deal with interrupts and interrupt handlers. They can concentrate on the different ta sks or threads that they want the computer to perform; the details of how the computer manages to get all those tasks done are not important to them. In fact, most users, and many programm ers, can ignore threads and multitasking altogether. However, threads have become inc reasingly important as computers have become more powerful and as they have begun to make more u se of multitasking and s fast becoming an essential job skill multiprocessing. In fact, the ability to work with threads i for programmers. Fortunately, Java has good support for thr eads, which are built into the Java programming language as a fundamental programming concept . Programming with threads will be covered in . Chapter 12 l is the basic concept of Just as important in Java and in modern programming in genera l with interrupts directly, they do asynchronous events. While programmers don’t actually dea event handlers , which, like interrupt handlers, are called asyn- often find themselves writing chronously when specific events occur. Such “event-driven p rogramming” has a very different feel from the more traditional straight-through, synchron ous programming. We will begin with the more traditional type of programming, which is still use d for programming individual tasks, Chapter 6 but we will return to threads and events later in the text, sta rting in ∗ ∗ ∗ By the way, the software that does all the interrupt handling , handles communication with the user and with hardware devices, and controls which threa d is allowed to run is called the operating system . The operating system is the basic, essential software with out which a computer would not be able to function. Other programs, such as word processors and Web perating systems include Linux, browsers, are dependent upon the operating system. Common o various versions of Windows, and Mac OS. 1.3 The Java Virtual Machine M achine language consists of very simple instructions that can be executed directly by the CPU of a computer. Almost all programs, though, are writt en in high-level programming languages el language cannot such as Java, Fortran, or C++. A program written in a high-lev be run directly on any computer. First, it has to be translate d into machine language. This translation can be done by a program called a compiler . A compiler takes a high-level-language program and translates it into an executable machine-langu age program. Once the translation is done, the machine-language program can be run any number o f times, but of course it can only be run on one type of computer (since each type of computer has its own individual machine language). If the program is to run on another type of compute r it has to be re-translated, using a different compiler, into the appropriate machine lan guage. There is an alternative to compiling a high-level language p rogram. Instead of using a compiler, which translates the program all at once, you can u se an interpreter , which translates it instruction-by-instruction, as necessary. An interpre ter is a program that acts much like a CPU, with a kind of fetch-and-execute cycle. In order to exec ute a program, the interpreter runs in a loop in which it repeatedly reads one instruction fr om the program, decides what is necessary to carry out that instruction, and then performs t he appropriate machine-language commands to do so.

22 CHAPTER 1. THE MENTAL LANDSCAPE 7 ograms. For example, the pro- One use of interpreters is to execute high-level language pr gramming language Lisp is usually executed by an interprete r rather than a compiler. However, hine-language program meant interpreters have another purpose: they can let you use a mac for one type of computer on a completely different type of comp uter. For example, one of the original home computers was the Commodore 64 or “C64”. While you might not find an actual C64, you can find programs that run on other computers—or even in a web browser—that “emulate” one. Such an emulator can run C64 programs by actin g as an interpreter for the C64 machine language. ∗ ∗ ∗ The designers of Java chose to use a combination of compilati on and interpreting. Pro- grams written in Java are compiled into machine language, bu t it is a machine language for al” computer is known as the a computer that doesn’t really exist. This so-called “virtu Java Virtual Machine called Java , or JVM. The machine language for the Java Virtual Machine is . There is no reason why Java bytecode couldn’t be used as the m bytecode achine language of a real computer, rather than a virtual computer. But in fact th e use of a virtual machine makes it can actually be used on any possible one of the main selling points of Java: the fact that computer. All that the computer needs is an interpreter for J ava bytecode. Such an interpreter simulates the JVM in the same way that a C64 emulator simulate s a Commodore 64 computer. (The term JVM is also used for the Java bytecode interpreter p rogram that does the simulation, so we say that a computer needs a JVM in order to run Java progra ms. Technically, it would be more correct to say that the interpreter implements the JVM than to say that it is a JVM.) Of course, a different Java bytecode interpreter is needed fo r each type of computer, but once a computer has a Java bytecode interpreter, it can run an y Java bytecode program, and the same program can be run on any computer that has such an int erpreter. This is one of the essential features of Java: the same compiled program can be run on many different types of computers. Java Interperter for Mac OS Java Java Java Interperter Compiler Bytecode Program for Windows Program Java Interperter for Linux Why, you might wonder, use the intermediate Java bytecode at all? Why not just distribute the original Java program and let each person compile it into the machine language of whatever computer they want to run it on? There are several reasons. Fi rst of all, a compiler has to understand Java, a complex high-level language. The compil er is itself a complex program. A Java bytecode interpreter, on the other hand, is a relative ly small, simple program. This makes it easy to write a bytecode interpreter for a new type of computer; once that is done, that computer can run any compiled Java program. It would be m uch harder to write a Java compiler for the same computer. Furthermore, some Java programs are meant to be downloaded o ver a network. This leads to obvious security concerns: you don’t want to download and run a program that will damage

23 CHAPTER 1. THE MENTAL LANDSCAPE 8 a buffer between you and the your computer or your files. The bytecode interpreter acts as program you download. You are really running the interprete r, which runs the downloaded tentially dangerous actions on the program indirectly. The interpreter can protect you from po part of that program. g slow: Since Java bytecode was When Java was still a new language, it was criticized for bein executed by an interpreter, it seemed that Java bytecode pro grams could never run as quickly as programs compiled into native machine language (that is, the actual machine language of the computer on which the program is running). However, this pro blem has been largely overcome for executing Java bytecode. A just-in-time compiler just-in-time compilers by the use of translates Java bytecode into native machine language. It d oes this while it is executing the program. Just as for a normal interpreter, the input to a just -in-time compiler is a Java bytecode program, and its task is to execute that program. But as it is e xecuting the program, it also translates parts of it into machine language. The translate d parts of the program can then be ince a given part of a program is executed much more quickly than they could be interpreted. S e compiler can significantly speed often executed many times as the program runs, a just-in-tim up the overall execution time. I should note that there is no necessary connection between J ava and Java bytecode. A program written in Java could certainly be compiled into the machine language of a real com- puter. And programs written in other languages can be compil ed into Java bytecode. However, the combination of Java and Java bytecode is platform-indep endent, secure, and network- compatible while allowing you to program in a modern high-le vel object-oriented language. (In the past few years, it has become fairly common to create n ew programming languages, or versions of old languages, that compile into Java bytecod e. The compiled bytecode programs can then be executed by a standard JVM. New languages that hav e been developed specifically for programming the JVM include Groovy, Clojure, and Proces sing. Jython and JRuby are e JVM. These languages make it versions of older languages, Python and Ruby, that target th ding some of the technicalities possible to enjoy many of the advantages of the JVM while avoi of the Java language. In fact, the use of other languages with the JVM has become important enough that several new features have been added to the JVM sp ecifically to add better support for some of those languages. And this improvement to the JVM h as in turn made possible some of the new features in Java 7 and Java 8.) ∗ ∗ ∗ I should also note that the really hard part of platform-inde pendence is providing a “Graph- ical User Interface”—with windows, buttons, etc.—that wil l work on all the platforms that support Java. You’ll see more about this problem in Section 1.6 . 1.4 Fundamental Building Blocks of Programs T here are two basic aspects of programming: data and instructions. To work with data, you need to understand and types ; to work with instructions, you need to variables understand control structures and subroutines . You’ll spend a large part of the course becoming familiar with these concepts. A variable is just a memory location (or several consecutive locations treated as a unit) that has been given a name so that it can be easily referred to a nd used in a program. The programmer only has to worry about the name; it is the compile r’s responsibility to keep track of the memory location. As a programmer, you need to keep in mi nd that the name refers to

24 CHAPTER 1. THE MENTAL LANDSCAPE 9 n’t have to know where in a kind of “box” in memory that can hold data, even though you do memory that box is located. type In Java and in many other programming languages, a variable h that indicates as a what sort of data it can hold. One type of variable might hold i ntegers—whole numbers such as 3, -7, and 0—while another holds floating point numbers—numb ers with decimal points such as 3.14, -2.7, or 17.0. (Yes, the computer does make a distincti on between the integer 17 and the nt inside the computer.) There could floating-point number 17.0; they actually look quite differe also be types for individual characters (’A’, ’;’, etc.), st rings (“Hello”, “A string can include many characters”, etc.), and less common types such as dates , colors, sounds, or any other kind of data that a program might need to store. Programming languages always have commands for getting dat a into and out of variables and for doing computations with data. For example, the follo wing “assignment statement,” ke the number stored in the which might appear in a Java program, tells the computer to ta nd then store the result in the variable named “principal”, multiply that number by 0.07, a variable named “interest”: interest = principal * 0.07; There are also “input commands” for getting data from the use r or from files on the computer’s disks, and there are “output commands” for sending data in th e other direction. These basic commands—for moving data from place to place and for performing computations—are the building blocks for all programs. The se building blocks are combined into complex programs using control structures and subrout ines. ∗ ∗ ∗ A program is a sequence of instructions. In the ordinary “flow of control,” the computer executes the instructions in the sequence in which they occu r in the program, one after the r would soon run out of instructions other. However, this is obviously very limited: the compute Control structures are special instructions that can change the flow of control. to execute. There are two basic types of control structure: loops , which allow a sequence of instructions branches to be repeated over and over, and , which allow the computer to decide between two or more different courses of action by testing conditions tha t occur as the program is running. For example, it might be that if the value of the variable “pri ncipal” is greater than 10000, then the “interest” should be computed by multiplying the pr incipal by 0.05; if not, then the interest should be computed by multiplying the principal by 0.04. A program needs some way of expressing this type of decision. In Java, it could be e xpressed using the following “if statement”: if (principal > 10000) interest = principal * 0.05; else interest = principal * 0.04; (Don’t worry about the details for now. Just remember that th e computer can test a condition and decide what to do next on the basis of that test.) Loops are used when the same task has to be performed more than once. For example, if you want to print out a mailing label for each name on a maili ng list, you might say, “Get the first name and address and print the label; get the second n ame and address and print the label; get the third name and address and print the label. . . ” But this quickly becomes ridiculous—and might not work at all if you don’t know in adva nce how many names there are. What you would like to say is something like “While there are m ore names to process, get the

25 CHAPTER 1. THE MENTAL LANDSCAPE 10 in a program to express such next name and address, and print the label.” A loop can be used repetition. ∗ ∗ ∗ ble to write them if there Large programs are so complex that it would be almost impossi ubroutines provide one way to were not some way to break them up into manageable “chunks.” S do this. A subroutine consists of the instructions for performing some task, grou ped together as a unit and given a name. That name can then be used as a substi tute for the whole set of t your program needs to perform instructions. For example, suppose that one of the tasks tha is to draw a house on the screen. You can take the necessary ins tructions, make them into a subroutine, and give that subroutine some appropriate nam e—say, “drawHouse()”. Then anyplace in your program where you need to draw a house, you ca n do so with the single command: drawHouse(); This will have the same effect as repeating all the house-draw ing instructions in each place. The advantage here is not just that you save typing. Organizi ng your program into sub- routines also helps you organize your thinking and your prog ram design effort. While writing the house-drawing subroutine, you can concentrate on the pr oblem of drawing a house without worrying for the moment about the rest of the program. And onc e the subroutine is written, you can forget about the details of drawing houses—that prob lem is solved, since you have a subroutine to do it for you. A subroutine becomes just like a b uilt-in part of the language which you can use without thinking about the details of what goes on “inside” the subroutine. ∗ ∗ ∗ Variables, types, loops, branches, and subroutines are the basis of what might be called “traditional programming.” However, as programs become la rger, additional structure is needed ools that has been found is object- to help deal with their complexity. One of the most effective t n. oriented programming, which is discussed in the next sectio 1.5 Objects and Object-oriented Programming P rograms must be designed . No one can just sit down at the computer and compose a software engineering program of any complexity. The discipline called is concerned with the construction of correct, working, well-written progra ms. The software engineer tries to use accepted and proven methods for analyzing the problem to be solved and for designing a program to solve that problem. During the 1970s and into the 80s, the primary software engin eering methodology was structured programming . The structured programming approach to program design was based on the following advice: To solve a large problem, brea k the problem into several pieces and work on each piece separately; to solve each piece, treat it as a new problem which can itself be broken down into smaller problems; eventually, you will w ork your way down to problems that can be solved directly, without further decomposition . This approach is called top-down programming . There is nothing wrong with top-down programming. It is a val uable and often-used ap- proach to problem-solving. However, it is incomplete. For o ne thing, it deals almost entirely with producing the instructions necessary to solve a problem. But as time went on, people realized that the design of the data structures for a program was at least as important as the

26 CHAPTER 1. THE MENTAL LANDSCAPE 11 gramming doesn’t give adequate design of subroutines and control structures. Top-down pro consideration to the data that the program manipulates. Another problem with strict top-down programming is that it makes it difficult to reuse work done for other projects. By starting with a particular p roblem and subdividing it into convenient pieces, top-down programming tends to produce a design that is unique to that problem. It is unlikely that you will be able to take a large ch unk of programming from another program and fit it into your project, at least not without exte nsive modification. Producing high-quality programs is difficult and expensive, so program mers and the people who employ them are always eager to reuse past work. ∗ ∗ ∗ So, in practice, top-down design is often combined with bottom-up design . In bottom-up design, the approach is to start “at the bottom,” with proble ms that you already know how to re component at hand). From solve (and for which you might already have a reusable softwa problem. there, you can work upwards towards a solution to the overall A is a component of a The reusable components should be as “modular” as possible. module larger system that interacts with the rest of the system in a s imple, well-defined, straightforward manner. The idea is that a module can be “plugged into” a syste m. The details of what goes on inside the module are not important to the system as a whole, a s long as the module fulfills its assigned role correctly. This is called , and it is one of the most important information hiding principles of software engineering. One common format for software modules is to contain some dat a, along with some sub- routines for manipulating that data. For example, a mailing -list module might contain a list of names and addresses along with a subroutine for adding a new n ame, a subroutine for printing mailing labels, and so forth. In such modules, the data itsel f is often hidden inside the module; a program that uses the module can then manipulate the data on ly indirectly, by calling the since it can only be manipulated subroutines provided by the module. This protects the data, ms to use the module, since they in known, well-defined ways. And it makes it easier for progra don’t have to worry about the details of how the data is repres ented. Information about the representation of the data is hidden. Modules that could support this kind of information-hiding became common in program- d form of the same idea has ming languages in the early 1980s. Since then, a more advance proach is called object-oriented more or less taken over software engineering. This latest ap programming , often abbreviated as OOP. The central concept of object-oriented programming is the object , which is a kind of module containing data and subroutines. The point-of-view in OOP i s that an object is a kind of self- sufficient entity that has an internal state (the data it contains) and that can respond to messages (calls to its subroutines). A mailing list object, for examp le, has a state consisting ng it to add a name, it will of a list of names and addresses. If you send it a message telli respond by modifying its state to reflect the change. If you se nd it a message telling it to print itself, it will respond by printing out its list of names and a ddresses. The OOP approach to software engineering is to start by ident ifying the objects involved in a problem and the messages that those objects should respond to. The program that results is a collection of objects, each with its own data and its own set of responsibilities. The objects interact by sending messages to each other. There is not much “top-down” in the large-scale design of such a program, and people used to more traditional programs can have a hard time getting used to OOP. However, people who use OOP would claim t hat object-oriented programs tend to be better models of the way the world itself works, and that they are therefore easier

27 CHAPTER 1. THE MENTAL LANDSCAPE 12 . to write, easier to understand, and more likely to be correct ∗ ∗ ∗ You should think of objects as “knowing” how to respond to cer tain messages. Different objects might respond to the same message in different ways. F or example, a “print” message would produce very different results, depending on the objec t it is sent to. This property of objects—that different objects can respond to the same messa ge in different ways—is called polymorphism . It is common for objects to bear a kind of “family resemblance ” to one another. Objects that contain the same type of data and that respond to the same messages in the same way class . (In actual programming, the class is primary; that is, a cla belong to the same ss is created and then one or more objects are created using that cl ass as a template.) But objects can be similar without being in exactly the same class. For example, consider a drawing program that lets the user dr aw lines, rectangles, ovals, polygons, and curves on the screen. In the program, each visi ble object on the screen could be represented by a software object in the program. There would be five classes of objects in the program, one for each type of visible object that can be drawn . All the lines would belong to one class, all the rectangles to another class, and so on. The se classes are obviously related; all of them represent “drawable objects.” They would, for ex ample, all presumably be able to respond to a “draw yourself” message. Another level of group ing, based on the data needed to represent each type of object, is less obvious, but would be v ery useful in a program: We can group polygons and curves together as “multipoint objects, ” while lines, rectangles, and ovals points, a rectangle by two of its are “two-point objects.” (A line is determined by its two end ains it. The rectangles that I am corners, and an oval by two corners of the rectangle that cont talking about here have sides that are vertical and horizont al, so that they can be specified by just two points; this is the common meaning of “rectangle” in drawing programs.) We could diagram these relationships as follows: DrawableObject TwoPointObject MultipointObject Oval Polygon Curve Line Rectangle DrawableObject, MultipointObject, and TwoPointObject wo uld be classes in the program. MultipointObject and TwoPointObject would be of DrawableObject. The class subclasses Line would be a subclass of TwoPointObject and (indirectly) of DrawableObject. A subclass of a class is said to inherit the properties of that class. The subclass can add to its inhe ritance and it can even “override” part of that inheritance (by defining a different response to some method). Nevertheless, lines, rectangles, and so on are drawable objects, and the class DrawableObject expresses this relationship. Inheritance is a powerful means for organizing a program. It is also related to the problem of reusing software components. A class is the ultimate reus able component. Not only can it

28 CHAPTER 1. THE MENTAL LANDSCAPE 13 ing to write, but if it just almost be reused directly if it fits exactly into a program you are try fits, you can still reuse it by defining a subclass and making on ly the small changes necessary to adapt it exactly to your needs. ol and a partial solution So, OOP is meant to be both a superior program-development to -oriented programming will be to the software reuse problem. Objects, classes, and object important themes throughout the rest of this text. You will s tart using objects that are built into the Java language in the next chapter, and in Chapter 5 you will begin creating your own classes and objects. 1.6 The Modern User Interface W hen computers were first introduced , ordinary people—including most programmers— e-coated attendants who would couldn’t get near them. They were locked up in rooms with whit turn the computer’s response take your programs and data, feed them to the computer, and re hes its attention rapidly from some time later. When timesharing—where the computer switc ssible for several people to one person to another—was invented in the 1960s, it became po interact directly with the computer at the same time. On a tim esharing system, users sit at “terminals” where they type commands to the computer, and th e computer types back its re- sponse. Early personal computers also used typed commands a nd responses, except that there was only one person involved at a time. This type of interacti on between a user and a computer is called a command-line interface . Today, of course, most people interact with computers in a co mpletely different way. They use a Graphical User Interface , or GUI. The computer draws interface components on the screen. The components include things like windows, scroll bars, menus, buttons, and icons. mouse ” your fingers. Usually, a is used to manipulate such components or, on “touchscreens, Assuming that you have not just been teleported in from the 19 70s, you are no doubt already familiar with the basics of graphical user interfaces! d. That is, they have similar A lot of GUI interface components have become fairly standar s including Mac OS, Windows, appearance and behavior on many different computer platform and Linux. Java programs, which are supposed to run on many di fferent platforms without modification to the program, can use all the standard GUI comp onents. They might vary a little in appearance from platform to platform, but their fu nctionality should be identical on any computer on which the program runs. Shown below is an image of a very simple Java program that demo nstrates a few standard GUI interface components. When the program is run, a window s imilar to the picture shown here will open on the computer screen. There are four compone nts in the window with which the user can interact: a button, a checkbox, a text field, and a pop -up menu. These components are labeled. There are a few other components in the window. T he labels themselves are components (even though you can’t interact with them). The r ight half of the window is a text area component, which can display multiple lines of tex t. A scrollbar component appears alongside the text area when the number of lines of text becom es larger than will fit in the text area. And in fact, in Java terminology, the whole window is itself considered to be a “component.”

29 CHAPTER 1. THE MENTAL LANDSCAPE 14 , as well as a compiled (If you would like to run this program, the source code, , are available on line. For more information on using this an GUIDemo.jar d other program, examples from this textbook, see Section 2.6 .) Now, Java actually has two complete sets of GUI components. O ne of these, the AWT or Abstract Windowing Toolkit , was available in the original version of Java. The other, wh ich Swing , was introduced in Java version 1.2, and is used in preferenc e to the AWT is known as uses components that are in most modern Java programs. The program that is shown above part of Swing. When a user interacts with GUI components, “events” are gene rated. For example, clicking a push button generates an event, and pressing return while t yping in a text field generates an event. Each time an event is generated, a message is sent to th e program telling it that the event has occurred, and the program responds according to it s program. In fact, a typical GUI program consists largely of “event handlers” that tell the p rogram how to respond to various types of events. In this example, the program has been progra mmed to respond to each event by displaying a message in the text area. In a more realistic e xample, the event handlers would have more to do. The use of the term “message” here is deliberate. Messages, a s you saw in the previous sec- plemented as objects. Java tion, are sent to objects. In fact, Java GUI components are im includes many predefined classes that represent various typ es of GUI components. Some of these classes are subclasses of others. Here is a diagram sho wing just a few of Swing’s GUI classes and their relationships: J Component JAbstractButton JComboBox JSlider JTextComponent JLabel JToggleButton JButton JTextField JTextArea JCheckBox JRadioButton Don’t worry about the details for now, but try to get some feel about how object-oriented programming and inheritance are used here. Note that all the GUI classes are subclasses, directly or indirectly, of a class called JComponent , which represents general properties that are shared by all Swing components. In the diagram, two of the dir ect subclasses of JComponent themselves have subclasses. The classes JTextArea and JTextField , which have certain behaviors

30 CHAPTER 1. THE MENTAL LANDSCAPE 15 JTextComponent . Similarly and in common, are grouped together as subclasses of JButton JAbstractButton are subclasses of JToggleButton , which represents properties common to both buttons and checkboxes. ( JComboBox , by the way, is the Swing class that represents pop-up menus.) Just from this brief discussion, perhaps you can see how GUI p rogramming can make effec- tive use of object-oriented design. In fact, GUIs, with thei r “visible objects,” are probably a major factor contributing to the popularity of OOP. Programming with GUI components and events is one of the most interesting aspects of Java. However, we will spend several chapters on the basics b efore returning to this topic in Chapter 6 . 1.7 The Internet and Beyond omputers can be connected C networks . A computer on a network can together on anging data and files or by communicate with other computers on the same network by exch ven work together on a large sending and receiving messages. Computers on a network can e computation. Today, millions of computers throughout the world are conne cted to a single huge network Internet . New computers are being connected to the Internet every day called the , both by wireless communication and by physical connection using technologies such as DSL, cable modems, and Ethernet. There are elaborate protocols for communication over the Internet. A protocol is simply a detailed specification of how communication is to proceed. F or two computers to communicate at all, they must both be using the same protocols. The most ba sic protocols on the Internet are the Internet Protocol d from one (IP), which specifies how data is to be physically transmitte Transmission Control Protocol computer to another, and the (TCP), which ensures that data sent using IP is received in its entirety and without err or. These two protocols, which are referred to collectively as TCP/IP, provide a foundation fo r communication. Other protocols use TCP/IP to send specific types of information such as web pa ges, electronic mail, and data files. All communication over the Internet is in the form of packets . A packet consists of some essing information that indicates data being sent from one computer to another, along with addr where on the Internet that data is supposed to go. Think of a pa cket as an envelope with an address on the outside and a message on the inside. (The messa ge is the data.) The packet also includes a “return address,” that is, the address of the sender. A packet can hold only a limited amount of data; longer messages must be divided amo ng several packets, which are then sent individually over the net and reassembled at their destination. IP address , a number that identifies it uniquely Every computer on the Internet has an among all the computers on the net. (Actually, the claim abou t uniqueness is not quite true, but the basic idea is valid, and the full truth is complicated.) T he IP address is used for addressing packets. A computer can only send data to another computer on the Internet if it knows that computer’s IP address. Since people prefer to use names rath er than numbers, most computers are also identified by names, called . For example, the main computer of domain names the Mathematics Department at Hobart and William Smith Coll eges has the domain name (Domain names are just for convenience; your computer still needs to know IP addresses before it can communicate. There are computers on the Internet whose job it is to translate domain names to IP addresses. When you use a do main name, your computer

31 CHAPTER 1. THE MENTAL LANDSCAPE 16 nding IP address. Then, your sends a message to a domain name server to find out the correspo computer uses the IP address, rather than the domain name, to communicate with the other computer.) onnected to it (and, of course, The Internet provides a number of services to the computers c o send various types of data over to the users of those computers). These services use TCP/IP t the net. Among the most popular services are instant messagi ng, file sharing, electronic mail, and the World-Wide Web. Each service has its own protocols, w hich are used to control transmission of data over the network. Each service also has some sort of user interface, which allows the user to view, send, and receive data through the se rvice. For example, the email service uses a protocol known as SMTP (Simple Mail Transfer Protocol) to transfer email messages from one computer to an other. Other protocols, such as POP and IMAP, are used to fetch messages from an email account so that the recipient can read them. A person who uses email, however, doesn’t need to u nderstand or even know about these protocols. Instead, they are used behind the scenes by computer programs to send and h an easy-to-use user interface to receive email messages. These programs provide the user wit the underlying network protocols. The World-Wide Web is perhaps the most exciting of network se rvices. The World-Wide Web allows you to request pages of information that are stored on computers all over the links to other pages on the same computer from which it Internet. A Web page can contain mputer that stores such pages was obtained or to other computers anywhere in the world. A co of information is called a web server . The user interface to the Web is the type of program known as a web browser . Common web browsers include Internet Explorer, Firefox, C hrome, and Safari. You use a Web browser to request a page of informat ion. The browser sends a request for that page to the computer on which the page is stor ed, and when a response is ou in a neatly formatted form. received from that computer, the web browser displays it to y enes, the web browser uses a A web browser is just a user interface to the Web. Behind the sc protocol called HTTP (HyperText Transfer Protocol) to send each page request and to receive the response from the web server. ∗ ∗ ∗ ith Java? In fact, Java Now just what, you might be thinking, does all this have to do w de Web. When Java was first is intimately associated with the Internet and the World-Wi introduced, one of its big attractions was the ability to wri te applets . An applet is a small program that is transmitted over the Internet and that runs o n a web page. Applets make it possible for a web page to perform complex tasks and have comp lex interactions with the user. Alas, applets have suffered from a variety of security proble ms, and fixing those problems has made them more difficult to use. Applets have become much less c ommon on the Web, and in pages. any case, there are other options for running programs on Web But applets are only one aspect of Java’s relationship with t he Internet. Java can be used to write complex, stand-alone applications that do not depend on a Web browser. Many of these programs are network-related. For example many of the large st and most complex web sites use web server software that is written in Java. Java include s excellent support for network protocols, and its platform independence makes it possible to write network programs that work on many different types of computer. You will learn about Java’s network support in Chapter 11 . Its support for networking is not Java’s only advantage. But many good programming languages have been invented only to be soon forgotten. Java has had the good luck to ride on the coattails of the Internet’s immense and increasing popu larity.

32 CHAPTER 1. THE MENTAL LANDSCAPE 17 ∗ ∗ ∗ As Java has matured, its applications have reached far beyon d the Net. The standard version of Java already comes with support for many technologies, su ch as cryptography and data compression. Free extensions are available to support many other technologies such as advanced sound processing and three-dimensional graphics. Complex , high-performance systems can be ale data processing, is written in developed in Java. For example, Hadoop, a system for large sc o process the huge amounts Java. Hadoop is used by Yahoo, Facebook, and other Web sites t of data generated by their users. Furthermore, Java is not restricted to use on traditional co mputers. Java can be used to write programs for many smartphones (though not for the iPho ne). It is the primary develop- ment language for Android-based devices. (Some mobile devi ces use a version of Java called Java ME (“Mobile Edition”), but Android uses Google’s own ve rsion of Java and does not use the same graphical user interface components as standard Ja va.) Java is also the programming language for the Amazon Kindle eBook reader and for interact ive features on Blu-Ray video disks. At this time, Java certainly ranks as one of the most widely us ed programming languages. It is a good choice for almost any programming project that is meant to run on more than one type of computing device, and is a reasonable choice even for many programs that will run on only one device. It is probably still the most widely ta ught language at Colleges and Universities. It is similar enough to other popular languag es, such as C, C++, and Python, that knowing it will give you a good start on learning those la nguages as well. Overall, learning Java is a great starting point on the road to becoming an exper t programmer. I hope you enjoy the journey!

33 Quiz 18 Quiz on Chapter 1 (answers) One of the components of a computer is its CPU. What is a CPU and what role does it 1. play in a computer? 2. Explain what is meant by an “asynchronous event.” Give some e xamples. 3. er”? What is the difference between a “compiler” and an “interpret 4. Explain the difference between high-level languages and machine language. 5. If you have the source code for a Java program, and you want to r un that program, you will need both a compiler and an interpreter. What does the Java compiler do, and what does the Java interpreter do? What is a subroutine? 6. 7. Java is an object-oriented programming language. What is an object ? 8. What is a variable? (There are four different ideas associated with variables in Java. Try to mention all four aspects in your answer. Hint: One of the as pects is the variable’s name.) 9. Java is a “platform-independent language.” What does this m ean? 10. What is the “Internet”? Give some examples of how it is used. ( What kind of services does it provide?)

34 Chapter 2 Programming in the Small I: Names and Things O very simple n a basic level (the level of machine language), a computer can perform only together large numbers of such operations. A computer performs complex tasks by stringing operations. Such tasks must be “scripted” in complete and pe rfect detail by programs. Creating can be handled to some extent by complex programs will never be really easy, but the difficulty giving the program a clear overall structure . The design of the overall structure of a program is what I call “programming in the large.” Programming in the small, which is sometimes called , would then refer to filling in coding the details of that design. The details are the explicit, ste p-by-step instructions for performing g “close to the machine,” with some fairly small-scale tasks. When you do coding, you are workin emory locations, arithmetic of the same concepts that you might use in machine language: m ch as Java, you get to work with operations, loops and branches. In a high-level language su ge. However, you still have to these concepts on a level several steps above machine langua worry about getting all the details exactly right. This chapter and the next examine the facilities for program ming in the small in the Java programming language. Don’t be misled by the term “programm ing in the small” into thinking that this material is easy or unimportant. This material is a n essential foundation for all types rograms, no matter how good of programming. If you don’t understand it, you can’t write p you get at designing their large-scale structure. The last section of this chapter discusses programming environments . That section contains information about how to compile and run Java progr ams, and you should take a look at it before trying to write and use your own programs or tryin g to use the sample programs in this book. 2.1 The Basic Java Application A program is a sequence of instructions that a computer can execute to perform some task. A simple enough idea, but for the computer to make any us e of the instructions, they must be written in a form that the computer can use. This means that programs have to be written in programming languages . Programming languages differ from ordinary human languages in being completely unambiguous and very strict a bout what is and is not allowed in a program. The rules that determine what is allowed are cal led the syntax of the language. Syntax rules specify the basic vocabulary of the language an d how programs can be constructed 19

35 CHAPTER 2. NAMES AND THINGS 20 ctically correct program is one that using things like loops, branches, and subroutines. A synta can be successfully compiled or interpreted; programs that have syntax errors will be rejected he problem). (hopefully with a useful error message that will help you fix t So, to be a successful programmer, you have to develop a detai led knowledge of the syntax of the programming language that you are using. However, syn tax is only part of the story. It’s not enough to write a program that will run—you want a program that will run and produce of the program has to be right. The meaning of the correct result! That is, the meaning . More correctly, the semantics of a programming semantics a program is referred to as its language is the set of rules that determine the meaning of a pr ogram written in that language. A semantically correct program is one that does what you want it to. ly correct but still be a pretty Furthermore, a program can be syntactically and semantical sing it bad program. Using the language correctly is not the same as u . For example, a well it easy for people to read and good program has “style.” It is written in a way that will make to other programmers. And it has to understand. It follows conventions that will be familiar an overall design that will make sense to human readers. The c omputer is completely oblivious to such things, but to a human reader, they are paramount. The se aspects of programming are pragmatics sometimes referred to as style .) . (I will often use the more common term When I introduce a new language feature, I will explain the sy ntax, the semantics, and some of the pragmatics of that feature. You should memorize t he syntax; that’s the easy part. Then you should get a feeling for the semantics by following t he examples given, making sure that you understand how they work, and, ideally, writing sho rt programs of your own to test your understanding. And you should try to appreciate and abs orb the pragmatics—this means well learning how to use the language feature , with style that will earn you the admiration of other programmers. Of course, even when you’ve become familiar with all the indi vidual features of the language, that doesn’t make you a programmer. You still have to learn ho w to construct complex programs to solve particular problems. For that, you’ll need both exp erience and taste. You’ll find hints about software development throughout this textbook. ∗ ∗ ∗ We begin our exploration of Java with the problem that has bec ome traditional for such beginnings: to write a program that displays the message “He llo World!”. This might seem like a trivial problem, but getting a computer to do this is really a big first step in learning a new programming language (especially if it’s your first program ming language). It means that you understand the basic process of: 1. getting the program text into the computer, 2. compiling the program, and running the compiled program. 3. The first time through, each of these steps will probably take you a few tries to get right. I won’t go into the details here of how you do each of these steps ; it depends on the particular computer and Java programming environment that you are usin g. See Section 2.6 for informa- tion about creating and running Java programs in specific pro gramming environments. But in general, you will type the program using some sort of text edi tor and save the program in a file. Then, you will use some command to try to compile the file. You’ ll either get a message that the program contains syntax errors, or you’ll get a compiled ver sion of the program. In the case of Java, the program is compiled into Java bytecode, not into ma chine language. Finally, you can run the compiled program by giving some appropriate command . For Java, you will actually use

36 CHAPTER 2. NAMES AND THINGS 21 ng environment might automate an interpreter to execute the Java bytecode. Your programmi some of the steps for you—for example, the compilation step i s often done automatically—but ackground. you can be sure that the same three steps are being done in the b Here is a Java program to display the message “Hello World!”. Don’t expect to understand what’s going on here just yet; some of it you won’t really unde rstand until a few chapters from now: /** A program to display the message * "Hello World!" on standard output. */ public class HelloWorld { public static void main(String[] args) { System.out.println("Hello World!"); } } // end of class HelloWorld The command that actually displays the message is: System.out.println("Hello World!"); subroutine call statement This command is an example of a . It uses a “built-in subroutine” named to do the actual work. Recall that a subroutine consists of th e System.out.println d given a name. That name can be instructions for performing some task, chunked together an erformed. A built-in subroutine used to “call” the subroutine whenever that task needs to be p fore automatically available for is one that is already defined as part of the language and there use in any program. When you run this program, the message “Hello World!” (withou t the quotes) will be displayed on standard output. Unfortunately, I can’t say ex actly what that means! Java is meant to run on many different platforms, and standard output will mean different things on different platforms. However, you can expect the message to s how up in some convenient or inconvenient place. (If you use a command-line interface, l ike that in Oracle’s Java Development Kit, you type in a command to tell the computer to run the progr am. The computer will type n an integrated development the output from the program, Hello World!, on the next line. I ere in one of the environment’s environment such as Eclipse, the output might appear somewh windows.) You must be curious about all the other stuff in the above progr am. Part of it consists of comments . Comments in a program are entirely ignored by the computer; they are there for human readers only. This doesn’t mean that they are unimport ant. Programs are meant to be read by people as well as by computers, and without comments, a program can be very difficult to understand. Java has two types of comments. The first type b egins with // and extends to the end of a line. There is a comment of this form on the last lin e of the above program. The computer ignores the // and everything that follows it on the same line. The second ty pe of comment starts with and ends with */ , and it can extend over more than one line. The first /* three lines of the program are an example of this second type o f comment. (A comment that actually begins with /** , like this one does, has special meaning; it is a “Javadoc” co mment that can be used to produce documentation for the program.) Everything else in the program is required by the rules of Jav a syntax. All programming in Java is done inside “classes.” The first line in the above prog ram (not counting the comment) says that this is a class named HelloWorld . “HelloWorld,” the name of the class, also serves as

37 CHAPTER 2. NAMES AND THINGS 22 to define a program, a class the name of the program. Not every class is a program. In order , with a definition that takes the form: must include a subroutine named main public static void main(String[] args) { statements 〈 〉 } When you tell the Java interpreter to run the program, the int erpreter calls this main() subroutine, and the statements that it contains are execute d. These statements make up the gram is executed. The script that tells the computer exactly what to do when the pro main() routine can call other subroutines that are defined in the sam e class or even in other classes, but it is the main() routine that determines how and in what order the other subro utines are used. main() The word “public” in the first line of means that this routine can be called from out- side the program. This is essential because the routine is called by the Java interpreter, main() nder of the first line of the routine which is something external to the program itself. The remai part of the required syntax. is harder to explain at the moment; for now, just think of it as The definition of the subroutine—that is, the instructions t hat say what it does—consists of { and } . Here, I’ve used 〈 the sequence of “statements” enclosed between braces, 〉 as statements a placeholder for the actual statements that make up the prog ram. Throughout this textbook, I will always use a similar format: anything that you see in 〈 this style of text 〉 (italic in angle brackets) is a placeholder that describes something you nee d to type when you write an actual program. As noted above, a subroutine can’t exist by itself. It has to b e part of a “class”. A program is defined by a public class that takes the form: public class program-name 〉 { 〈 〈 optional-variable-declarations-and-subroutines 〉 public static void main(String[] args) { statements 〉 〈 } 〈 〉 optional-variable-declarations-and-subroutines } The name on the first line is the name of the program, as well as t he name of the class. 〈 program-name 〉 is a placeholder for the actual name!) (Remember, again, that If the name of the class is HelloWorld, then the class must be saved in a file called HelloWorld.class will . When this file is compiled, another file named be produced. This class file, HelloWorld.class , contains the translation of the program into Java bytecode, which can be executed by a Java interpreter. is called the source code for the program. To execute the program, you only need the com piled class file, not the source code. The layout of the program on the page, such as the use of blank l ines and indentation, is not part of the syntax or semantics of the language. The computer doesn’t care about layout—you could run the entire program together on one line as far as it i s concerned. However, layout is important to human readers, and there are certain style guid elines for layout that are followed by most programmers.

38 CHAPTER 2. NAMES AND THINGS 23 program can contain other Also note that according to the above syntax specification, a , as well as things called “variable declarations.” You’ll l earn more subroutines besides main() about these later, but not until . Chapter 4 2.2 Variables and the Primitive Types N ames are fundamental to programming . In programs, names are used to refer to many different sorts of things. In order to use those things, a prog rammer must understand the rules rk with them. That is, the for giving names to them and the rules for using the names to wo ames. programmer must understand the syntax and the semantics of n According to the syntax rules of Java, the most basic names ar e identifiers . Identifiers can be used to name classes, variables, and subroutines. An i dentifier is a sequence of one or d must consist entirely of letters, more characters. It must begin with a letter or underscore an cter ’ digits, and underscores. (“Underscore” refers to the chara ’.) For example, here are some legal identifiers: N n rate x15 quite a long name HelloWorld No spaces are allowed in identifiers; HelloWorld is a legal identifier, but “Hello World” is fferent, so that HelloWorld not. Upper case and lower case letters are considered to be di , helloworld HELLOWORLD , and hElloWorLD , are all distinct names. Certain words are reserved for special uses in Java, and cannot be used as identifiers. Th ese reserved words include: class , public , static , if , else , while , and several dozen other words. (Remember that reserved words are not identifiers, since they can’t be used as names for things.) or a digit. Java uses the Java is actually pretty liberal about what counts as a letter many different languages Unicode character set, which includes thousands of characters from s letters or digits. However, I will and different alphabets, and many of these characters count a . be sticking to what can be typed on a regular English keyboard The pragmatics of naming includes style guidelines about ho w to choose names for things. h upper case letters, while names For example, it is customary for names of classes to begin wit of variables and of subroutines begin with lower case letter s; you can avoid a lot of confusion by st Java programmers do not use following this standard convention in your own programs. Mo ing of the names of certain kinds underscores in names, although some do use them at the beginn HelloWorld of variables. When a name is made up of several words, such as interestRate , or it is customary to capitalize each word, except possibly the first; this is sometimes referred to as camel case , since the upper case letters in the middle of a name are suppo sed to look something like the humps on a camel’s back. Finally, I’ll note that in addition to simple identifiers, th compound ings in Java can have which consist of several simple names separated by periods. (Compound names are also names qualified names .) You’ve already seen an example: System.out.println . The idea called here is that things in Java can contain other things. A compou nd name is a kind of path to an item through one or more levels of containment. The name indicates that System.out.println something called “System” contains something called “out” which in turn contains something called “println”. 2.2.1 Variables Programs manipulate data that are stored in memory. In machi ne language, data can only be referred to by giving the numerical address of the location i n memory where the data is stored.

39 CHAPTER 2. NAMES AND THINGS 24 of numbers to refer to data. It In a high-level language such as Java, names are used instead is the job of the computer to keep track of where in memory the d ata is actually stored; the programmer only has to remember the name. A name used in this w ay—to refer to data stored variable in memory—is called a . variable is not a name for the Variables are actually rather subtle. Properly speaking, a u should think of a variable as data itself but for a location in memory that can hold data. Yo o use later. The variable refers a container or box where you can store data that you will need t directly to the box and only indirectly to the data in the box. Since the data in the box can change, a variable can refer to different data values at differ ent times during the execution of the program, but it always refers to the same box. Confusion c an arise, especially for beginning programmers, because when a variable is used in a program in c ertain ways, it refers to the ata in the container. You’ll see container, but when it is used in other ways, it refers to the d examples of both cases below. sident of the United States.” (In this way, a variable is something like the title, “The Pre This title can refer to different people at different times, bu t it always refers to the same office. rack Obama is playing basketball. If I say “the President is playing basketball,” I mean that Ba t she wants to fill the office, not But if I say “Hillary Clinton wants to be President” I mean tha that she wants to be Barack Obama.) In Java, the way to get data into a variable—that is, into the box that the v ariable only names—is with an assignment statement . An assignment statement takes the form: variable 〉 = 〈 expression 〉 〈 ; where expression 〉 represents anything that refers to or computes a data value. When the 〈 ecuting a program, it evaluates computer comes to an assignment statement in the course of ex the expression and puts the resulting data value into the var iable. For example, consider the simple assignment statement rate = 0.07; The 〈 variable 〉 in this assignment statement is rate , and the 〈 expression 〉 is the number 0.07. The computer executes this assignment statement by putting the number 0.07 in the variable , replacing whatever was there before. Now, consider the fol lowing more complicated rate assignment statement, which might come later in the same pro gram: interest = rate * principal; Here, the value of the expression “ rate * principal ” is being assigned to the variable interest . In the expression, the * is a “multiplication operator” that tells the computer rate to multiply principal . The names rate and principal are themselves variables, times and it is really the values stored in those variables that are to be multiplied. We see th at when a variable is used in an expression, it is the value stored in t he variable that matters; in this case, the variable seems to refer to the data in the box, rathe r than to the box itself. When the computer executes this assignment statement, it takes t he of rate , multiplies it by value value the principal , and stores the answer in the box referred to by interest . When a of variable is used on the left-hand side of an assignment state ment, it refers to the box that is named by the variable. hat is executed by the (Note, by the way, that an assignment statement is a command t computer at a certain time. It is not a statement of fact. For e xample, suppose a program includes the statement “ rate = 0.07; ”. If the statement “ interest = rate * principal; ” is executed later in the program, can we say that the principal is multiplied by 0.07? No!

40 CHAPTER 2. NAMES AND THINGS 25 rate might have been changed in the meantime by another statement The value of . The meaning of an assignment statement is completely different f rom the meaning of an equation in mathematics, even though both use the symbol “=”.) 2.2.2 Types A variable in Java is designed to hold only one particular typ e of data; it can legally hold that type of data and no other. The compiler will consider it to be a syntax error if you try to violate this rule by assigning a variable of the wrong type to a variable. We say that Java is a language because it enforces this rule. strongly typed built into Java. The primitive types are named primitive types There are eight so-called byte , int , long , float , double , char , and boolean . The first four types hold integers , short (whole numbers such as 17, -38477, and 0). The four integer ty pes are distinguished by the ranges of integers they can hold. The and double types hold real numbers (such as 3.6 and float ir range and accuracy. A variable -145.99). Again, the two real types are distinguished by the holds a single character from the Unicode character set. And a variable of type of type char holds one of the two logical values or false . boolean true ented as a binary number, Any data value stored in the computer’s memory must be repres that is as a string of zeros and ones. A single zero or one is cal led a . A string of eight bit byte . Memory is usually measured in terms of bytes. Not surprisin gly, the bits is called a byte data type refers to a single byte of memory. A variable of type byte holds a string of eight bits, which can represent any of the integers between -128 an d 127, inclusive. (There are 256 integers in that range; eight bits can represent 256—two rai sed to the power eight—different values.) As for the other integer types, • corresponds to two bytes (16 bits). Variables of type short have values in the range short -32768 to 32767. • corresponds to four bytes (32 bits). Variables of type int have values in the range int -2147483648 to 2147483647. long corresponds to eight bytes (64 bits). Variables of type long have values in the range • -9223372036854775808 to 9223372036854775807. You don’t have to remember these numbers, but they do give you some idea of the size of nteger data you should just stick to integers that you can work with. Usually, for representing i int data type, which is good enough for most purposes. the float The dard method for data type is represented in four bytes of memory, using a stan encoding real numbers. The maximum value for a float is about 10 raised to the power 38. A float can have about 7 significant digits. (So that 32.3989231134 a nd 32.3989234399 would both have to be rounded off to about 32.398923 in order to be sto red in a variable of type .) A takes up 8 bytes, can range up to about 10 to the power 308, and h as about float double double 15 significant digits. Ordinarily, you should stick to the type for real values. A variable of type char occupies two bytes in memory. The value of a char variable is a single character such as A, *, x, or a space character. The val ue can also be a special character such a tab or a carriage return or one of the many Unicode chara cters that come from different languages. Values of type char are closely related to integer values, since a character is a ctually stored as a 16-bit integer code number. In fact, we will see th at chars in Java can actually be used like integers in certain situations. It is important to remember that a primitive type value is rep resented using ony a certain, finite number of bits. So, an int can’t be an arbitrary integer; it can only be an integer

41 CHAPTER 2. NAMES AND THINGS 26 float and variables can only take on in a certain finite range of values. Similarly, double certain values. They are not true real numbers in the mathema tical sense. For example, the , since or double can only be approximated by a value of type mathematical constant float π sent it exactly. For that matter, it would require an infinite number of decimal places to repre and doubles . simple numbers like 1/3 can only be approximated by floats 2.2.3 Literals the computer’s memory, it A data value is stored in the computer as a sequence of bits. In doesn’t look anything like a value written on this page. You n eed a way to include constant values in the programs that you write. In a program, you repre literals . sent constant values as A literal is something that you can type in a program to repres ent a value. It is a kind of name for a constant value. char in a program, you must surround it with a pair For example, to type a value of type of single quote marks, such as , ’*’ , or ’x’ . The character and the quote marks make up a ’A’ literal of type . Without the quotes, A would be an identifier and * would be a multiplication char not ust operator. The quotes are part of the value and are not stored in the variable; they are j a convention for naming a particular character constant in a program. If you want to store the ch of type char , you could do so with the assignment statement character A in a variable ch = ’A’; Certain special characters have special literals that use a \ , as an “escape character”. backslash, ’\t’ In particular, a tab is represented as ’\r’ , a linefeed as ’\n’ , the , a carriage return as single quote character as ’\’’ , and the backslash itself as ’\\’ . Note that even though you type two characters between the quotes in ’\t’ , the value represented by this literal is a single tab character. Numeric literals are a little more complicated than you migh t expect. Of course, there are the obvious literals such as 317 and 17.42. But there are o ther possibilities for expressing numbers in a Java program. First of all, real numbers can be re presented in an exponential form such as 1.3e12 or 12.3737e-108. The “e12” and “e-108” re present powers of 10, so that 12 − 108 . This format can be 1.3e12 means 1.3 times 10 and 12.3737e-108 means 12.3737 times 10 c literal that contains a decimal used to express very large and very small numbers. Any numeri double point or exponential is a literal of type float , you have to . To make a literal of type F” stands for 1.2 considered append an “F” or “f” to the end of the number. For example, “1.2 float . (Occasionally, you need to know this because the rules of Ja va say that as a value of type double to a variable of type float , so you might be confronted you can’t assign a value of type with a ridiculous-seeming error message if you try to do some thing like “ x = 1.2; ” if x is a variable of type . You have to say “ x = 1.2F;" . This is one reason why I advise sticking float to type double for real numbers.) Even for integer literals, there are some complications. Or dinary integers such as 177777 and -32 are literals of type byte , short , or int , depending on their size. You can make a literal of type by adding “L” as a suffix. For example: 17L or 728476874368L. As a nother long complication, Java allows binary, octal (base-8), and hexa decimal (base-16) literals. I don’t want to cover number bases in detail, but in case you run into t hem in other people’s programs, it’s worth knowing a few things: Octal numbers use only the di gits 0 through 7. In Java, a numeric literal that begins with a 0 is interpreted as an octa l number; for example, the octal literal 045 represents the number 37, not the number 45. Octa l numbers are rarely used, but you need to be aware of what happens when you start a number wit h a zero. Hexadecimal

42 CHAPTER 2. NAMES AND THINGS 27 ters A, B, C, D, E, and F. Upper numbers use 16 digits, the usual digits 0 through 9 and the let case and lower case letters can be used interchangeably in th is context. The letters represent 0x 0X , as in 0x45 ins with the numbers 10 through 15. In Java, a hexadecimal literal beg or . Finally, binary literals start with 0b or 0B and contain only the digits 0 and 1; for or 0xFF7A example: 0b10110. e the underscore character (“ As a final complication, numeric literals in Java 7 can includ ”), he integer constant for seven which can be used to separate groups of digits. For example, t billion could be written 7 000 000, which is a good deal easier to decipher than 7000000000. 000 There is no rule about how many digits have to be in each group. Underscores can be especially 1100 . 1011 useful in long binary numbers; for example, 0b1010 cter literals to represent I will note that hexadecimal numbers can also be used in chara f \u followed by four hexadecimal arbitrary Unicode characters. A Unicode literal consists o digits. For example, the character literal ’\u00E9’ represents the Unicode character that is an “e” with an acute accent. boolean , there are precisely two literals: true For the type false . These literals are and typed just as I’ve written them here, without quotes, but the y represent values, not variables. expressions. For example, Boolean values occur most often as the values of conditional rate > 0.05 true if the value of the variable rate is greater is a boolean-valued expression that evaluates to than 0.05, and to false if the value of rate is not greater than 0.05. As you’ll see in Chapter 3 , l structures. Of course, boolean values boolean-valued expressions are used extensively in contro . For example, if test is a variable of type can also be assigned to variables of type boolean : boolean , then both of the following assignment statements are legal test = true; test = rate > 0.05; 2.2.4 Strings and String Literals ll the other types represent objects Java has other types in addition to the primitive types, but a e not concerned with objects for rather than “primitive” data values. For the most part, we ar hat is very important: the type the time being. However, there is one predefined object type t . ( String is a type, but not a primitive type; it is in fact the name of a cl ass, and we will String return to that aspect of strings in the next section.) A value of type String is a sequence of characters. You’ve already seen a string lit eral: "Hello World!" . The double quotes are part of the literal; they have to be typ ed in the program. However, they are not part of the actual String value, which consists of just the er of characters, even zero. A characters between the quotes. A string can contain any numb empty string and is represented by the literal "" , a pair string with no characters is called the e difference between single of double quote marks with nothing between them. Remember th quotes and double quotes! Single quotes are used for char literals and double quotes for String literals! There is a big difference between the String "A" and the char ’A’ . Within a string literal, special characters can be represen ted using the backslash notation. Within this context, the double quote is itself a special cha racter. For example, to represent the string value I said, "Are you listening!" with a linefeed at the end, you would have to type the string literal :

43 CHAPTER 2. NAMES AND THINGS 28 "I said, \"Are you listening!\"\n" You can also use \r , \\ , and Unicode sequences such as \u00E9 to represent other \t , special characters in string literals. 2.2.5 Variables in Programs A variable can be used in a program only if it has first been declared . A variable declaration statement is used to declare one or more variables and to give them names . When the computer e variable and associates the variable’s executes a variable declaration, it sets aside memory for th he form: name with that memory. A simple variable declaration takes t type-name variable-name-or-names 〉 ; 〈 〉 〈 〈 variable-name-or-names 〉 The can be a single variable name or a list of variable names separated by commas. (We’ll see later that variable declara tion statements can actually be somewhat more complicated than this.) Good programming sty le is to declare only one variable in a declaration statement, unless the variables are closel y related in some way. For example: int numberOfStudents; String name; double x, y; boolean isFinished; char firstInitial, middleInitial, lastInitial; It is also good style to include a comment with each variable d eclaration to explain its purpose in the program, or to give other information that mig ht be useful to a human reader. For example: double principal; // Amount of money invested. double interestRate; // Rate as a decimal, not percentage. he In this chapter, we will only use variables declared inside t subroutine of a pro- main() gram. Variables declared inside a subroutine are called local variables for that subroutine. They exist only inside the subroutine, while it is running, a nd are completely inaccessible from outside. Variable declarations can occur anywhere inside t he subroutine, as long as each vari- able is declared before it is used in any way. Some people like to declare all the variables at the beginning of the subroutine. Others like to wait to decla re a variable until it is needed. My preference: Declare important variables at the beginning o f the subroutine, and use a comment to explain the purpose of each variable. Declare “utility va riables” which are not important to the overall logic of the subroutine at the point in the subrou tine where they are first used. Here is a simple program using some variables and assignment stat ements: /** * This class implements a simple program that * will compute the amount of interest that is * earned on $17,000 invested at an interest * rate of 0.027 for one year. The interest and * the value of the investment after one year are * printed to standard output. */ public class Interest { public static void main(String[] args) {

44 CHAPTER 2. NAMES AND THINGS 29 /* Declare the variables. */ double principal; // The value of the investment. double rate; // The annual interest rate. double interest; // Interest earned in one year. /* Do the computations. */ principal = 17000; rate = 0.027; interest = principal * rate; // Compute the interest. principal = principal + interest; // Compute value of investment after one year, with interest . // (Note: The new value replaces the old value of principal.) /* Output the results. */ System.out.print("The interest earned is $"); System.out.println(interest); System.out.print("The value of the investment after one ye ar is $"); System.out.println(principal); } // end of main() } // end of class Interest This program uses several subroutine call statements to dis play information to the user of the program. Two different subroutines are used: and System.out.println . System.out.print System.out.println The difference between these is that adds a linefeed after the end of the System.out.print does not. Thus, the value of interest , information that it displays, while System.out.println(interest); ”, follows on the which is displayed by the subroutine call “ same line as the string displayed by the previous System.out.print statement. Note that the value to be displayed by System.out.print or System.out.println is provided in parentheses after the subroutine name. This value is called a parameter to the subroutine. A parameter ts task. In a subroutine call state- provides a subroutine with information it needs to perform i routine name. Not all subroutines ment, any parameters are listed in parentheses after the sub have parameters. If there are no parameters in a subroutine c all statement, the subroutine name must be followed by an empty pair of parentheses. All the sample programs for this textbook are available in se parate source code files in the . They are also included on-line version of this text at in the downloadable archives of the web site, in a folder name d source . The source code for the Interest program, for example, can be found in the file in subfolder named chapter2 source folder. inside the 2.3 Strings, Classes, Objects, and Subroutines T he previous section introduced the eight primitive data types and the type String . There is a fundamental difference between the primitive types and String : Values of type String Chapter 5 , it will be useful for are objects. While we will not study objects in detail until you to know a little about them and about a closely related top ic: classes. This is not just because strings are useful but because objects and classes a re essential to understanding another important programming concept, subroutines.

45 CHAPTER 2. NAMES AND THINGS 30 2.3.1 Built-in Subroutines and Functions Recall that a subroutine is a set of program instructions tha t have been chunked together and o get that task performed given a name. A subroutine is designed to perform some task. T , e call statement. In in a program, you can “call” the subroutine using a subroutin Chapter 4 t a lot done in a program just you’ll learn how to write your own subroutines, but you can ge by calling subroutines that have already been written for yo u. In Java, every subroutine is contained either in a class or in an object. Some classes that are standard parts of the Java String language contain predefined subroutines that you can use. A v alue of type , which is an that string. These subroutines object, contains subroutines that can be used to manipulate are “built into” the Java language. You can call all these sub routines without understanding how they were written or how they work. Indeed, that’s the who le point of subroutines: A what goes on inside. subroutine is a “black box” which can be used without knowing Let’s first consider subroutines that are part of a class. One of the purposes of a class is contained in that class. These to group together some variables and subroutines, which are static members variables and subroutines are called of the class. You’ve seen one example: main() routine is a static member of the class. The parts In a class that defines a program, the static ”, of a class definition that define static members are marked wit h the reserved word “ public static void main... such as the word “static” in When a class contains a static variable or subroutine, the na me of the class is part of the full d class named System name of the variable or subroutine. For example, the standar contains a subroutine named . To use that subroutine in your program, you must refer to it a s exit . This full name consists of the name of the class that contain System.exit s the subroutine, followed by a period, followed by the name of the subroutine. This subroutine requires an integer as parameter, so you would actually use it with a subr outine call statement such as System.exit(0); Calling System.exit will terminate the program and shut down the Java Virtual Mac hine. You could use it if you had some reason to terminate the program be fore the end of the routine. main ated. A parameter value of 0 (The parameter tells the computer why the program was termin indicates that the program ended normally. Any other value i ndicates that the program was to indicate that System.exit(1) terminated because an error was detected, so you could call nt back to the operating system; the program is ending because of an error. The parameter is se in practice, the value is usually ignored by the operating sy stem.) is just one of many standard classes that come with Java. Anot System her useful class is called . This class gives us an example of a class that contains static variables: It Math includes the variables and Math.E whose values are the mathematical constants π Math.PI and e. Math also contains a large number of mathematical “functions.” E very subroutine performs some specific task. For some subroutines, that task is to compute or retrieve some functions . We say that a function returns a data value. Subroutines of this type are called how in the program that calls value. Generally, the returned value is meant to be used some the function. You are familiar with the mathematical function that comput es the square root of a number. The corresponding function in Java is called Math.sqrt . This function is a static member computes subroutine of the class named . If x is any numerical value, then Math.sqrt(x) Math and returns the square root of that value. Since Math.sqrt(x) represents a value, it doesn’t make sense to put it on a line by itself in a subroutine call sta tement such as Math.sqrt(x); // This doesn’t make sense!

46 CHAPTER 2. NAMES AND THINGS 31 d by the function in this case? What, after all, would the computer do with the value compute You have to tell the computer to do something with the value. Y ou might tell the computer to display it: ot of x. System.out.print( Math.sqrt(x) ); // Display the square ro or you might use an assignment statement to tell the computer to store that value in a variable: lengthOfSide = Math.sqrt(x); represents a value of type , and it can be used anyplace Math.sqrt(x) double The function call where a numeric literal of type double could be used. f some of the more class contains many static member functions. Here is a list o The Math important of them: , which computes the absolute value of Math.abs(x) . • x Math.sin(x) , The usual trigonometric functions, , and Math.tan(x) . (For • Math.cos(x) all the trigonometric functions, angles are measured in rad ians, not degrees.) • ctan, which are written as: The inverse trigonometric functions arcsin, arccos, and ar Math.asin(x) Math.acos(x) , and Math.atan(x) . The return value is expressed in radi- , ans, not degrees. • for computing the number e raised to the power The exponential function Math.exp(x) , and the natural logarithm function for computing the logarithm of x in x Math.log(x) the base e. Math.pow(x,y) x • raised to the power y . for computing Math.floor(x) • x down to the nearest integer value that is less than or , which rounds equal to x . Even though the return value is mathematically an integer, it is returned as a value of type double , rather than of type int as you might expect. For example, Math.floor(3.76) is 3.0. The function returns the integer that is closest Math.round(x) x , and rounds x up to an integer. (“Ceil” is short for “ceiling”, the to Math.ceil(x) opposite of “floor.”) • , which returns a randomly chosen double in the range 0.0 <= Math.random() . (The computer actually calculates so-called “pseudorand om” Math.random() < 1.0 numbers, which are not truly random but are effectively rando m enough for most pur- Math.random poses.) We will find a lot of uses for in future examples. x or y inside the parentheses—can be For these functions, the type of the parameter—the alue returned by the function any value of any numeric type. For most of the functions, the v is of type double no matter what the type of the parameter. However, for Math.abs(x) , the value returned will be the same type as x ; if x is of type int , then so is Math.abs(x) . So, for example, while Math.sqrt(9) double value 3.0, Math.abs(9) is the int value 9. is the Math.random() does not have any parameter. You still need the parentheses, Note that even though there’s nothing between them. The parentheses l et the computer know that this is a subroutine rather than a variable. Another example of a sub routine that has no parameters is the function System.currentTimeMillis() , from the System class. When this function is executed, it retrieves the current time, expressed as the nu mber of milliseconds that have passed since a standardized base time (the start of the year 1970, if you care). One millisecond is one- thousandth of a second. The return value of System.currentTimeMillis() is of type long (a 64-bit integer). This function can be used to measure the tim e that it takes the computer to

47 CHAPTER 2. NAMES AND THINGS 32 and the time at which it is perform a task. Just record the time at which the task is begun finished and take the difference. Here is a sample program that performs a few mathematical tas ks and reports the time that it takes for the program to run. On some computers, the ti me reported might be zero, because it is too small to measure in milliseconds. Even if it ’s not zero, you can be sure that most of the time reported by the computer was spent doing outp ut or working on tasks other than the program, since the calculations performed in this p rogram occupy only a tiny fraction of a millisecond of a computer’s time. /** * This program performs some mathematical computations and displays the . It then * results. It also displays the value of the constant Math.PI * reports the number of seconds that the computer spent on thi s task. */ public class TimedComputation { public static void main(String[] args) { long startTime; // Starting time of program, in millisecond s. long endTime; // Time when computations are done, in millise conds. double time; // Time difference, in seconds. startTime = System.currentTimeMillis(); double width, height, hypotenuse; // sides of a triangle width = 42.0; height = 17.0; hypotenuse = Math.sqrt( width*width + height*height ); enuse "); System.out.print("A triangle with sides 42 and 17 has hypot System.out.println(hypotenuse); System.out.println("\nMathematically, sin(x)*sin(x) + " + "cos(x)*cos(x) - 1 should be 0."); System.out.println("Let’s check this for x = 1:"); System.out.print(" sin(1)*sin(1) + cos(1)*cos(1) - 1 is ") ; System.out.println( Math.sin(1)*Math.sin(1) + Math.cos(1)*Math.cos(1) - 1 ); System.out.println("(There can be round-off errors when" + " computing with real numbers!)"); System.out.print("\nHere is a random number: "); System.out.println( Math.random() ); System.out.print("The value of Math.PI is "); System.out.println( Math.PI ); endTime = System.currentTimeMillis(); time = (endTime - startTime) / 1000.0; System.out.print("\nRun time in seconds was: "); System.out.println(time); } // end main() } // end class TimedComputation

48 CHAPTER 2. NAMES AND THINGS 33 2.3.2 Classes and Objects Classes can be containers for static variables and subrouti nes. However classes also have another type class is a , in the same way purpose. They are used to describe objects. In this role, the double are types. That is, the class name can be used to declare varia bles. Such that and int ase are objects . An object is variables can only hold one type of value. The values in this c a collection of variables and subroutines. Every object has an associated class that tells what broutines and variables that “type” of object it is. The class of an object specifies what su object contains. All objects defined by the same class are sim ilar in that they contain similar collections of variables and subroutines. For example, an o bject might represent a point in the plane, and it might contain variables named and y to represent the coordinates of that point. x Every point object would have an and a y , but different points would have different values for x these variables. A class, named , for example, could exist to define the common structure Point s of type . of all point objects, and all such objects would then be value Point As another example, let’s look again at System.out.println . System is a class, and out System.out is a static variable within that class. However, the value of object , and is an System.out.println is actually the full name of a subroutine that is contained in the ob- ject System.out . You don’t need to understand it at this point, but the object referred to by System.out is an object of the class PrintStream . PrintStream is another class that is a standard part of Java. Any PrintStream is a destination to which information object of type any PrintStream has a println subroutine that can be used can be printed; object of type to send information to that destination. The object System.out is just one possible desti- System.out.println is a subroutine that sends information to that particular nation, and destination. Other objects of type PrintStream might send information to other destinations ject-oriented programming: such as files or across a network to other computers. This is ob Many different things which have something in common—they ca n all be used as destina- h a println subroutine. The tions for information—can all be used in the same way—throug PrintStream class expresses the commonalities among all these objects. The dual role of classes can be confusing, and in practice mos t classes are designed to perform primarily or exclusively in only one of the two possi ble roles. Fortunately, you will not ects in a more serious way, in need to worry too much about it until we start working with obj . Chapter 5 By the way, since class names and variable names are used in si milar ways, it might be hard fined names in Java follow the rule to tell which is which. Remember that all the built-in, prede le names begin with a lower case that class names begin with an upper case letter while variab letter. While this is not a formal syntax rule, I strongly rec ommend that you follow it in your own programming. Subroutine names should also begin with lo wer case letters. There is no possibility of confusing a variable with a subroutine, sinc e a subroutine name in a program is always followed by a left parenthesis. s in Java are often referred As one final general note, you should be aware that subroutine to as methods . Generally, the term “method” means a subroutine that is con tained in a class or in an object. Since this is true of every subroutine in Java , every subroutine in Java is a method. The same is not true for other programming languages , and for the time being, I will prefer to use the more general term, “subroutine.” However, I should note that some people prefer to use the term “method” from the beginning.

49 CHAPTER 2. NAMES AND THINGS 34 2.3.3 Operations on Strings String is an object. That object contains data, namely is a class, and a value of type String the sequence of characters that make up the string. It also co ntains subroutines. All of these subroutines are in fact functions. For example, every strin g object contains a function named advice length is a that computes the number of characters in that string. Suppo se that advice variable that refers to a String . For example, might have been declared and assigned a value as follows: String advice; advice = "Seize the day!"; is a function call that returns the number of characters in th advice.length() Then e string str n general, for any variable “Seize the day!”. In this case, the return value would be 14. I , the value of str.length() is an of type equal to the number of characters in the String int ular string whose length is being string. Note that this function has no parameter; the partic str . The length subroutine is defined by the class String , and it computed is the value of String can be used with any value of type String literals, which are, . It can even be used with String . For example, you could have a program count the after all, just constant values of type characters in “Hello World” for you by saying System.out.print("The number of characters in "); System.out.print("the string \"Hello World\" is "); System.out.println( "Hello World".length() ); The String class defines a lot of functions. Here are some that you might fi nd useful. Assume and s2 are variables of type String : that s1 s1.equals(s2) • boolean value. It returns true if s1 consists is a function that returns a of exactly the same sequence of characters as , and returns false otherwise. s2 • is another boolean-valued function that checks whether s1 s1.equalsIgnoreCase(s2) is the same string as s2 , but this function considers upper and lower case letters to be equivalent. Thus, if s1 is “cat”, then s1.equals("Cat") is false , while s1.equalsIgnoreCase("Cat") is . true s1.length() , as mentioned above, is an integer-valued function that giv • es the number of . s1 characters in , where N is an integer, returns a value of type char • s1.charAt(N) . It returns the Nth th 0, so s1.charAt(0) is character in the string. Positions are numbered starting wi s1.charAt(1) actually the first character, is the second, and so on. The final position is s1.length() - 1 "cat".charAt(1) is ’a’. An error occurs if . For example, the value of or equal to . the value of the parameter is less than zero or is greater than s1.length() s1.substring(N,M) , where • and M are integers, returns a value of type String . The N returned value consists of the characters of s1 in positions N , N+1 ,. . . , M-1 . Note that the character in position M s1 . The is not included. The returned value is called a substring of s1.substring(N) s1 consisting of characters starting subroutine returns the substring of N up until the end of the string. at position • returns an integer. If s2 occurs as a substring of s1 , then the returned s1.indexOf(s2) value is the starting position of that substring. Otherwise , the returned value is -1. You can also use s1.indexOf(ch) to search for a char , ch , in s1 . To find the first occurrence . To find the last occurance of of at or after position N , you can use s1.indexOf(x,N) x x in s1 , use s1.lastIndexOf(x) .

50 CHAPTER 2. NAMES AND THINGS 35 s1.compareTo(s2) is an integer-valued function that compares the two strings • . If the is less than s2 strings are equal, the value returned is zero. If s1 , the value returned s2 is greater than s1 is a number less than zero, and if , the value returned is some number greater than zero. (If both of the strings consist ent irely of lower case letters, or if they consist entirely of upper case letters, then “less th an” and “greater than” refer to cated.) alphabetical order. Otherwise, the ordering is more compli is a String -valued function that returns a new string that is equal to s1 s1.toUpperCase() • , s1 have been converted to upper case. For example, except that any lower case letters in "Cat".toUpperCase() "CAT" . There is also a function s1.toLowerCase() . is the string • is a String -valued function that returns a new string that is equal to s1 except s1.trim() e been trimmed from the that any non-printing characters such as spaces and tabs hav s1 has the value "fred " , then beginning and from the end of the string. Thus, if is the string , with the spaces at the end removed. s1.trim() "fred" s1.toUpperCase() For the functions s1.toLowerCase() , and s1.trim() , note that the , value of s1 is not changed. Instead a new string is created and returned as the v alue of the function. The returned value could be used, for example, in an assignment statement smallLetters = s1.toLowerCase(); ”. To change the value of , you could use an such as “ s1 ”. s1 = s1.toLowerCase(); assignment “ ∗ ∗ ∗ Here is another extremely useful fact about strings: You can use the plus operator, + , to concatenate consisting of all the two strings. The concatenation of two strings is a new string characters of the first string followed by all the characters of the second string. For example, evaluates to "HelloWorld" "Hello" + "World" . (Gotta watch those spaces, of course—if you want a space in the concatenated string, it has to be somewher e in the input data, as in "Hello " + "World" .) Let’s suppose that name is a variable of type String and that it already refers to the name of the person using the program. Then, the program could gree t the user by executing the statement: System.out.println("Hello, " + name + ". Pleased to meet you !"); lues of any type onto a Even more surprising is that you can actually concatenate va String using the + operator. The value is converted to a string, just as it would be if you printed it to the standard output, and then that string is concatenated wi th the other string. For example, the expression evaluates to the string "Number42" . And the statements "Number" + 42 System.out.print("After "); System.out.print(years); System.out.print(" years, the value is "); System.out.print(principal); can be replaced by the single statement: System.out.print("After " + years + " years, the value is " + principal); Obviously, this is very convenient. It would have shortened some of the examples presented earlier in this chapter.

51 CHAPTER 2. NAMES AND THINGS 36 2.3.4 Introduction to Enums Java comes with eight built-in primitive types and a large se t of types that are defined by . But even this large collection of types is not sufficient to co String ver all the classes, such as possible situations that a programmer might have to deal wit h. So, an essential part of Java, ity to create new types. For the just like almost any other programming language, is the abil how to do that in most part, this is done by defining new classes; you will learn Chapter 5 . But we will look here at one particular case: the ability to define enumerated enums (short for ). types Technically, an enum is considered to be a special kind of cla ss, but that is not important for now. In this section, we will look at enums in a simplified f orm. In practice, most uses of e. enums will only need the simplified form that is presented her An enum is a type that has a fixed list of possible values, which is specified when the enum boolean is created. In some ways, an enum is similar to the true and data type, which has false boolean is a primitive type, while an enum is not. as its only possible values. However, The definition of an enum type has the (simplified) form: enum enum-type-name 〉 { 〈 list-of-enum-values 〉 } 〈 t outside This definition cannot be inside a subroutine. You can place i main() routine the of the program. The 〈 enum-type-name 〉 can be any simple identifier. This identifier becomes the name of the enum type, in the same way that “boolean” is the name of the boolean type and “String” is the name of the String type. Each value in the 〈 list-of-enum-values 〉 must be a simple identifier, and the identifiers in the list are separat ed by commas. For example, here is Season whose values are the names of the four seasons the definition of an enum type named of the year: enum Season { SPRING, SUMMER, FALL, WINTER } By convention, enum values are given names that are made up of upper case letters, but that is a style guideline and not a syntax rule. An enum value is a ; that is, it represents constant a fixed value that cannot be changed. The possible values of an enum type are usually referred to as . enum constants Note that the enum constants of type Season are considered to be “contained in” Season , which means—following the convention that compound identi fiers are used for things that are contained in other things—the names that you actually use in your program to refer to them are Season.SPRING , Season.SUMMER , Season.FALL , and Season.WINTER . Once an enum type has been created, it can be used to declare va riables in exactly the same variable named vacation of ways that other types are used. For example, you can declare a type with the statement: Season Season vacation; After declaring the variable, you can assign a value to it usi ng an assignment statement. The value on the right-hand side of the assignment can be one of th e enum constants of type Season . Remember to use the full name of the constant, including “Sea son”! For example: vacation = Season.SUMMER; You can print out an enum value with an output statement such a s System.out.print(vacation) . The output value will be the name of the enum constant (withou t the “Season.”). In this case, the output would be “SUMMER”.

52 CHAPTER 2. NAMES AND THINGS 37 chnically objects. As ob- Because an enum is technically a class, the enum values are te jects, they can contain subroutines. One of the subroutines in every enum value is named ordinal number . When used with an enum value, it returns the of the value in ordinal() the list of values of the enum. The ordinal number simply tell s the position of the value in the list. That is, int value 0, Season.SUMMER.ordinal() is Season.SPRING.ordinal() is the Season.FALL.ordinal() 1, Season.WINTER.ordinal() is 3. (You will see over and is 2, and over again that computer scientists like to start counting a t zero!) You can, of course, use the method with a variable of type . , such as vacation.ordinal() ordinal() Season Using enums can make a program more readable, since you can us e meaningful names for the values. And it can prevent certain types of errors, since a compiler can check that the values assigned to an enum variable are in fact legal values f or that variable. However, we will in fact use them only occasionally in this book. For now, you s hould just appreciate them as the first example of an important concept: creating new types . Here is a little example that shows enums being used in a complete program: public class EnumDemo { // Define two enum types -- remember that the definitions // go OUTSIDE The main() routine! enum Day { SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FR IDAY, SATURDAY } enum Month { JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, N OV, DEC } public static void main(String[] args) { Day tgif; // Declare a variable of type Day. Month libra; // Declare a variable of type Month. tgif = Day.FRIDAY; // Assign a value of type Day to tgif. libra = Month.OCT; // Assign a value of type Month to libra. System.out.print("My sign is libra, since I was born in "); System.out.println(libra); // Output value will be: OCT System.out.print("That’s the "); System.out.print( libra.ordinal() ); System.out.println("-th month of the year."); System.out.println(" (Counting from 0, of course!)"); System.out.print("Isn’t it nice to get to "); System.out.println(tgif); // Output value will be: FRIDAY System.out.println( tgif + " is the " + tgif.ordinal() + "-th day of the week."); } } 2.4 Text Input and Output W e have seen that it is very easy to display text to the user with the functions System.out.print and System.out.println . But there is more to say on the topic of out- putting text. Furthermore, most programs use data that is in put to the program at run time, so you need to know how to do input as well as output. This secti on explains how to get data

53 CHAPTER 2. NAMES AND THINGS 38 seen so far. It also has a section from the user, and it covers output in more detail than we have on using files for input and output. 2.4.1 Basic Output and Formatted Output System.out.print(x) can be a value or expression , where The most basic output function is x String , is not already a string, it is converted to a value of type x of any type. If the parameter, , and the string is then output to the destination called standard output . (Generally, this means that the string is displayed to the user; however, in GU I programs, it outputs to a place dard output can be “redirected” where a typical user is unlikely to see it. Furthermore, stan to write to a different output destination. Nevertheless, fo r the type of program that we are working with now, the purpose of System.out is to display text to the user.) outputs the same text as System.out.print , but it follows that System.out.println(x) ll be on the next line. It is text by a line feed, which means that any subsequent output wi System.out.println() possible to use this function with no parameter, , which outputs nothing System.out.println(x) is equivalent to but a line feed. Note that System.out.print(x); System.out.println(); You might have noticed that System.out.print outputs real numbers with as many digits π is output as 3.141592653589793, and after the decimal point as necessary, so that for example numbers that are supposed to represent money might be output as 1050.0 or 43.575. You might , 1050.00, and 43.58. Java has a prefer to have these numbers output as, for example, 3.14159 how real numbers and other values “formatted output” capability that makes it easy to control l cover just a few of the simplest are printed. A lot of formatting options are available. I wil and most commonly used possibilities here. System.out.printf can be used to produce formatted output. (The name The function m the C and C++ programming “printf,” which stands for “print formatted,” is copied fro languages, where this type of output originated.) System.out.printf takes one or more pa- rameters. The first parameter is a String that specifies the format of the output. This parameter is called the format string ut- . The remaining parameters specify the values that are to be o format for a dollar amount, put. Here is a statement that will print a number in the proper amount is a variable of type double : where System.out.printf( "%1.2f", amount ); format specifier . In this example, the format The output format of a value is specified by a %1.2f . The format string (in the simple cases that I cover here) con tains one format specifier is specifier for each of the values that is to be output. Some typi cal format specifiers are %d , %12d , %10s , %1.2f , %15.8e and %1.8g . Every format specifier begins with a percent sign ( % ) and ends with a letter, possibly with some extra formatting informat ion in between. The letter specifies %d and %12d , the “d” specifies that the type of output that is to be produced. For example, in %12d specifies the minimum number of spaces that an integer is to be written. The “12” in should be used for the output. If the integer that is being out put takes up fewer than 12 spaces, extra blank spaces are added in front of the integer to bring t he total up to 12. We say that the output is “right-justified in a field of length 12.” A very l arge value is not forced into 12 spaces; if the value has more than 12 digits, all the digits wi ll be printed, with no extra spaces. The specifier %d means the same as %1d —that is, an integer will be printed using just as many spaces as necessary. (The “d,” by the way, stands for “decima l”—that is, base-10—numbers. You can replace the “d” with an “x” to output an integer value i n hexadecimal form.)

54 CHAPTER 2. NAMES AND THINGS 39 ny type of value. It The letter “s” at the end of a format specifier can be used with a means that the value should be output in its default format, j ust as it would be in unformatted , can be added to specify the (minimum) number output. A number, such as the “20” in %20s . It can for values of type String of characters. The “s” stands for “string,” and it can be used also be used for values of other types; in that case the value i s converted into a value in String the usual way. The format specifiers for values of type %1.2f , double are more complicated. An “f”, as in th digits after a decimal point. In is used to output a number in “floating-point” form, that is wi %1.2f , the “2” specifies the number of digits to use after the decima l point. The “1” specifies the (minimum) number of characters to output; a “1” in this po sition effectively means that larly, %12.3f would specify a just as many characters as are necessary should be used. Simi right-justified in a field of length 12. floating-point format with 3 digits after the decimal point, ntial format, such as Very large and very small numbers should be written in expone 6.00221415e23, representing “6.00221415 times 10 raised t o the power 23.” A format speci- specifies an output in exponential form, with the “8” telling how many %15.8e fier such as f “e”, the output will be in ex- digits to use after the decimal point. If you use “g” instead o ponential form for very small values and very large values an d in floating-point form for other %1.8g , the 8 gives the total number of digits in the answer, includi values. In ng both the digits before the decimal point and the digits after the decimal poi nt. “,”), which will cause the For numeric output, the format specifier can include a comma ( sier to read big numbers. In digits of the number to be separated into groups, to make it ea mmas. For example, if the United States, groups of three digits are separated by co is one x billion, then System.out.printf("%,d",x) will output 1,000,000,000. In other countries, the separator character and the number of digits per group might be different. The comma should come at the beginning of the format specifier, before the field width; for example: . %,12.3f stified, add a minus sign to the If you want the output to be left-justified instead of right ju %-20s . beginning of the format specifier: for example, In addition to format specifiers, the format string in a printf statement can include other characters. These extra characters are just copied to the ou tput. This can be a convenient way ple, if x and to insert values into the middle of an output string. For exam are variables of y type , you could say int ); System.out.printf("The product of %d and %d is %d", x, y, x*y x is substituted for the first %d in the string, the When this statement is executed, the value of value of y for the second %d , and the value of the expression x*y for the third, so the output would be something like “The product of 17 and 42 is 714” (quot ation marks not included in output!). To output a percent sign, use the format specifier %% in the format string. You can use %n \ , as usual in strings to output special to output a line feed. You can also use a backslash, characters such as tabs and double quote characters. 2.4.2 A First Text Input Example For some unfathomable reason, Java has never made it very eas y to read data typed in by the user of a program. You’ve already seen that output can be disp layed to the user using the sub- routine System.out.print . This subroutine is part of a pre-defined object called System.out . The purpose of this object is precisely to display output to t he user. There is a correspond- ing object called that exists to read data input by the user, but it provides onl y

55 CHAPTER 2. NAMES AND THINGS 40 ced Java programming skills to use it very primitive input facilities, and it requires some advan effectively. class. However, it requires Scanner Java 5.0 finally made input a little easier with a new lass, so it’s not ideal for use here some knowledge of object-oriented programming to use this c Console class for communicating with at the beginning of this course. Java 6 introduced the the user, but has its own problems. (It is not always available, and it can o nly read Console strings, not numbers.) Furthermore, in my opinion, Console still don’t get things Scanner and Scanner briefly at the end of this section, in case you quite right. Nevertheless, I will introduce want to start using it now. However, we start with my own versi on of text input. Fortunately, it is possible to extend Java by creating new classes that provide subroutines that are not available in the standard part of the language. A s soon as a new class is available, the subroutines that it contains can be used in exactly the sa me way as built-in routines. Along TextIO these lines, I’ve written a class named that defines subroutines for reading values typed by the user. The subroutines in this class make it possible to get input from the standard input object, , without knowing about the advanced aspects of Java that are needed to Scanner or to use use TextIO also has a few other capabilities that I will directly. discuss later in this section. To use the TextIO class, you must make sure that the class is available to your p rogram. What this means depends on the Java programming environment that you are using. In general, you just have to add the source code file, , to the same directory that contains your main program. See Section 2.6 TextIO . for information about how to use TextIO The input routines in the class are static member functions. (Static member func- tions were introduced in the previous section.) Let’s suppo se that you want your program to read an integer typed in by the user. The TextIO class contains a static member function getlnInt that you can use for this purpose. Since this function is cont ained in the named class, you have to refer to it in your program as TextIO . The function has TextIO.getlnInt rm “ no parameters, so a complete call to the function takes the fo ”. This TextIO.getlnInt() function call represents the int value typed by the user, and you have to do something with the returned value, such as assign it to a variable. For examp le, if userInput is a variable of type int int userInput; ”), then you could use the (created with a declaration statement “ assignment statement userInput = TextIO.getlnInt(); he user to type in an integer value. When the computer executes this statement, it will wait for t The user must type a number and press return before the progra m can continue. The value that the user typed will then be returned by the function, and it will be stored in the variable, userInput . Here is a complete program that uses TextIO.getlnInt to read a number typed by the user and then prints out the square of that number: /** * A program that reads an integer that is typed in by the * user and computes and prints the square of that integer. */ public class PrintSquare { public static void main(String[] args) { int userInput; // The number input by the user. int square; // The userInput, multiplied by itself.

56 CHAPTER 2. NAMES AND THINGS 41 System.out.print("Please type a number: "); userInput = TextIO.getlnInt(); square = userInput * userInput; System.out.println(); rInput); System.out.println("The number that you entered was " + use ); System.out.println("The square of that number is " + square System.out.println(); } // end of main() } //end of class PrintSquare When you run this program, it will display the message “Pleas e type a number:” and will pause the number. Note that it is good until you type a response, including a carriage return after style to output a question or some other prompt to the user bef ore reading input. Otherwise, the user will have no way of knowing exactly what the computer is waiting for, or even that it is waiting for the user to do something. 2.4.3 Basic TextIO Input Functions includes a variety of functions for inputting values of vari TextIO ous types. Here are the functions that you are most likely to use: j = TextIO.getlnInt(); // Reads a value of type int. y = TextIO.getlnDouble(); // Reads a value of type double. a = TextIO.getlnBoolean(); // Reads a value of type boolean. c = TextIO.getlnChar(); // Reads a value of type char. w = TextIO.getlnWord(); // Reads one "word" as a value of type String. s = TextIO.getln(); // Reads an entire input line as a String. For these statements to be legal, the variables on the left si de of each assignment statement must already be declared and must be of the same type as that re turned by the function on the right side. Note carefully that these functions do not ha ve parameters. The values that they return come from outside the program, typed in by the use r as the program is running. To “capture” that data so that you can use it in your program, y ou have to assign the return value of the function to a variable. You will then be able to re fer to the user’s input value by using the name of the variable. When you call one of these functions, you are guaranteed that it will return a legal value of the correct type. If the user types in an illegal value as inpu t—for example, if you ask for an int and the user types in a non-numeric character or a number that is outside the legal range int of values that can be stored in a variable of type —then the computer will ask the user to re-enter the value, and your program never sees the first, ill egal value that the user entered. For TextIO.getlnBoolean() , the user is allowed to type in any of the following: true, fal se, t, f, yes, no, y, n, 1, or 0. Furthermore, they can use either upper or low er case letters. In any case, the user’s input is interpreted as a true/false value. It’s conv enient to use TextIO.getlnBoolean() to read the user’s response to a Yes/No question. Strings. The first, getlnWord() , You’ll notice that there are two input functions that return returns a string consisting of non-blank characters only. W hen it is called, it skips over any spaces and carriage returns typed in by the user. Then it read s non-blank characters until it gets to the next space or carriage return. It returns a String consisting of all the non- blank characters that it has read. The second input function , getln() , simply returns a string consisting of all the characters typed in by the user, includ ing spaces, up to the next carriage

57 CHAPTER 2. NAMES AND THINGS 42 urn itself is not returned as part of return. It gets an entire line of input text. The carriage ret the input string, but it is read and discarded by the computer . Note that the String returned might be the , which contains no characters at all. You , "" TextIO.getln() by empty string will get this return value if the user simply presses return, without typing anything else first. TextIO.getln() does not skip blanks or end-of-lines before reading a value. But the getlnInt() , getlnDouble() , input functions , and getlnChar() behave like getlnBoolean() getlnWord() the input before in that they will skip past any blanks and carriage returns in -of-line, it outputs a ’?’ to let reading a value. When one of these functions skips over an end the user know that more input is expected. fter the input value, all the Furthermore, if the user types extra characters on the line a extra characters will be discarded, along with the carriage re turn at the end of the line . If the program executes another input function, the user wi ll have to type in another line of input, even if they had typed more than one value on the prev ious line. It might not sound like a good idea to discard any of the user’s input, but it turn s out to be the safest thing to do in most programs. ∗ ∗ ∗ TextIO Using for input and output, we can now improve the program from Section 2.2 for computing the value of an investment. We can have the user typ e in the initial value of the investment and the interest rate. The result is a much more us eful program—for one thing, it makes sense to run it more than once! Note that this program us es formatted output to print out monetary values in their correct format. /** * This class implements a simple program that will compute * the amount of interest that is earned on an investment over * a period of one year. The initial amount of the investment * and the interest rate are input by the user. The value of * the investment at the end of the year is output. The * rate must be input as a decimal, not a percentage (for * example, 0.05 rather than 5). */ public class Interest2 { public static void main(String[] args) { double principal; // The value of the investment. double rate; // The annual interest rate. double interest; // The interest earned during the year. System.out.print("Enter the initial investment: "); principal = TextIO.getlnDouble(); System.out.print("Enter the annual interest rate (as a dec imal): "); rate = TextIO.getlnDouble(); interest = principal * rate; // Compute this year’s interest . principal = principal + interest; // Add it to principal. System.out.printf("The amount of interest is $%1.2f%n", i nterest); System.out.printf("The value after one year is $%1.2f%n", principal); } // end of main() } // end of class Interest2

58 CHAPTER 2. NAMES AND THINGS 43 System.out.println , which (You might be wondering why there is only one output routine, can output data values of any type, while there is a separate i nput routine for each data type. For the output function, the computer can tell what type of va lue is being output by looking at the parameter. However, the input routines don’t have par ameters, so the different input routines can only be distinguished by having different names .) 2.4.4 Introduction to File I/O System.out sends its output to the output destination known as “standar d output.” But stan- mple, data can be written to a file dard output is just one possible output destination. For exa that is stored on the user’s hard drive. The advantage to this , of course, is that the data is saved in the file even after the program ends, and the user can print t he file, email it to someone else, has only one possible source for edit it with another program, and so on. Similarly, input data. TextIO . TextIO includes has the ability to write data to files and to read data from files TextIO.put . Ordinarily, these functions TextIO.putln , and TextIO.putf output functions , System.out.print work exactly like System.out.println , and System.out.printf and are , interchangeable with them. However, they can also be used to output text to files and to other destinations. When you write output using TextIO.put , TextIO.putln , or TextIO.putf , the output is sent to the current output destination. By default, the current output destination is TextIO change the current standard output. However, has subroutines that can be used to output destination. To write to a file named “result.txt”, fo r example, you would use the statement: TextIO.writeFile("result.txt"); TextIO output statements will be sent to the After this statement is executed, any output from file named “result.txt” instead of to standard output. The fil e will be created if it does not already exist. Note that if a file with the same name already ex ists, its previous contents will be erased without any warning! When you call TextIO.writeFile , TextIO remembers the file and automatically sends any output from or other output functions to that file. If you want to go back to TextIO.put writing to standard output, you can call TextIO.writeStandardOutput(); Here is a simple program that asks the user some questions and outputs the user’s responses to a file named “profile.txt.” As an example, it uses TextIO for output to standard output as well as to the file, but System.out could also have been used for the output to standard output. public class CreateProfile { public static void main(String[] args) { String name; // The user’s name. String email; // The user’s email address. double salary; // the user’s yearly salary. String favColor; // The user’s favorite color. TextIO.putln("Good Afternoon! This program will create") ; TextIO.putln("your profile file, if you will just answer") ; TextIO.putln("a few simple questions.");

59 CHAPTER 2. NAMES AND THINGS 44 TextIO.putln(); /* Gather responses from the user. */ TextIO.put("What is your name? "); name = TextIO.getln(); TextIO.put("What is your email address? "); email = TextIO.getln(); TextIO.put("What is your yearly income? "); salary = TextIO.getlnDouble(); TextIO.put("What is your favorite color? "); favColor = TextIO.getln(); /* Write the user’s information to the file named profile.tx t. */ oes to file TextIO.writeFile("profile.txt"); // subsequent output g TextIO.putln("Name: " + name); TextIO.putln("Email: " + email); TextIO.putln("Favorite Color: " + favColor); TextIO.putf( "Yearly Income: %,1.2f%n", salary); /* Print a final message to standard output. */ TextIO.writeStandardOutput(); TextIO.putln("Thank you. Your profile has been written to p rofile.txt."); } } be used for output. You In many cases, you want to let the user select the file that will could ask the user to type in the file name, but that is error-pr one, and users are more familiar with selecting a file from a file dialog box. The statement TextIO.writeUserSelectedFile(); n dialog where the user can specify the will open a typical graphical-user-interface file selectio output file. This also has the advantage of alerting the user i f they are about to replace an existing file. It is possible for the user to cancel the dial og box without selecting a file. TextIO.writeUserSelectedFile is a function that returns a boolean value. The return value is true false if the user canceled the dialog box. Your program if the user selected a file, and is ually going to write to a file or can check the return value if it needs to know whether it is act not. ∗ ∗ ∗ can also read from files, as an alternative to reading from stan TextIO dard input. You can specify an input source for TextIO’s various “get” functions. The default input source is standa rd input. You can use the statement TextIO.readFile("data.txt") to read from a file named “data.txt” instead, or you can let the user select the input fi le with a GUI-style dialog box by saying TextIO.readUserSelectedFile() . After you have done this, any input will come from the file instead of being typed by the user. You can go back to re ading the user’s input with TextIO.readStandardInput() . When your program is reading from standard input, the user ge ts a chance to correct any errors in the input. This is not possible when the program is r eading from a file. If illegal data is found when a program tries to read from a file, an error occur s that will crash the program.

60 CHAPTER 2. NAMES AND THINGS 45 and recover from them.) Errors can (Later, we will see that it is possible to “catch” such errors also occur, though more rarely, when writing to files. knowledge of object oriented A complete understanding of input/output in Java requires a Tex- Chapter 11 programming. We will return to the topic later, in . The file I/O capabilities in sufficient for many applications, are rather primitive by comparison. Nevertheless, they are tIO r rather than later. and they will allow you to get some experience with files soone 2.4.5 Other TextIO Features input functions that we have seen so far can only read one valu e from a line of The TextIO alue from the same line of input. Sometimes, however, you do want to read more than one v input. For example, you might want the user to be able to type s omething like “42 17” to input the two numbers 42 and 17 on the same line. TextIO provides the following alternative input functions to allow you to do this: j = TextIO.getInt(); // Reads a value of type int. y = TextIO.getDouble(); // Reads a value of type double. a = TextIO.getBoolean(); // Reads a value of type boolean. c = TextIO.getChar(); // Reads a value of type char. ring. w = TextIO.getWord(); // Reads one "word" as a value of type St The names of these functions start with “get” instead of “get ln”. “Getln” is short for “get line” and should remind you that the functions whose names begin wi th “getln” will consume an entire line of data. A function without the “ln” will read an i nput value in the same way, but memory called the input buffer will then save the rest of the input line in a chunk of internal . The next time the computer wants to read an input value, it wil l look in the input buffer before d several values from one line prompting the user for input. This allows the computer to rea of the user’s input. Strictly speaking, the computer actual only from the input buffer. ly reads The first time the program tries to read input from the user, th e computer will wait while the user types in an entire line of input. TextIO stores that line in the input buffer until the data on the line has been read or discarded (by one of the “getln” fu nctions). The user only gets to type when the buffer is empty. Note, by the way, that although the TextIO input functions will skip past blank spaces and skip past other characters. For example, not carriage returns while looking for input, they will ints and the user types “42,17”, the computer will read the first nu mber if you try to read two l see the comma. It will regard this correctly, but when it tries to read the second number, it wil want to input several numbers as an error and will force the user to retype the number. If you rate them with spaces, not from one line, you should make sure that the user knows to sepa commas. Alternatively, if you want to require a comma betwee n the numbers, use getChar() to read the comma before reading the second number. There is another character input function, TextIO.getAnyChar() , which does not skip past blanks or carriage returns. It simply reads and returns the n ext character typed by the user, even if it’s a blank or carriage return. If the user typed a car riage return, then the returned char getAnyChar() by \ n’. There is also a function, TextIO.peek() , is the special linefeed character ’ that lets you look ahead at the next character in the input wit hout actually reading it. After you “peek” at the next character, it will still be there when y ou read the next item from input. This allows you to look ahead and see what’s coming up in the in put, so that you can take different actions depending on what’s there. The TextIO class provides a number of other functions. To learn more abo ut them, you can look at the comments in the source code file, .

61 CHAPTER 2. NAMES AND THINGS 46 n the semantics of output! Clearly, the semantics of input is much more complicated tha Fortunately, for the majority of applications, it’s pretty straightforward in practice. You only strongly n particular, I advise need to follow the details if you want to do something fancy. I you to use the “getln” versions of the input routines, rather than the “get” versions, unless you really want to read several items from the same line of input, precisely because the semantics of the “getln” versions is much simpler. 2.4.6 Using Scanner for Input ot a standard class, you TextIO makes it easy to get input from the user. However, since it is n available to any program that uses it. Another option have to remember to make for input is the Scanner class. One advantage of using Scanner is that it’s a standard part of Java and so is always there when you want it. Scanner for user input, and it has some nice features, but using It’s not that hard to use a it requires some syntax that will not be introduced until Chapter 4 Chapter 5 . I’ll tell you and nderstand all the syntax at how to do it here, without explaining why it works. You won’t u Subsection 11.1.5 .) Scanners will be covered in more detail in this point. ( First, you should add the following line to your program at th e beginning of the source code before the “public class. . . ”: file, import java.util.Scanner; Then include the following statement at the beginning of you main() routine: r Scanner stdin = new Scanner( ); stdin of type Scanner . (You can use a different name for the This creates a variable named variable if you want; “stdin” stands for “standard input.”) You can then use stdin in your program to access a variety of subroutines for reading user i nput. For example, the function reads one value of type int stdin.nextInt() from the user and returns it. It is almost the except for two things: If the value entered by the user is not a legal TextIO.getInt() same as , then stdin.nextInt() will crash rather than prompt the user to re-enter the value. And int the integer entered by the user must be followed by a blank spa ce or by an end-of-line, whereas TextIO.getInt() will stop reading at any character that is not a digit. ata, including There are corresponding methods for reading other types of d stdin.nextDouble() , , and stdin.nextBoolean() . ( stdin.nextBoolean() stdin.nextLong() will only accept “true” or “false” as input.) These subrouti nes can read more than one value from a line, so they are more similar to the “get” versions of TextIO subroutines rather than stdin.nextLine() is equivalent to TextIO.getln() the “getln” versions. The method , and , like TextIO.getWord() , returns a string of non-blank characters. As a simple example, here is a version of the sample program that uses Scanner instead of for user input: TextIO import java.util.Scanner; // Make the Scanner class available. public class Interest2WithScanner { public static void main(String[] args) { Scanner stdin = new Scanner( ); // Create the Scanner. double principal; // The value of the investment. double rate; // The annual interest rate. double interest; // The interest earned during the year.

62 CHAPTER 2. NAMES AND THINGS 47 System.out.print("Enter the initial investment: "); principal = stdin.nextDouble(); System.out.print("Enter the annual interest rate (as a dec imal): "); rate = stdin.nextDouble(); . interest = principal * rate; // Compute this year’s interest principal = principal + interest; // Add it to principal. System.out.printf("The amount of interest is $%1.2f%n", i nterest); System.out.printf("The value after one year is $%1.2f%n", principal); } // end of main() } // end of class Interest2With Scanner and create stdin . Note the inclusion of the two lines given above to import Scanner for Also note the substitution of . (In fact, stdin.nextDouble() TextIO.getlnDouble() TextIO.getDouble() is really equivalent to stdin.nextDouble() rather than to the “getln” version, but this will not affect the behavior of the program a s long as the user types just one number on each line of input.) TextIO I will continue to use s for input for the time being, but I will give a few more example of using in the on-line solutions to the end-of-chapter exercises. T here will be more Scanner Scanner detailed coverage of later in the book. 2.5 Details of Expressions T his section takes a closer look at expressions. Recall that an expression is a piece of program code that represents or computes a value. An express ion can be a literal, a variable, rators such as + and > a function call, or several of these things combined with ope . The value of an expression can be assigned to a variable, used as a param eter in a subroutine call, or on. (The value can even, in some combined with other values into a more complicated expressi cases, be ignored, if that’s what you want to do; this is more c ommon than you might think.) is book has dealt only informally Expressions are an essential part of programming. So far, th with expressions. This section tells you the more-or-less c omplete story (leaving out some of the less commonly used operators). The basic building blocks of expressions are literals (such as 674 , 3.14 , true , and ’X’ ), variables, and function calls. Recall that a function is a su broutine that returns a value. You’ve TextIO utines from the class and already seen some examples of functions, such as the input ro the mathematical functions from the Math class. class also contains a couple of mathematical constants that The Math are useful in Math.PI represents π (the ratio of the circumference of a cir- mathematical expressions: Math.E represents e (the base of the natural logarithms). These cle to its diameter), and Math double . They are only ap- of type “constants” are actually member variables in proximations for the mathematical constants, which would r equire an infinite number of Integer contains a couple of constants re- digits to specify exactly. The standard class VALUE is the largest possible int , 2147483647, and lated to the int data type: Integer.MAX Integer.MIN is the smallest int , -2147483648. Similarly, the class Double contains some VALUE constants related to type double . Double.MAX VALUE is the largest value of type double , and Double.MIN is the smallest positive value. It also has constants to represent infinite VALUE values, Double.POSITIVE INFINITY and Double.NEGATIVE INFINITY , and the special value

63 CHAPTER 2. NAMES AND THINGS 48 to represent an undefined value. For example, the value of Math.sqrt(-1) Double.NaN is Double.NaN. ions. More complex expressions Literals, variables, and function calls are simple express + operators for can be built up by using to combine simpler expressions. Operators include adding two numbers, > for comparing two values, and so on. When several operators a ppear precedence in an expression, there is a question of , which determines how the operators are ”, B*C is computed first A + B * C grouped for evaluation. For example, in the expression “ . We say that multiplication ( * ) has and then the result is added to A higher precedence + arentheses to than addition ( ). If the default precedence is not what you want, you can use p (A + B) * C ould use “ ” if you explicitly specify the grouping you want. For example, you c to B first and then multiply the result by C want to add A . he number of operators in Java The rest of this section gives details of operators in Java. T is quite large. I will not cover them all here, but most of the i mportant ones are here. 2.5.1 Arithmetic Operators Arithmetic operators include addition, subtraction, mult iplication, and division. They are indicated by , - , * , and / . These operations can be used on values of any numeric type: byte , + double , long , float , or , . (They can also be used with values of type char , which short int char is converted into its Unicode code number when are treated as integers in this context; a tually calculates one of these it is used with an arithmetic operator.) When the computer ac e type. If your program tells operations, the two values that it combines must be of the sam puter will convert one of the the computer to combine two values of different types, the com + 10, the computer will convert values from one type to another. For example, to compute 37.4 + 10.0. This is called a type the integer 10 to a real number 10.0 and will then compute 37.4 . Ordinarily, you don’t have to worry about type conversion i n expressions, because conversion the computer does it automatically. version on one of them, if When two numerical values are combined (after doing type con necessary), the answer will be of the same type. If you multip ly two ints , you get an int ; if you multiply two doubles , you get a double . This is what you would expect, but you have to be very careful when you use the division operator / . When you divide two integers, the answer rt, it is discarded. For example, the will always be an integer; if the quotient has a fractional pa is 3 , not 3.5 . If N is an integer variable, then N/100 7/2 1/N is equal value of is an integer, and N greater than one! This fact is a common source of programming errors. You to zero for any can force the computer to compute a real number as the answer b y making one of the operands 1.0/N , it first converts real: For example, when the computer evaluates to a real number in N order to match the type of , so you get a real number as the answer. 1.0 e number is divided by Java also has an operator for computing the remainder when on % . If A and B are integers, then A % B another. This operator is indicated by represents the remainder when A is divided by B . (However, for negative operands, % is not quite the same as the usual mathematical “modulus” operator, since if one of A or B is negative, then the value 50 % 8 of 7 % 2 is 1 , while 34577 % 100 is 77 , and will be negative.) For example, is A % B 2 . A common use of % is to test whether a given integer is even or odd: N is even if N % 2 is zero, and it is odd if N % 2 is 1 . More generally, you can check whether an integer N is evenly divisible by an integer by checking whether N % M is zero. M The % operator also works with real numbers. In general, A % B is what is left over after you remove as many copies of B as possible from A . For example, 7.52 % 0.5 is 0.02.

64 CHAPTER 2. NAMES AND THINGS 49 unary minus operator, which takes the negative of a number. Finally, you might need the has the same value as (-1)*X -X For example, . For completeness, Java also has a unary plus , even though it doesn’t really do anything. operator, as in +X By the way, recall that the operator can also be used to concatenate a value of any type + + to combine a string with a value of some other type, it is anoth onto a String . When you use er String . lly converted into type example of type conversion, since any type can be automatica 2.5.2 Increment and Decrement to a variable is an extremely common operation in programmin 1 You’ll find that adding g. from a variable is also pretty common. You might perform the o 1 Subtracting peration of adding 1 to a variable with assignment statements such as: counter = counter + 1; goalsScored = goalsScored + 1; is to take the old value of the variable The effect of the assignment statement x = x + 1 x , compute the result of adding 1 to that value, and store the answer as the new value of . The same operation can be accomplished by writing x++ (or, if you prefer, x ). This ++x actually changes the value of , so that it has the same effect as writing “ x = x + 1 ”. The two x statements above could be written counter++; goalsScored++; x (or ) to subtract 1 Similarly, you could write --x . That is, x-- performs the same x-- from x = x - 1 . Adding 1 to a variable is called incrementing that variable, computation as 1 and subtracting decrementing . The operators ++ and -- are called the increment is called operator and the decrement operator, respectively. These o perators can be used on variables belonging to any of the numerical types and also on variables of type char . ( ’A’++ is ’B’ .) Usually, the operators ++ or -- are used in statements like “ x++ ;” or “ x-- ;”. These state- ments are commands to change the value of x x++ , ++x , x-- , . However, it is also legal to use --x ou can write things like: or as expressions, or as parts of larger expressions. That is, y y = x++; y = ++x; TextIO.putln(--x); z = (++x) * (y--); y = x++ ;” has the effects of adding 1 to the value of x and, in addition, assigning The statement “ y y some value to is the value of the expression x++ , which is defined . The value assigned to x old to be the , before the 1 is added. Thus, if the value of value of is 6 , the statement “ y x = x++ ;” will change the value of x to 7 , but it will change the value of y to 6 since the value assigned to y old value of x . On the other hand, the value of ++x is defined to be the is the is value of , after the 1 is added. So if x new 6 , then the statement “ y = ++x ;” changes the x values of both x and y to 7 . The decrement operator, -- , works in a similar way. Note in particular that the statement does not change the value of x ! This is x = x++; because the value that is being assigned to x is the old value o f x, the one that it had before the statement was executed. The net result is that x is increment ed but then immediately changed back to its previous value! You also need to remember that x++ is not the same as x + 1 . The expression x++ changes the value of x; the expression x + 1 does not.

65 CHAPTER 2. NAMES AND THINGS 50 grams resulting from the This can be confusing, and I have seen many bugs in student pro and -- only as stand-alone statements, confusion. My advice is: Don’t be confused. Use ++ not as expressions. I will follow this advice in almost all ex amples in these notes. 2.5.3 Relational Operators Java has boolean variables and boolean-valued expressions that can be used to express con- false or true ditions that can be either . One way to form a boolean-valued expression is to compare two values using a relational operator . Relational operators are used to test whether two values are equal, whether one value is greater th an another, and so forth. The <= , , < , > , != , and >= . The meanings of these operators are: relational operators in Java are: == A == B Is A "equal to" B? A != B Is A "not equal to" B? A < B Is A "less than" B? A > B Is A "greater than" B? A <= B Is A "less than or equal to" B? A >= B Is A "greater than or equal to" B? These operators can be used to compare values of any of the num eric types. They can also be . For characters, > and char are defined according the numeric < used to compare values of type hat you want. It is not the same Unicode values of the characters. (This might not always be w as alphabetical order because all the upper case letters com e before all the lower case letters.) far as the computer is con- When using boolean expressions, you should remember that as e next chapter, you will see how to cerned, there is nothing special about boolean values. In th n boolean-valued expressions use them in loop and branch statements. But you can also assig o numeric variables. And functions to boolean variables, just as you can assign numeric values t can return boolean values. == and By the way, the operators can be used to compare boolean values too. This is != occasionally useful. For example, can you figure out what thi s does: boolean sameSign; sameSign = ((x > 0) == (y > 0)); One thing that you cannot do with the relational operators < , > , <= , and >= is to use them to compare values of type String == and != to compare Strings , but . You can legally use ht not give the results you want. because of peculiarities in the way objects behave, they mig == operator checks whether two objects are stored in the same me mory location, rather (The some objects, you do want to make than whether they contain the same value. Occasionally, for later chapter.) Instead, you should such a check—but rarely for strings. I’ll get back to this in a equals() , equalsIgnoreCase() , and compareTo() use the subroutines , which were described in Subsection 2.3.3 , to compare two Strings . Another place where == and != don’t work as you would expect is with Double.NaN , the constant that represents an undefined value of type double x == Double.NaN and . The values of are both defined to be x != Double.NaN in all cases, whether or not x is Double.NaN ! To false test whether a real value x is the undefined value Double.NaN , use the boolean -valued function Double.isNaN(x) . 2.5.4 Boolean Operators In English, complicated conditions can be formed using the w ords “and”, “or”, and “not.” For example, “If there is a test and you did not study for it. . . ”. “And”, “or”, and “not” are

66 CHAPTER 2. NAMES AND THINGS 51 , and they exist in Java as well as in English. boolean operators . The && operator is used to In Java, the boolean operator “and” is represented by && true both e. The result is combine two boolean values. The result is also a boolean valu if , and the result is false if either of the combined values is of the combined values are true . For example, “ (x == 0) && (y == 0) true if and only if both x is equal to 0 and ” is false is equal to 0. y The boolean operator “or” is represented by || . (That’s supposed to be two of the vertical | .) The expression “ A || B ” is true if either A is true or B is line characters, , or if both true are true. “ ” is false only if both A and B are false. A || B && and are said to be short-circuited versions of the boolean operators. The operators || or || is not necessarily evaluated. Consider the test This means that the second operand of && (x != 0) && (y/x > 1) x is undefined math- y/x Suppose that the value of is in fact zero. In that case, the division vision, since when the computer ematically. However, the computer will never perform the di (x != 0) , it finds that the result is false , and so it knows that ( (x != 0) && evaluates any- thing ) has to be false. Therefore, it doesn’t bother to evaluate th e second operand. The evaluation has been short-circuited and the division by zer o is avoided. (This may seem like a technicality, and it is. But at times, it will make your progr amming life a little easier.) The boolean operator “not” is a unary operator. In Java, it is indicated by and is written ! test is a boolean variable, then in front of its single operand. For example, if test = ! test; . false , or from false to true to will reverse the value of test, changing it from true 2.5.5 Conditional Operator Any good programming language has some nifty little feature s that aren’t really necessary but that let you feel cool when you use them. Java has the conditio nal operator. It’s a ternary ieces, ? and :, that have to be operator—that is, it has three operands—and it comes in two p used together. It takes the form 〈 〉 ? 〈 expression1 〉 : 〈 boolean-expression 〉 expression2 The computer tests the value of 〈 boolean-expression 〉 . If the value is true , it evaluates 〈 expression1 〉 ; otherwise, it evaluates 〈 expression2 〉 . For example: next = (N % 2 == 0) ? (N/2) : (3*N+1); will assign the value to next if N N/2 N % 2 == 0 is true ), and it will assign is even (that is, if the value (3*N+1) to next if N is odd. (The parentheses in this example are not required, bu t they do make the expression easier to read.) 2.5.6 Assignment Operators and Type Conversion You are already familiar with the assignment statement, whi ch uses the symbol “=” to assign the value of an expression to a variable. In fact, = is really a n operator in the sense that an assignment can itself be used as an expression or as part of a m ore complex expression. The value of an assignment such as A=B is the same as the value that is assigned to A . So, if you want to assign the value of B to A and test at the same time whether that value is zero, you could say:

67 CHAPTER 2. NAMES AND THINGS 52 if ( (A=B) == 0 )... Usually, I would say, don’t do things like that ! of an assignment statement In general, the type of the expression on the right-hand side must be the same as the type of the variable on the left-hand si de. However, in some cases, the computer will automatically convert the value computed by the expression to match the , short , int , long , float type of the variable. Consider the list of numeric types: double . byte , ted automatically to a value that A value of a type that occurs earlier in this list can be conver occurs later. For example: int A; double X; short B; A = 17; X = A; // OK; A is converted to a double B = A; // illegal; no automatic conversion // from int to short y when it can be done without The idea is that conversion should only be done automaticall int double with the same changing the semantics of the value. Any can be converted to a numeric value. However, there are int values that lie outside the legal range of shorts . There int 100000 as a short , for example, since the largest value of is simply no way to represent the short type is 32767. n’t be done automatically. In some cases, you might want to force a conversion that would type cast . A type cast is indicated by putting a type For this, you can use what is called a name, in parentheses, in front of the value you want to conver t. For example, int A; short B; A = 17; B = (short)A; // OK; A is explicitly type cast // to a value of type short You can do type casts from any numeric type to any other numeri c type. However, you should e-casting it. For example, note that you might change the numeric value of a number by typ int 100000 and throwing (short)100000 is -31072. (The -31072 is obtained by taking the 4-byte short away two of those bytes to obtain a —you’ve lost the real information that was in those two bytes.) When you type-cast a real number to an integer, the fractiona l part is discarded. For (int)7.9453 is example, . As another example of type casts, consider the problem of ge t- 7 ting a random integer between 1 and 6. The function gives a real number Math.random() 6*Math.random() is between 0.0 and 5.999. . . . The type- between 0.0 and 0.9999. . . , and so (int) , can be used to convert this to an integer: (int)(6*Math.random()) . cast operator, Thus, (int)(6*Math.random()) is one of the integers 0, 1, 2, 3, 4, and 5. To get a number between 1 and 6, we can add 1: “ ”. (The parentheses around (int)(6*Math.random()) + 1 6*Math.random() are necessary because of precedence rules; without the pare ntheses, the type cast operator would apply only to the 6 .) The type char is almost an integer type. You can assign char values to int variables, and you can assign numerical constants in the range 0 to 65535 to variables. You can also char use explicit type-casts between char and the numeric types. For example, (char)97 is ’a’ , (int)’+’ is 43 , and (char)(’A’ + 2) is ’C’. ∗ ∗ ∗

68 CHAPTER 2. NAMES AND THINGS 53 String and other types cannot be done with type-casts. One way to Type conversion between ith an empty string. For example, convert a value of any type into a string is to concatenate it w . But a better way is to use the function String.valueOf(x) , a static is the string "" + 42 "42" String.valueOf(x) returns the value of x , converted into String member function in the class. is the string a string. For example, , and if ch is a char variable, String.valueOf(42) "42" String.valueOf(ch) is a string of length one containing the single character tha t is the then value of ch . It is also possible to convert certain strings into values of other types. For example, the string should be convertible into the int value 10, and the string "17.42e-2" into the "10" double t-in functions. value 0.1742. In Java, these conversions are handled by buil Integer String to The standard class contains a static member function for converting from . In particular, if str is any expression of type String , then Integer.parseInt(str) is a int function call that attempts to convert the value of str int . For example, the into a value of type Integer.parseInt("10") is the value of value 10. If the parameter to Integer.parseInt int does not represent a legal int value, then an error occurs. Similarly, the standard class Double includes a function Double.parseDouble . If str is a String , then the function call tries to convert str into a value of Double.parseDouble(str) double str does not represent a legal double value. type . An error occurs if ∗ ∗ ∗ Getting back to assignment statements, Java has several var iations on the assignment A += B ” is defined to be the same as operator, which exist to save typing. For example, “ A = A + B ”. Every operator in Java that applies to two operands, excep t for the relational “ example: operators, gives rise to a similar assignment operator. For x -= y; // same as: x = x - y; x *= y; // same as: x = x * y; x /= y; // same as: x = x / y; x %= y; // same as: x = x % y; q &&= p; // same as: q = q && p; (for booleans q and p) += even works with strings. Recall that when the + operator The combined assignment operator is used with a string as one of the operands, it represents con catenation. Since str += x is equivalent to str = str + x += is used with a string on the left-hand side, it appends , when , if str the value on the right-hand side onto the string. For example has the value “tire”, then the statement str += ’d’; changes the value of str to “tired”. 2.5.7 Precedence Rules If you use several operators in one expression, and if you don ’t use parentheses to explicitly indicate the order of evaluation, then you have to worry abou t the precedence rules that deter- mine the order of evaluation. (Advice: don’t confuse yourse lf or the reader of your program; use parentheses liberally.) Here is a listing of the operators discussed in this section, listed in order from highest precedence (evaluated first) to lowest precedence (evaluat ed last): Unary operators: ++, --, !, unary -, unary +, type-cast Multiplication and division: *, /, % Addition and subtraction: +, - Relational operators: <, >, <=, >= Equality and inequality: ==, !=

69 CHAPTER 2. NAMES AND THINGS 54 Boolean and: && Boolean or: || Conditional operator: ?: Assignment operators: =, +=, -=, *=, /=, %= rators of the same precedence Operators on the same line have the same precedence. When ope rators and assignment operators are are strung together in the absence of parentheses, unary ope evaluated right-to-left, while the remaining operators ar e evaluated left-to-right. For example, (A*B)/C A*B/C A=B=C means A=(B=C) . (Can you see how the expression A=B=C means , while B=C as an expression is the same as the value that is might be useful, given that the value of B assigned to ?) 2.6 Programming Environments A is highly standardized, the procedures for creating, compi l- lthough the Java language ing, and editing Java programs vary widely from one programm ing environment to another. command line environment There are two basic approaches: a , where the user types com- mands and the computer responds, and an integrated development environment (IDE), where the user uses the keyboard and mouse to interact with a g raphical user interface. While there is just one common command line environment for Java pr ogramming, there are several common IDEs, including Eclipse, NetBeans, and BlueJ. I cann ot give complete or definitive information on Java programming environments in this secti on, but I will try to give enough textbook. (Readers are strongly information to let you compile and run the examples from this de can be downloaded from the encouraged to read, compile, and run the examples. Source co .) book’s web page, One thing to keep in mind is that you do not have to pay any money to do Java programming (aside from buying a computer, of course). Everything that y ou need can be downloaded for free on the Internet. 2.6.1 Java Development Kit The basic development system for Java programming is usuall y referred to as the JDK (Java Development Kit). It is a part of Java SE, the Java “Standard E dition” (as opposed to Java EE for servers or Java ME for mobile devices). Note that Java S E comes in two versions, a Development Kit version (the JDK) and a Runtime Environmen t version (the JRE). The you to compile your own Java Runtime can be used to run Java programs, but it does not allow programs. The Development Kit includes the Runtime but also lets you compile programs. You need a JDK for use with this textbook. Java was developed by Sun Microsystems, Inc., which is now a p art of the Oracle corporation. Oracle makes the JDK for Windows, Mac OS, and Linux available for free download at its Java Web site. Many Windows computers come with a Java Runtime alr eady installed, but you might need to install the JDK. Some versions of Linux come wit h the JDK either installed by default or on the installation media. Mac OS does not current ly come with Java pre-installed. If you need to download and install the JDK, be sure to get the J DK for Java 7, Java 8, or later. As of summer, 2014, it can be downloaded from oads/index.html

70 CHAPTER 2. NAMES AND THINGS 55 e command line environment If a JDK is properly installed on your computer, you can use th to compile and run Java programs. An IDE will also require a JD K, but it might be included with the IDE download. 2.6.2 Command Line Environment Many modern computer users find the command line environment to be pretty alien and unin- tuitive. It is certainly very different from the graphical us er interfaces that most people are used to. However, it takes only a little practice to learn the basi cs of the command line environment and to become productive using it. To use a command line programming environment, you will have to open a window where nd window by running the you can type in commands. In Windows, you can open such a comma program named cmd . (In Windows 7, click “Start / Program Files / Accessories / C ommand Prompt.” In Windows 8, press the Windows and X keys together t o bring up the “Power User n the Terminal program, Menu,” and select “Command Prompt.”) In Mac OS, you want to ru tions folder. In Linux, there are which can be found in the Utilities folder inside the Applica xterm several possibilities, including an old program called ; try looking for “Terminal” in your applications menu. No matter what type of computer you are using, when you open a c ommand window, it will display a prompt of some sort. Type in a command at the pro mpt and press return. The computer will carry out the command, displaying any output i n the command window, and will d. One of the central concepts then redisplay the prompt so that you can type another comman current directory in the command line environment is the which contains files that can be d “folder” mean the same used by the commands that you type. (The words “directory” an thing.) Often, the name of the current directory is part of th e command prompt. You can get a list of the files in the current directory by typing in the command dir (on Windows) or ls (on Linux and Mac OS). When the window first opens, the current directory is your home directory , where all your files are stored. You can change the current di cd rectory using the r example, to change into command with the name of the directory that you want to use. Fo cd Desktop and press return. your Desktop directory, type in the command You should create a directory (that is, a folder) to hold your Java work. For example, create javawork in your home directory. You can do this using your computer’s a directory named GUI; another way to do it is to open a command window, cd to the d irectory that you want to mkdir javawork . When you want to work contain the new dirctory, and enter the command on programming, open a command window and use the cd command t o change into your work directory. Of course, you can have more than one working dire ctory for your Java work; you can organize your files any way you like. ∗ ∗ ∗ The most basic commands for using Java on the command line are javac and java ; javac is used to compile Java source code, and is used to run Java stand-alone applications. If a java JDK is correctly installed on your computer, it should recog nize these commands when you type them in on the command line. Try typing the commands java -version and javac -version which should tell you which version of Java is installed. If y ou get a message such as “Command not found,” then Java is not correctly installed. If the “jav a” command works, but “javac” does not, it means that a Java Runtime is installed rather than a De velopment Kit. (On Windows, after installing the JDK, you need to modify the Windows PATH environment variable to make this work. See the JDK installation instructions on Oracle’ s download site for information about

71 CHAPTER 2. NAMES AND THINGS 56 how to do this.) into your working directory. (If you To test the javac command, place a copy of source ctory named downloaded the Web site of this book, you can find it in the dire ; you can use your computer’s GUI to copy-and-paste this file into your working directory. Alternatively, you can navigate to Web site and use the “Save As” command in on the book’s your Web browser to save a copy of the file into your working dir ectory.) Type the command: javac This will compile and will create a bytecode file named TextIO.class in the same directory. Note that if the command succeeds, you will not ge t any response from the computer; dy for another command. it will just redisplay the command prompt to tell you it’s rea java To test the from this command, copy a sample program such as nload it from the web site. First, book’s source directory into your working directory, or dow compile the program with the command javac Remember that for this to succeed, TextIO must already be in the same directory. Then you can execute the program using the command java Interest2 just the name of the program, Be careful to use , with the java command, not the Interest2 name of the Java source code file or the name of the compiled cla ss file. When you give this command, the program will run. You will be asked to enter some information, and you will respond by typing your answers into the command window, pres sing return at the end of the line. When the program ends, you will see the command prompt, and you can enter another command. (Note that “ java TextIO TextIO does not have a ” would not make sense, since routine, and so it doesn’t make sense to try to execute it as a p main() rogram.) You can follow a similar procedure to run all of the examples i n this book. Some examples require additional classes, such as TextIO , in addition to the main program. Remember to place any required classes in the same folder as the program that us es them. (You can use either the .java or the .class files for the required classes.) ∗ ∗ ∗ To create your own programs, you will need a . A text editor is a computer text editor tain plain text. It is important program that allows you to create and save documents that con that the documents be saved as plain text, that is without any special encoding or formatting information. Word processor documents are not appropriate , unless you can get your word processor to save as plain text. A good text editor can make pr ogramming a lot more pleasant. Linux comes with several text editors. On Windows, you can us e notepad in a pinch, but you will probably want something better. For Mac OS, you might do wnload the free TextWrangler is to use jedit application. One possibility that will work on any platform , a good programmer’s text editor that is itself written in Java and that can be down loaded for free from . To work on your programs, you can open a command line window an d cd into the working directory where you will store your source code files. Start u p your text editor program, such as by double-clicking its icon or selecting it from a Start me nu. Type your code into the editor window, or open an existing source code file that you want to mo dify. Save the file into your working directory. Remember that the name of a Java source co de file must end in “.java”, and the rest of the file name must match the name of the class that is defined in the file. Once the file is saved in your working directory, go to the command wind ow and use the javac command

72 CHAPTER 2. NAMES AND THINGS 57 in the code, they will be listed to compile it, as discussed above. If there are syntax errors in the command window. Each error message contains the line n umber in the file where the save your e or more errors, computer found the error. Go back to the editor and try to fix on , and then try the javac command again. (It’s usually a good idea to just work on the changes first few errors; sometimes fixing those will make other error s go away.) Remember that when the you can use the java javac command finally succeeds, you will get no message at all. Then compiled the program, you command to run your program, as described above. Once you’ve can run it as many times as you like without recompiling it. That’s really all there is to it: Keep both editor and command -line window open. Edit, rors. (Always remember to save save, and compile until you have eliminated all the syntax er file, not the version in the editor the file before compiling it—the compiler only sees the saved mantic errors that cause it window.) When you run the program, you might find that it has se t/save/compile loop to try to to run incorrectly. In that case, you have to go back to the edi find and fix the problem. 2.6.3 Eclipse In an Integrated Development Environment, everything you n eed to create, compile, and run programs is integrated into a single package, with a graphic al user interface that will be familiar r Java program development, to most computer users. There are a number of different IDEs fo complex applications with a ranging from fairly simple wrappers around the JDK to highly multitude of features. For a beginning programmer, there is a danger in using an IDE, since the difficulty of learning to use the IDE, on top of the difficulty of learning to program, can be overwhelming. However, for my own programming, I general ly use the Eclipse IDE, and I introduce my students to it after they have had some experien ce with the command line. I will discuss Eclipse in some detail and two other IDEs, NetBeans a nd BlueJ, in much less detail. beginning programmer, although All of these IDEs have features that are very useful even for a a beginner will want to ignore many of their advanced feature s. You can download an Eclipse IDE from . It is a free program. Eclipse is itself not necessarily a JDK, since it written in Java. It requires a Java Runtime Environment, but includes its own compiler. You should make sure that the JRE o r JDK, Version 7 or higher is installed on your computer, as described above, you install Eclipse. There are several before versions of the Eclipse IDE; you can use the “Eclipse IDE for J ava Developers.” The first time you start Eclipse, you will be asked to specify a workspace , which is the directory where all your work will be stored. You can accept t he default name, or provide one of your own. When startup is complete, the Eclipse window wil l be filled by a large “Welcome” screen that includes links to extensive documentation and t utorials. You can close this screen, by clicking the “X” next to the word “Welcome”; you can get bac k to it later by choosing “Welcome” from the “Help” menu. The Eclipse GUI consists of one large window that is divided i nto several sections. Each section contains one or more views . For example, a view can be a text editor, it can be a place where a program can do I/O, or it can contain a list of all your p rojects. If there are several views in one section of the window, then there will be tabs at t he top of the section to select the view that is displayed in that section. Each view displays a d ifferent type of information. The whole set of views is called a perspective . Eclipse uses different perspectives, that is different sets of views of different types of information, for different tasks. For compiling and running programs, the only perspective that you will need is the “Jav a Perspective,” which is the default. As you become more experienced, you might want to the use the “ Debug Perspective,” which

73 CHAPTER 2. NAMES AND THINGS 58 rams. has features designed to help you find semantic errors in prog The Java Perspective includes a large area in the center of th e window that contains text rams. To the left of this is the editor views. This is where you will create and edit your prog Package Explorer view, which will contain a list of your Java projects and source code files. To the right are some other views that I don’t find very useful, and I suggest that you close them by clicking the small “X” next to the name of each one. Sev eral other views that will be useful appear in a section of the window below the editing a rea. If you accidently close one of the important views, such as the Package Explorer, you can get it back by selecting it from the “Show View” submenu of the “Window” menu. You can also res et the whole window to its default contents by selecting “Reset Perspective” from the “Window” menu. ∗ ∗ ∗ To do any work in Eclipse, you need a project . To start a Java project, go to the “New” mand. In the window that submenu in the “File” menu, and select the “Java Project” com project and click the “Finish” pops up, it is only necessary to fill in a “Project Name” for the t should appear in the “Package button. The project name can be anything you like. The projec to the project name to see the Explorer” view. Click on the small triangle or plus sign next contents of the project. Assuming that you use the default se ttings, there should be a directory named “src,” which is where your Java source code files will go . It also contains the “JRE System Library”; this is the collection of standard built-i n classes that come with Java. TextIO To run the de file based examples from this textbook, you must add the source co to your project. If you have downloaded the Web site of this bo ok, you can find a copy of in the source directory. Alternatively, you can navigate to the file on-line and use the “Save As” command of your Web browser to save a copy of the file onto your computer. The easiest way to get TextIO into your project is to locate the source code file on your computer and drag the file icon onto the project name in th e Eclipse window. If that k the file icon (or control-click on doesn’t work, you can try using copy-and-paste: Right-clic project’s src folder in the Eclipse Mac OS), select “Copy” from the pop-up menu, right-click the window, and select “Paste”. (Be sure to paste it into the src f older, not into the project itself; files outside the source folder are not treated as Java source code files.) Another option is to src folder inside your workspace directory. However, Eclipse w add the file directly to the ill not automatically recognize a file added in this way; to make Ecli pse find the file, right-click the the pop-up menu. In any case, project name in the Eclipse window and select “Refresh” from TextIO package named “default package”. should appear under “src” in your project, inside a Once a file is in this list, you can open it by double-clicking i t; it will appear in the editing area of the Eclipse window. To run any of the Java programs from this textbook, copy the so urce code file into your ava. To run the program, right- Eclipse Java project in the same way that you copied TextIO.j click in the editor window, or on the file name in the Package Ex plorer view (or control- click in Mac OS). In the menu that pops up, go to the “Run As” sub menu, and select “Java Application”. The program will be executed. If the program w rites to standard output, the output will appear in the “Console” view, in the area of the Ec lipse window below the editing area. If the program uses TextIO for input, you will have to type the required input into the “Console” view— , so that the characters click the “Console” view before you start typing that you type will be sent to the correct part of the window. (F or an easier way to run a program, find and click the small “Run” button in Eclipse’s tool bar.) N ote that when you run a program in Eclipse, it is compiled automatically. There is no separa te compilation step. You can have more than one program in the same Eclipse project , or you can create addi-

74 CHAPTER 2. NAMES AND THINGS 59 in any tional projects to organize your work better. Remember to pl ace a copy of project that requires it. ∗ ∗ ∗ To create a new Java program in Eclipse, you must create a new J ava class. To do that, right-click the Java project name in the “Project Explorer” view. Go to the “New” submenu of the popup menu, and select “Class”. (Alternatively, there i s a small icon in the toolbar at the top of the Eclipse window that you can click to create a new Jav a class.) In the window that opens, type in the name of the class that you want to create. Th e class name must be a legal Java identifier. Note that you want the name of the class, not t he name of the source code file, so don’t add “.java” at the end of the name. Examples in this bo ok use the “default package,” so you will also want to erase the contents of the box labeled “ Package.” (See the last section of , click the “Finish” button to create this section for more information about packages.) Finally n the “default package,” and it the class. The class should appear inside the “src” folder, i start typing in your program. should automatically open in the editing area so that you can e. It will underline any syntax Eclipse has several features that aid you as you type your cod error with a jagged red line, and in some cases will place an er ror marker in the left border of the edit window. If you hover the mouse cursor over the error m arker or over the error itself, a description of the error will appear. Note that you do not ha ve to get rid of every error immediately as you type; some errors will go away as you type i n more of the program. If an error marker displays a small “light bulb,” Eclipse is offeri ng to try to fix the error for you. Click the light bulb—or simply hover your mouse over the actu al error—to get a list of possible fixes, then double click the fix that you want to apply. For exam ple, if you use an undeclared variable in your program, Eclipse will offer to declare it for you. You can actually use this error-correcting feature to get Eclipse to write certain ty pes of code for you! Unfortunately, you’ll find that you won’t understand a lot of the proposed fixe s until you learn more about not the Java language, and it is a good idea to apply a fix that you don’t understand—often that will just make things worse in the end. Eclipse will also look for spelling errors in comments and wi ll underline them with jagged red lines. Hover your mouse over the error to get a list of poss ible correct spellings. content assist . Content assist can be invoked by typing Another essential Eclipse feature is er you are typing at the moment. For Control-Space. It will offer possible completions of whatev example, if you type part of an identifier and hit Control-Spa ce, you will get a list of identifiers that start with the characters that you have typed; use the up and down arrow keys to select one of the items in the list, and press Return or Enter. (You can al so click an item with the mouse to select it, or hit Escape to dismiss the list.) If there is on ly one possible completion when you hit Control-Space, it will be inserted automatically. B y default, Content Assist will also pop up automatically, after a short delay, when you type a per iod or certain other characters. For example, if you type “ TextIO. ” and pause for just a fraction of a second, you will get a list of all the subroutines in the TextIO class. Personally, I find this auto-activation annoying. You can disable it in the Eclipse Preferences. (Look under Ja va / Editor / Content Assist, and turn off the “Enable auto activation” option.) You can still c all up Code Assist manually with Control-Space. Once you have an error-free program, you can run it as describ ed above. If you find a problem when you run it, it’s very easy to go back to the editor , make changes, and run it again. Note that using Eclipse, there is no explicit “compil e” command. The source code files in your project are automatically compiled, and are re-comp iled whenever you modify them.

75 CHAPTER 2. NAMES AND THINGS 60 2.6.4 NetBeans Another IDE for professional programming is NetBeans. It ca n be downloaded from net- DK is available on . Alternatively, a bundle containing both NetBeans and the J Oracle’s Java download page. Using NetBeans is very similar to using Eclipse. Even the lay out of its window is very similar to the Eclipse window. Create a project in NetBeans w ith the “New Project” command. You will have to select the type of project in a pop-up window. You want to create a “Java Application.” The project creation dialog will have a sugge sted name for the project, which you will want to change. It also has an option to create a main c lass for the project, which is selected by default. If you use that option, you should chang e the class name. For use with this book, the name should not be in a “package”; that is, it sh ould not include a period. A project will have a “Source Folder” where the source code fil es for the project are stored. You can drag and other files onto that folder, or y ou can copy-and-paste them e file and select “Run File” from from the file system. For running a file, you can right-click th oolbar. There is no explicit the pop-up menu. There is also a “Run” button in the NetBeans t compilation step. Input and ouput are done in an area below th e edit window, just as in Eclipse. When you are editing a file, NetBeans will mark errors as you ty pe. (Remember, again, that If NetBeans displays an error many errors will go away on their own as you continue to type.) , you have to click the light bulb marker with a light bulb in the left-hand margin of the editor to get a list of possible automatic fixes for the error. NetBea ns also has a “Code Completion” feature that is similar to Content Assist in Eclipse. Just pr ess Control-Space as you are typing to get a list of possible completions. 2.6.5 BlueJ Finally, I will mention BlueJ, an IDE that is designed specifi cally for people who are learning to program. It is much less complex than Eclipse or NetBeans, but it does have some features om that make it useful for education. BlueJ can be downloaded fr . In BlueJ, you can begin a project with the “New Project” comma nd in the “Project” menu. A BlueJ project is simply a folder. When you create a project, you will have to select a folder name that does not already exist. The folder will be created a nd a window will be opened to show the contents of the folder. Files are shown as icons in th e BlueJ window. You can drag .java files from the file system onto that window to add files to t he project; they will be copied into the project folder as well as shown in the window. You can also copy files directly into the project folder, but BlueJ won’t see them until the next ti me you open the project. For example, you can do this with and the sample prog rams from this book. When you restart BlueJ, it should show the last project you were wo rking on, but you can open any project with a command from the “Project” menu. s. An icon for the class is There is a button in the project window for creating a new clas added to the window, and a .java source code file is created in t he project folder. The file is not automatically opened for editing. To edit a file, double-cli ck its icon in the project window. An editor will be opened in a separate window. (A newly created c lass will contain some default code that you probably don’t want; you can erase it and add a main() routine instead.) The BlueJ editor does not show errors as you type. Errors will be r eported when you compile the program. Also, it does not offer automatic fixes for errors. It has a less capable version of Eclipse’s Content Assist, which seems only to work for getti ng a list of available subroutines in a class or object; call up the list by hitting Control-Space a fter typing the period following the

76 CHAPTER 2. NAMES AND THINGS 61 name of a class or object. An editor window contains a button for compiling the program in the window. There is also a compile button in the project window, which compiles a ll the classes in the project. To run a program, it must already be compiled. Right-click th e icon of a compiled program. In the menu that pops up, you will see “ void main(String[] args) ”. Select that option from the menu to run the program. Just click “OK” in the dialog box t hat pops up. A separate window will open for input/output. One of the neatest features of BlueJ is that you can actually u se it to run any subroutine, . If a class contains other subroutines, you will see them in t he list that you get main not just by right-clicking its icon. A pop-up dialog allows you to ent er any parameters required by the routine, and if the routine is a function, you will get anothe r dialog box after the routine has esting of individual subroutines. been executed to tell you its return value. This allows easy t m a class. An icon for the object Furthermore, you can also use BlueJ to create new objects fro ight-click that icon to get will be added at the bottom of the project window, and you can r a list of subroutines in the object. This will, of course, not be useful to you until we get to object-oriented programming in . Chapter 5 2.6.6 The Problem of Packages Every class in Java is contained in something called a package . Classes that are not explicitly put into a package are in the “default” package. Almost all th e examples in this textbook are Section 4.5 . in the default package, and I will not even discuss packages i n any depth until However, some IDEs force you to pay attention to packages. In fact, the use of the default package is discouraged, accor ding to official Java style guide- lines. Nevertheless, I have chosen to use it, since it seems e asier for beginning programmers to avoid the whole issue of packages, at least at first. If Eclips e or NetBeans tries to put a class into a package, you can delete the package name from the class -creation dialog to get it to use ackage, the source code starts the default package instead. But if you do create a class in a p ample, if the class is in a package with a line that specifies which package the class is in. For ex named test.pkg , then the first line of the source code will be package test.pkg; In an IDE, this will not cause any problem unless the program y ou are writing depends on . A class that is in a non-default package cannot use a class fr TextIO om the default package. To make TextIO available to such a class, you can move TextIO to a named, non-default package. This means that the source code file has to be modified to specify the package: A statement like the one shown above must be added to the very be ginning of the file, package with the appropriate package name. (The IDE might do this for you, if you drag from the default package into a non-default package.) If you add TextIO to the same package as the class that uses it, then will be automatically available to that class. If TextIO is TextIO in a different named package, you have to add an “import” state ment to the other class to make TextIO available to it. For example, if TextIO is in the package textio , add the statement import textio.TextIO; package declaration. to the top of the other source code file, just after its own By the way, if you use packages in a command-line environment , other complications arise. For example, if a class is in a package named test.pkg , then the source code file must be in a subdirectory named “pkg” inside a directory named “test” th at is in turn inside your main Java

77 CHAPTER 2. NAMES AND THINGS 62 working directory. Nevertheless, when you compile or execu te the program, you should be in the main directory, not in a subdirectory. When you compile t he source code file, you have to include the name of the directory in the command: Use “ javac test/pkg/ ” on Linux or Mac OS, or “ javac test\pkg\ ” on Windows. The command for executing the program is then “ java test.pkg.ClassName ”, with a period separating the package name from the class name. However, you will not need t o worry about any of that when working with almost all of the examples in this book.

78 Exercises 63 Exercises for Chapter 2 (solution) Write a program that will print your initials to standard out put in letters that are nine 1. For example, if your initials lines tall. Each big letter should be made up of a bunch of *’s. were “DJE”, then the output would look something like: ****** ************* ********** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ******** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ***** **** ********** (solution) 2. Write a program that simulates rolling a pair of dice. You can simulate rolling one die by choosing one of the integers 1, 2, 3, 4, 5, or 6 at random. The nu mber you pick represents the number on the die after it is rolled. As pointed out in Section 2.5 , the expression (int)(Math.random()*6) + 1 does the computation to select a random integer between 1 and 6. You can assign this rolled. Do this twice and value to a variable to represent one of the dice that are being hould report the number add the results together to get the total roll. Your program s showing on each die as well as the total roll. For example: The first die comes up 3 The second die comes up 5 Your total roll is 8 3. Write a program that asks the user’s name, and then greets the user by name. Before (solution) outputting the user’s name, convert it to upper case letters . For example, if the user’s ice to meet you!”. name is Fred, then the program should respond “Hello, FRED, n (solution) 4. Write a program that helps the user count his change. The prog ram should ask how many els, then how many quarters the user has, then how many dimes, then how many nick he has, expressed in pennies. Then the program should tell the user how much money dollars. (solution) If you have N eggs, then you have N/12 dozen eggs, with N%12 eggs left over. (This is 5. essentially the definition of the and % operators for integers.) Write a program that asks / the user how many eggs she has and then tells the user how many d ozen eggs she has and how many extra eggs are left over. A gross of eggs is equal to 144 eggs. Extend your program so tha t it will tell the user how many gross, how many dozen, and how many left over eggs she has. For example, if the user says that she has 1342 eggs, then your program would r espond with Your number of eggs is 9 gross, 3 dozen, and 10

79 Exercises 64 since 1342 is equal to 9*144 + 3*12 + 10. (solution) 6. e built-in subroutines for This exercise asks you to write a program that tests some of th working with Strings . The program should ask the user to enter their first name and t heir ng TextIO.getln() last name, separated by a space. Read the user’s response usi . Break the input string up into two strings, one containing the first name and one containing the indexOf() subroutine to find the position of the last name. You can do that by using the substring() to extract each of the two names. Also output the space, and then using number of characters in each name, and output the user’s init ials. (The initials are the first letter of the first name together with the first letter of t he last name.) A sample run of the program should look something like this: ce. Please enter your first name and last name, separated by a spa ? Mary Smith Your first name is Mary, which has 4 characters Your last name is Smith, which has 5 characters Your initials are MS 7. Suppose that a file named “testdata.txt” contains the follow ing information: The first (solution) line of the file is the name of a student. Each of the next three l ines contains an integer. The integers are the student’s scores on three exams. Write a program that will read the information in the file and display (on standard output) a message that contains the name of the student and the student’s average grade on the thr ee exams. The average is obtained by adding up the individual exam grades and then div iding by the number of exams.

80 Quiz 65 Quiz on Chapter 2 (answers) syntax and the semantics of a programming language. 1. Briefly explain what is meant by the error and a semantics error. Give an example to illustrate the difference between a syntax 2. tion statement. Give an What does the computer do when it executes a variable declara example. 3. What is a type, as this term relates to programming? One of the primitive types in Java is 4. What is the boolean type? Where are boolean. boolean values used? What are its possible values? Give the meaning of each of the following Java operators: 5. a) ++ b) && c) != Explain what is meant by an assignment statement, 6. and give an example. What are assignment statements used for? 7. What is meant by precedence of operators? 8. What is a literal ? 9. In Java, classes have two fundamentally different purposes. What are they? What is the difference between the statement “ ” and the state- 10. x = TextIO.getDouble(); ment “ x = TextIO.getlnDouble(); ” Explain why the value of the expression 2 + 3 + "test" 11. "5test" while the is the string value of the expression "test" + 2 + 3 is the string "test23" . What is the value of "test" + 2 * 3 ? 12. use syntax coloring , which Integrated Development Environments such as Eclipse often assigns various colors to the characters in a program to refle ct the syntax of the language. A student notices that Eclipse colors the word String differently from int , double , and boolean . The student asks why String should be a different color, since all these words are names of types. What’s the answer to the student’s questi on?

81 Chapter 3 Programming in the Small II: Control T s, and he basic building blocks of programs—variables, expressions, assignment statement apter. Starting with this chapter, subroutine call statements—were covered in the previous ch we look at how these building blocks can be put together to bui ld complex programs with more interesting behavior. Since we are still working on the level of “programming in the small” in this chapter, we are interested in the kind of complexity that can occur within a s ingle subroutine. On this level, complexity is provided by control structures . The two types of control structures, loops and and over or to choose among two branches, can be used to repeat a sequence of statements over ntrol structures of each type, and or more possible courses of action. Java includes several co we will look at each of them in some detail. Program complexity can be seen not just in control structure data structures . s but also in A data structure is an organized collection of data, chunked together so that it can be treated as a unit. Section 3.8 mmon data in this chapter includes an introduction to one of the most co structures: arrays . The chapter will also begin the study of program design. Give n a problem, how can you come up with a program to solve that problem? We’ll look at a pa rtial answer to this question in Section 3.2 Section 3.9 is a very brief first look at GUI programming. . Finally, 3.1 Blocks, Loops, and Branches T he ability of a computer to perform complex tasks is built on just a few ways of combining simple commands into control structures. In Java , there are just six such structures that are used to determine the normal flow of control in a progr am—and, in fact, just three of them would be enough to write programs to perform any task. The six control structures are: the block , the while loop , the do..while loop , the for loop , the if statement , and the switch statement ment,” but a . Each of these structures is considered to be a single “state structured statement that can contain one or more other statements insi de itself. 3.1.1 Blocks The block is the simplest type of structured statement. Its purpose is simply to group a sequence of statements into a single statement. The format o f a block is: 67

82 CHAPTER 3. CONTROL 68 { 〈 statements 〉 } ween a pair of braces, “ ” and “ } ”. That is, it consists of a sequence of statements enclosed bet { In fact, it is possible for a block to contain no statements at all; such a block is called an empty , and can actually be useful at times. An empty block consists of nothing but an empty block pair of braces. Block statements usually occur inside other statements, where their purpose is block can be legally used wherever to group together several statements into a unit. However, a ired: As you might have already a statement can occur. There is one place where a block is requ main noticed in the case of the subroutine of a program, the definition of a subroutine is a block, since it is a sequence of statements enclosed inside a pair of braces. I should probably note again at this point that Java is what is called a free-format language. There are no syntax rules about how the language has to be arra nged on a page. So, for example, you could write an entire block on one line if you want. But as a matter of good programming style, you should lay out your program on the page in a way that will make its structure as clear as possible. In general, this means putting one statem ent per line and using indentation to indicate statements that are contained inside control st ructures. This is the format that I will generally use in my examples. Here are two examples of blocks: { System.out.print("The answer is "); System.out.println(ans); } { // This block exchanges the values of x and y int temp; // A temporary variable for use in this block. temp = x; // Save a copy of the value of x in temp. x = y; // Copy the value of y into x. y = temp; // Copy the value of temp into y. } temp In the second example, a variable, , is declared inside the block. This is perfectly legal, and it is good style to declare a variable inside a block if tha t variable is used nowhere else but inside the block. A variable declared inside a block is co mpletely inaccessible and invisible from outside that block. When the computer executes the vari able declaration statement, it allocates memory to hold the value of the variable. When the b lock ends, that memory is discarded (that is, made available for reuse). The variable is said to be local to the block. There is a general concept called the “scope” of an identifier scope of an identifier is the . The part of the program in which that identifier is valid. The scop e of a variable defined inside a block is limited to that block, and more specifically to the pa rt of the block that comes after the declaration of the variable. 3.1.2 The Basic While Loop The block statement by itself really doesn’t affect the flow of control in a program. The five remaining control structures do. They can be divided into tw o classes: loop statements and branching statements. You really just need one control stru cture from each category in order to have a completely general-purpose programming language. M ore than that is just convenience.

83 CHAPTER 3. CONTROL 69 while loop and the statement. I’ll give the full details of In this section, I’ll introduce the if these statements and of the other three control structures i n later sections. A while loop t’s not likely is used to repeat a given statement over and over. Of course, i , which is infinite loop e an that you would want to keep repeating it forever. That would b ioneer Grace Murray Hopper, generally a bad thing. (There is an old story about computer p who read instructions on a bottle of shampoo telling her to “l ather, rinse, repeat.” As the story goes, she claims that she tried to follow the directions, but she ran out of shampoo. (In case ndlessly follow instructions.)) you don’t get it, this is a joke about the way that computers mi loop will repeat a statement over and over, but only so long To be more specific, a while loop has the form: while as a specified condition remains true. A boolean-expression 〉 while ( 〈 ) statement 〉 〈 Since the statement can be, and usually is, a block, most loops have the form: while while ( boolean-expression 〉 ) { 〈 statements 〉 〈 } uded as a matter of style, even Some programmers think that the braces should always be incl when there is only one statement between them, but I don’t alw ays follow that advice myself. while statement go like this: When the computer comes to a while The semantics of the 〈 boolean-expression statement, it evaluates the , which yields either true or false as its value. 〉 If the value is false , the computer skips over the rest of the while loop and proceeds to the next command in the program. If the value of the expression is true , the computer executes the 〈 statement 〉 or block of 〈 statements 〉 inside the loop. Then it returns to the beginning of the while 〈 boolean-expression 〉 , ends loop and repeats the process. That is, it re-evaluates the false true . This will continue over and the loop if the value is , and continues it if the value is over until the value of the expression is false when the computer evaluates it; if that never happens, then there will be an infinite loop. while loop that simply prints out the numbers 1, 2, 3, 4, 5: Here is an example of a int number; // The number to be printed. number = 1; // Start with 1. while ( number < 6 ) { // Keep going as long as number is < 6. System.out.println(number); number = number + 1; // Go on to the next number. } System.out.println("Done!"); number is initialized with the value 1. So when the computer evaluat The variable es the expression “ number < 6 ” for the first time, it is asking whether 1 is less than 6, which is true . The computer therefore proceeds to execute the two stateme nts inside the loop. The first statement prints out “1”. The second statement adds 1 to number and stores the result number number has been changed to 2. The computer has back into the variable ; the value of reached the end of the loop, so it returns to the beginning and number is asks again whether less than 6. Once again this is true, so the computer executes the loop again, this time printing out 2 as the value of number and then changing the value of number to 3. It continues in this way until eventually becomes equal to 6. At that point, the expression “ number < 6 ” number evaluates to false . So, the computer jumps past the end of the loop to the next sta tement and prints out the message “Done!”. Note that when the loop en ds, the value of number is 6, but the last value that was printed was 5.

84 CHAPTER 3. CONTROL 70 while loop standing by itself By the way, you should remember that you’ll never see a in a real program. It will always be inside a subroutine which is itself defined inside some class. As an example of a while loop used inside a complete program, here is a little program rs. This is an improvement over that computes the interest on an investment over several yea examples from the previous chapter that just reported the re sults for one year: /** * This class implements a simple program that will compute th e amount of * interest that is earned on an investment over a period of 5 ye ars. The nput by the * initial amount of the investment and the interest rate are i * user. The value of the investment at the end of each year is ou tput. */ public class Interest3 { public static void main(String[] args) { double principal; // The value of the investment. double rate; // The annual interest rate. /* Get the initial investment and interest rate from the user . */ System.out.print("Enter the initial investment: "); principal = TextIO.getlnDouble(); System.out.println(); System.out.println("Enter the annual interest rate."); System.out.print("Enter a decimal, not a percentage: "); rate = TextIO.getlnDouble(); System.out.println(); /* Simulate the investment for 5 years. */ int years; // Counts the number of years that have passed. years = 0; while (years < 5) { double interest; // Interest for this year. interest = principal * rate; principal = principal + interest; // Add it to principal. years = years + 1; // Count the current year. System.out.print("The value of the investment after "); System.out.print(years); System.out.print(" years is $"); System.out.printf("%1.2f", principal); System.out.println(); } // end of while loop } // end of main() } // end of class Interest3 You should study this program, and make sure that you underst and what the computer does step-by-step as it executes the while loop.

85 CHAPTER 3. CONTROL 71 3.1.3 The Basic If Statement An ction, depending if statement tells the computer to take one of two alternative courses of a true or false. It is an example of on whether the value of a given boolean-valued expression is a “branching” or “decision” statement. An statement has the form: if if ( 〈 boolean-expression 〉 ) 〈 statement1 〉 else 〈 statement2 〉 When the computer executes an if statement, it evaluates the boolean expression. If the valu e true is ement that follows the , the computer executes the first statement and skips the stat “ ”. If the value of the expression is false , then the computer skips the first statement and else e of the two statements inside executes the second one. Note that in any case, one and only on if statement is executed. The two statements represent altern ative courses of action; the the computer decides between these courses of action based on th e value of the boolean expression. omething and not doing In many cases, you want the computer to choose between doing s it. You can do this with an statement that omits the else part: if if ( 〈 boolean-expression 〉 ) 〈 statement 〉 To execute this statement, the computer evaluates the expre ssion. If the value is , the true 〈 〉 that is contained inside the if statement; if the value is computer executes the statement , the computer skips over that 〈 statement false . In either case, the computer then continues 〉 with whatever follows the if statement in the program. Sometimes, novice programmers confuse while statements with simple if statements (with no else part), although their meanings are quite different. The 〈 statement 〉 in an if is executed at most once, while the statement 〉 in a while can be executed any number of times. It can 〈 be helpful to look at diagrams of the the flow of control for while and simple if statements: While Loop Flow of Control If Statement Flow of Control No No Is condition true? Is condition true? Yes Yes Do statement Do statement

86 CHAPTER 3. CONTROL 72 statement is executed. Control In these diagrams, the arrows represent the flow of time as the enters the diagram at the top and leaves at the bottom. Simila rly, a flow control diagram for an atements is executed: if..else statement makes it clear that exactly one of the two nested st If ..Else Flow of Control Yes No Is condition true? Do statemen t 1 ∗ ∗ ∗ 〈 statements 〉 Of course, either or both of the if statement can be a block, and again in an many programmers prefer to add the braces even when they cont ain just a single statement. if So an statement often looks like: 〈 boolean-expression 〉 if ( ) { 〈 statements 〉 } else { 〈 statements 〉 } or: 〈 〉 ) { if ( boolean-expression 〈 statements 〉 } if statement that exchanges the value of two variables, x and y , As an example, here is an but only if x is greater than y to begin with. After this if statement has been executed, we can be sure that the value of is definitely less than or equal to the value of y : x if ( x > y ) { int temp; // A temporary variable for use in this block. temp = x; // Save a copy of the value of x in temp. x = y; // Copy the value of y into x. y = temp; // Copy the value of temp into y. }

87 CHAPTER 3. CONTROL 73 if statement that includes an part. See if you can Finally, here is an example of an else figure out what it does, and why it would be used: if ( years > 1 ) { // handle case for 2 or more years System.out.print("The value of the investment after "); System.out.print(years); System.out.print(" years is $"); } else { // handle case for 1 year System.out.print("The value of the investment after 1 year is $"); } // end of if statement any case System.out.printf("%1.2f", principal); // this is done in hapter. But you already know I’ll have more to say about control structures later in this c the essentials. If you never learned anything more about con trol structures, you would already know enough to perform any possible computing task. Simple l ooping and branching are all you really need! 3.1.4 Definite Assignment I will finish this introduction to control structures with a s omewhat technical issue that you might not fully understand the first time you encounter it. Co nsider the following two code segments, which seem to be entirely equivalent: int y; int y; if (x < 0) { if (x < 0) { y = 1; y = 1; } } else { if (x >= 0) { y = 2; y = 2; } } System.out.println(y); System.out.println(y); y In the version on the left, x < 0 and is assigned the value 2 otherwise, is assigned the value 1 if that is, if x >= 0 . Exactly the same is true of the version on the right. However , there is a subtle difference. In fact, the Java compiler will report an e rror for the System.out.println statement in the code on the right, while the code on the left i s perfectly fine! The problem is that in the code on the right, the computer can’ t tell that the variable has y if else part, the statement inside definitely been assigned a value. When an statement has no the if might or might not be executed, depending on the value of the c ondition. The compiler tion will only be evaluated when can’t tell whether it will be executed or not, since the condi the program is running. For the code on the right above, as far as the compiler is concerned, it neither statement, y = 1 is possible that y = 2 , will be evaluated, so it is possible that the or output statement is trying to print an undefined value. The co mpiler considers this to be an error. The value of a variable can only be used if the compiler can verify that the variable will have been assigned a value at that point when the program is ru nning. This is called definite . (It doesn’t matter that you assignment y will always be assigned a value in can tell that this example. The question is whether the compiler can tell. ) Note that in the code on the left above, y is definitely assigned a value, since in an if..else statement, one of the two alternatives will be executed no ma tter what the value of the condition in the if . It is important that you understand that there is a differenc e between an if..else

88 CHAPTER 3. CONTROL 74 if statements. Here is another pair of code segments that might statement and a pair of plain after each code segment is executed? seem to do the same thing, but don’t. What’s the value of x int x; int x; x = -1; x = -1; if (x < 0) if (x < 0) x = 1; x = 1; else if (x >= 0) x = 2; x = 2; After the code on the left is executed, x is 2. x is 1; after the code on the right, 3.2 Algorithm Development P rogramming is difficult (like many activities that are useful and worthwhile—and li ke most of those activities, it can also be rewarding and a lot of fun). When you write a program, you have to tell the computer every small detail of what to do. And you have to get everything rogram exactly as written. How, exactly right, since the computer will blindly follow your p ot a big mystery, actually. It’s then, do people write any but the most simple programs? It’s n a matter of learning to think in the right way. A program is an expression of an idea. A programmer starts wit h a general idea of a task some idea of how to perform for the computer to perform. Presumably, the programmer has the task by hand, at least in general outline. The problem is t o flesh out that outline into a complete, unambiguous, step-by-step procedure for carryi ng out the task. Such a procedure is called an “algorithm.” (Technically, an algorithm is an unambiguous, step-by-step procedure that always terminates after a finite number of steps. We don’ t want to count procedures that might go on forever.) An algorithm is not the same as a program . A program is written in some particular programming language. An algorithm is more like the behind the program, but idea steps the it’s the idea of the the program will take to perform its task, not just the idea of task itself. When describing an algorithm, the steps don’t neces sarily have to be specified in s clear that carrying out the steps complete detail, as long as the steps are unambiguous and it’ will accomplish the assigned task. An algorithm can be expre ssed in any language, including English. Of course, an algorithm can only be expressed as an a ctual program if all the details have been filled in. So, where do algorithms come from? Usually, they have to be de veloped, often with a lot of thought and hard work. Skill at algorithm development is som ething that comes with practice, but there are techniques and guidelines that can help. I’ll t alk here about some techniques and guidelines that are relevant to “programming in the small,” and I will return to the subject several times in later chapters. 3.2.1 Pseudocode and Stepwise Refinement When programming in the small, you have a few basics to work wi th: variables, assignment statements, and input/output routines. You might also have some subroutines, objects, or other building blocks that have already been written by you o r someone else. (Input/output routines fall into this class.) You can build sequences of th ese basic instructions, and you can also combine them into more complex control structures such as while loops and if statements. Suppose you have a task in mind that you want the computer to pe rform. One way to proceed is to write a description of the task, and take that de scription as an outline of the

89 CHAPTER 3. CONTROL 75 te that description, gradually algorithm you want to develop. Then you can refine and elabora adding steps and detail, until you have a complete algorithm that can be translated directly , and it is a type of stepwise refinement into programming language. This method is called se refinement, you can write out top-down design. As you proceed through the stages of stepwi —informal instructions that imitate the structure descriptions of your algorithm in pseudocode rfect syntax of actual program of programming languages without the complete detail and pe code. As an example, let’s see how one might develop the program fro m the previous section, which computes the value of an investment over five years. The task t hat you want the program to perform is: “Compute and display the value of an investment f or each of the next five years, ified by the user.” You might then where the initial investment and interest rate are to be spec : write—or more likely just think—that this can be expanded as Get the user’s input Compute the value of the investment after 1 year Display the value Compute the value after 2 years Display the value Compute the value after 3 years Display the value Compute the value after 4 years Display the value Compute the value after 5 years Display the value This is correct, but rather repetitive. And seeing that repe tition, you might notice an important, it would be more opportunity to use a loop. A loop would take less typing. More : Essentially the same loop will work no matter how many years you want to process. general So, you might rewrite the above sequence of steps as: Get the user’s input while there are more years to process: Compute the value after the next year Display the value Following this algorithm would certainly solve the problem , but for a computer we’ll have to be more explicit about how to “Get the user’s input,” how to “Compute the value after the next year,” and what it means to say “there are more years to pr ocess.” We can expand the step, “Get the user’s input” into Ask the user for the initial investment Read the user’s response Ask the user for the interest rate Read the user’s response To fill in the details of the step “Compute the value after the n ext year,” you have to know how to do the computation yourself. (Maybe you need to as k your boss or professor for clarification?) Let’s say you know that the value is computed by adding some interest to the previous value. Then we can refine the while loop to: while there are more years to process: Compute the interest Add the interest to the value Display the value

90 CHAPTER 3. CONTROL 76 ly way that we can do that is As for testing whether there are more years to process, the on by counting the years ourselves. This displays a very common pattern, and you should expect with zero years, add one each to use something similar in a lot of programs: We have to start time we process a year, and stop when we reach the desired numb er of years. This is sometimes . So the while called a counting loop loop becomes: years = 0 while years < 5: years = years + 1 Compute the interest Add the interest to the value Display the value We still have to know how to compute the interest. Let’s say th at the interest is to be ue of the investment. Putting computed by multiplying the interest rate by the current val r’s inputs, we have the complete this together with the part of the algorithm that gets the use algorithm: Ask the user for the initial investment Read the user’s response Ask the user for the interest rate Read the user’s response years = 0 while years < 5: years = years + 1 Compute interest = value * interest rate Add the interest to the value Display the value Finally, we are at the point where we can translate pretty dir ectly into proper programming- les, decide exactly what we want language syntax. We still have to choose names for the variab ress our algorithm in Java as: to say to the user, and so forth. Having done this, we could exp double principal, rate, interest; // declare the variables int years; System.out.print("Type initial investment: "); principal = TextIO.getlnDouble(); System.out.print("Type interest rate: "); rate = TextIO.getlnDouble(); years = 0; while (years < 5) { years = years + 1; interest = principal * rate; principal = principal + interest; System.out.println(principal); } till needs to be commented, This still needs to be wrapped inside a complete program, it s and it really needs to print out more information in a nicer fo rmat for the user. But it’s essentially the same program as the one in the previous secti on. (Note that the pseudocode algorithm used indentation to show which statements are ins ide the loop. In Java, indentation is completely ignored by the computer, so you need a pair of br aces to tell the computer which statements are in the loop. If you leave out the braces, the on ly statement inside the loop would be “ years = years + 1;" . The other statements would only be executed once, after the loop

91 CHAPTER 3. CONTROL 77 rror for you, like it would if you ends. The nasty thing is that the computer won’t notice this e ”. The parentheses are required by the syntax of left out the parentheses around “ (years < 5) statement. The braces are only required semantically. The c while omputer can recognize the syntax errors but not semantic errors.) One thing you should have noticed here is that my original spe cification of the problem— e next five years”—was far from “Compute and display the value of an investment for each of th being complete. Before you start writing a program, you shou ld make sure you have a complete n particular, you need to know specification of exactly what the program is supposed to do. I what computation it is going what information the program is going to input and output and of the problem might look like in to perform. Here is what a reasonably complete specification this example: “Write a program that will compute and display the value of an investment for each of the next five years. Each year, inter est g is added to the value. The interest is computed by multiplyin tial the current value by a fixed interest rate. Assume that the ini value and the rate of interest are to be input by the user when t he program is run.” 3.2.2 The 3N+1 Problem Let’s do another example, working this time with a program th at you haven’t already seen. The assignment here is an abstract mathematical problem that is one of my favorite programming fication of the task to be performed: exercises. This time, we’ll start with a more complete speci t- “Given a positive integer, N, define the ’3N+1’ sequence star ing from N as follows: If N is an even number, then divide N by two; but if N is odd, then multiply N by 3 and add 1. Continue to generate numbers in this way until N becomes equal to 1. For example, starting from N = 3, which is odd, we multiply by 3 and add 1, giving N = 3*3+1 = 10. Then, since N is even, we divide by 2, giving N = 10/2 = 5. We continue in this way, stopping when we reach 1. The complete sequence is: 3, 10, 5, 16, 8, 4, 2, 1. “Write a program that will read a positive integer from the user and will print out the 3N+1 sequence starting from that integer. The program should also count and print out the numb er of terms in the sequence.” A general outline of the algorithm for the program we want is: Get a positive integer N from the user. Compute, print, and count each number in the sequence. Output the number of terms. The bulk of the program is in the second step. We’ll need a loop , since we want to keep computing numbers until we get 1. To put this in terms appropr iate for a while loop, we need to know when to continue the loop rather than when to stop it: We want to continue as lon g as the number is not 1. So, we can expand our pseudocode algorithm to:

92 CHAPTER 3. CONTROL 78 Get a positive integer N from the user; while N is not 1: Compute N = next term; Output N; Count this term; Output the number of terms; rent actions depending on In order to compute the next term, the computer must take diffe statement to decide between the two cases: whether N is even or odd. We need an if Get a positive integer N from the user; while N is not 1: if N is even: Compute N = N/2; else Compute N = 3 * N + 1; Output N; Count this term; Output the number of terms; . Counting means that you We are almost there. The one problem that remains is counting start with zero, and every time you have something to count, y ou add one. We need a variable to do the counting. The variable must be set to zero once, the loop starts, and it must before be incremented within the loop. (Again, this is a common patt ern that you should expect to see over and over.) With the counter added, we get: Get a positive integer N from the user; Let counter = 0; while N is not 1: if N is even: Compute N = N/2; else Compute N = 3 * N + 1; Output N; Add 1 to counter; Output the counter; We still have to worry about the very first step. How can we get a integer from the positive user? If we just read in a number, it’s possible that the user m ight type in a negative number or zero. If you follow what happens when the value of N is negat ive or zero, you’ll see that the program will go on forever, since the value of N will never bec ome equal to 1. This is bad. In this case, the problem is probably no big deal, but in general you should try to write programs that are foolproof. One way to fix this is to keep reading in num bers until the user types in a positive number: Ask user to input a positive number; Let N be the user’s response; while N is not positive: Print an error message; Read another value for N; Let counter = 0; while N is not 1: if N is even: Compute N = N/2; else

93 CHAPTER 3. CONTROL 79 Compute N = 3 * N + 1; Output N; Add 1 to counter; Output the counter; while common loop will end only when N is a positive number, as required. (A The first statement instead of a beginning programmer’s error is to use an statement here: “If if while oblem arises if the second number N is not positive, ask the user to input another value.” The pr if statement is only executed once, so the second input by the user is also non-positive. The n infinite loop. With the input number is never tested, and the program proceeds into a while ck to the beginning of the loop loop, after the second number is input, the computer jumps ba ks the user for a third number, and tests whether the second number is positive. If not, it as and it will continue asking for numbers until the user enters an acceptable input. After the while loop ends, we can be absolutely sure that is a positive number.) N Here is a Java program implementing this algorithm. It uses t he operators <= to mean “is less than or equal to” and != to mean “is not equal to.” To test whether N is even, it uses Section 2.5 . “ N % 2 == 0 ”. All the operators used here were discussed in /** * This program prints out a 3N+1 sequence starting from a posi tive * integer specified by the user. It also counts the number of * terms in the sequence, and prints out that number. */ public class ThreeN1 { public static void main(String[] args) { int N; // for computing terms in the sequence int counter; // for counting the terms System.out.print("Starting point for sequence: "); N = TextIO.getlnInt(); while (N <= 0) { System.out.print( "The starting point must be positive. Please try again: " ); N = TextIO.getlnInt(); } // At this point, we know that N > 0 counter = 0; while (N != 1) { if (N % 2 == 0) N = N / 2; else N = 3 * N + 1; System.out.println(N); counter = counter + 1; } System.out.println(); System.out.print("There were "); System.out.print(counter); System.out.println(" terms in the sequence."); } // end of main()

94 CHAPTER 3. CONTROL 80 } // end of class ThreeN1 Two final notes on this program: First, you might have noticed that the first term of the unted by this program. Is sequence—the value of N input by the user—is not printed or co ogram careful enough to decide? this an error? It’s hard to say. Was the specification of the pr This is the type of thing that might send you back to the boss/p rofessor for clarification. The e the line “counter = 0” before problem (if it is one!) can be fixed easily enough. Just replac the while loop with the two lines: System.out.println(N); // print out initial term counter = 1; // and count it Second, there is the question of why this problem might be int eresting. Well, it’s interesting le question about the problem that to mathematicians and computer scientists because of a simp they haven’t been able to answer: Will the process of computi ng the 3N+1 sequence finish after a finite number of steps for all possible starting values of N? Although individual sequences are easy to compute, no one has been able to answer the general que stion. To put this another way, no one knows whether the process of computing 3N+1 seque nces can properly be called an algorithm, since an algorithm is required to terminate af ter a finite number of steps! (Note: type ! That is, it assumes that the This discussion really applies to integers, not to values of int value of N can take on arbitrarily large integer values, which is not tr ue for a variable of type in a Java program. When the value of N int in the program becomes too large to be represented as a 32-bit int , the values output by the program are no longer mathematical ly correct. So the Java program does not compute the correct 3N+1 sequence i f N becomes too large. See Exercise 8.2.) 3.2.3 Coding, Testing, Debugging It would be nice if, having developed an algorithm for your pr ogram, you could relax, press a , the process of turning an algorithm button, and get a perfectly working program. Unfortunately u do get to the stage of a working into Java source code doesn’t always go smoothly. And when yo program, it’s often only working in the sense that it does something . Unfortunately not what you want it to do. After program design comes coding: translating the design i nto a program written in Java e, a few syntax errors will creep or some other language. Usually, no matter how careful you ar gram with some kind of error in from somewhere, and the Java compiler will reject your pro t syntax errors, it’s not very good message. Unfortunately, while a compiler will always detec about telling you exactly what’s wrong. Sometimes, it’s not even good about telling you where { ” on line 45 might cause the compiler to choke the real error is. A spelling error or missing “ on line 105. You can avoid lots of errors by making sure that yo u really understand the syntax rules of the language and by following some basic programmin g guidelines. For example, I never type a “ { } ”. Then I go back and fill in the statements ” without typing the matching “ between the braces. A missing or extra brace can be one of the h ardest errors to find in a large program. Always, always indent your program nicely. If you c hange the program, change the indentation to match. It’s worth the trouble. Use a consiste nt naming scheme, so you don’t have to struggle to remember whether you called that variabl e interestrate or interestRate . In general, when the compiler gives multiple error messages , don’t try to fix the second error message from the compiler until you’ve fixed the first one. Onc e the compiler hits an error in your program, it can get confused, and the rest of the error me ssages might just be guesses.

95 CHAPTER 3. CONTROL 81 r before you try to fix it. Maybe the best advice is: Take the time to understand the erro Programming is not an experimental science. When your program compiles without error, you are still not d one. You have to test the program to make sure it works correctly. Remember that the go al is not to get the right output for the two sample inputs that the professor gave in class. Th e goal is a program that will work correctly for all reasonable inputs. Ideally, when fac ed with an unreasonable input, it should respond by gently chiding the user rather than by cras hing. Test your program on a wide variety of inputs. Try to find a set of inputs that will tes t the full range of functionality ger programs, write them in that you’ve coded into your program. As you begin writing lar stages and test each stage along the way. You might even have t o write some extra code to do the testing—for example to call a subroutine that you’ve j ust written. You don’t want to be faced, if you can avoid it, with 500 newly written lines of c ode that have an error in there somewhere. bugs The point of testing is to find —semantic errors that show up as incorrect behavior u will probably find them. Again, rather than as compilation errors. And the sad fact is that yo ut no one has found a way to you can minimize bugs by careful design and careful coding, b avoid them altogether. Once you’ve detected a bug, it’s time for debugging . You have to d eliminate it. Debugging is a track down the cause of the bug in the program’s source code an ctice to master. So don’t be afraid of skill that, like other aspects of programming, requires pra bugs. Learn from them. One essential debugging skill is the a bility to read source code—the ability to put aside preconceptions about what you think it does and to follow it the way the computer does—mechanically, step-by-step—to see what it r eally does. This is hard. I can still remember the time I spent hours looking for a bug only to find th at a line of code that I had looked at ten times had a “1” where it should have had an “i”, or the time when I wrote a WindowClosing subroutine named which would have done exactly what I wanted except that the computer was looking for windowClosing (with a lower case “w”). Sometimes it can help to have someone who doesn’t share your preconceptions look a t your code. Often, it’s a problem just to find the part of the program that c ontains the error. Most programming environments come with a , which is a program that can help you find debugger bugs. Typically, your program can be run under the control of the debugger. The debugger allows you to set “breakpoints” in your program. A breakpoin t is a point in the program where the debugger will pause the program so you can look at the valu es of the program’s variables. The idea is to track down exactly when things start to go wrong during the program’s execution. The debugger will also let you execute your program one line a t a time, so that you can watch what happens in detail once you know the general area in the pr ogram where the bug is lurking. . A more traditional approach to I will confess that I only occasionally use debuggers myself debugging is to insert debugging statements into your program. These are output statements that print out information about the state of the program. Ty pically, a debugging statement would say something like System.out.println("At start of while loop, N = " + N); You need to be able to tell from the output where in your progra m the output is coming from, and you want to know the value of important variables. Someti mes, you will find that the computer isn’t even getting to a part of the program that you t hink it should be executing. Remember that the goal is to find the first point in the program w here the state is not what you expect it to be. That’s where the bug is. And finally, remember the golden rule of debugging: If you are absolutely sure that every- thing in your program is right, and if it still doesn’t work, t hen one of the things that you are

96 CHAPTER 3. CONTROL 82 absolutely sure of is wrong. 3.3 The while and do..while Statements be either simple statements or compound statements. Simple S tatements in Java can all statements, are the basic building statements, such as assignment statements and subroutine c blocks of a program. Compound statements, such as loops and if statements, are used to while organize simple statements into complex structures, which are called control structures because they control the order in which the statements are executed. The next five sections explore while statement , starting with the the details of control structures that are available in Java and the do..while statement in this section. At the same time, we’ll look at exa mples of programming with each control structure and apply the techn iques for designing algorithms that were introduced in the previous section. 3.3.1 The while Statement The statement was already introduced in while Section 3.1 . A while loop has the form 〈 boolean-expression 〉 while ( ) 〈 statement 〉 The 〈 statement 〉 can, of course, be a block statement consisting of several st atements grouped together between a pair of braces. This statement is called t he body of the loop . The body of the loop is repeated as long as the 〈 〉 is true. This boolean expression is boolean-expression continuation condition test , of the loop. There are a few called the , or more simply the points that might need some clarification. What happens if th e condition is false in the first place, before the body of the loop is executed even once? In th at case, the body of the loop is any number of times, including never executed at all. The body of a while loop can be executed lse somewhere in the middle of zero. What happens if the condition is true, but it becomes fa the loop body? Does the loop end as soon as this happens? It doe sn’t, because the computer continues executing the body of the loop until it gets to the e nd. Only then does it jump back to the beginning of the loop and test the condition, and only t hen can the loop end. Let’s look at a typical problem that can be solved using a while loop: finding the average of a set of positive integers entered by the user. The average is the sum of the integers, divided er one integer at a time. It by the number of integers. The program will ask the user to ent will keep count of the number of integers entered, and it will keep a running total of all the numbers it has read so far. Here is a pseudocode algorithm for the program: Let sum = 0 // The sum of the integers entered by the user. Let count = 0 // The number of integers entered by the user. while there are more integers to process: Read an integer Add it to the sum Count it Divide sum by count to get the average Print out the average But how can we test whether there are more integers to process ? A typical solution is to tell the user to type in zero after all the data have been enter ed. This will work because we are assuming that all the data are positive numbers, so zero i s not a legal data value. The zero is not itself part of the data to be averaged. It’s just there t o mark the end of the real data.

97 CHAPTER 3. CONTROL 83 sentinel value . So now the test in the A data value used in this way is sometimes called a while loop becomes “while the input integer is not zero”. But there is another problem! The first time the test is evaluated, before the body of the loop ha s ever been executed, no integer has yet been read. There is no “input integer” yet, so testing whether the input integer is zero doesn’t make sense. So, we have to do something before the while loop to make sure that the loop makes sense the first time test makes sense. Setting things up so that the test in a while . In this case, we can simply read the first integer it is executed is called priming the loop before the beginning of the loop. Here is a revised algorithm : Let sum = 0 Let count = 0 Read an integer while the integer is not zero: Add the integer to the sum Count it Read an integer Divide sum by count to get the average Print out the average Notice that I’ve rearranged the body of the loop. Since an int eger is read before the loop, the loop has to begin by processing that integer. At the end of the loop, the computer reads a new integer. The computer then jumps back to the beginning of the loop and tests the integer that sentinel value, the loop ends it has just read. Note that when the computer finally reads the before the sentinel value is processed. It is not added to the sum, and it is not counted. This is the way it’s supposed to work. The sentinel is not part of th e data. The original algorithm, even if it could have been made to work without priming, was in correct since it would have summed and counted all the integers, including the sentinel . (Since the sentinel is zero, the sum would still be correct, but the count would be off by one. Such s o-called off-by-one errors are very common. Counting turns out to be harder than it looks !) We can easily turn the algorithm into a complete program. Not e that the program cannot use the statement “ average = sum/count sum and count ;” to compute the average. Since int sum/count is an integer. The average should be are both variables of type , the value of ert one of the int values to a real number. We’ve seen this problem before: we have to conv double to force the computer to compute the quotient as a real number . This can be done a double by type-casting one of the variables to type . The type cast “(double)sum” converts the value of sum to a real number, so in the program the average is computed as “ average = ((double)sum) / count ;”. Another solution in this case would have been to declare sum to be a variable of type in the first place. double One other issue is addressed by the program: If the user enter s zero as the first input value, there are no data to process. We can test for this case by check ing whether count is still equal to zero after the while loop. This might seem like a minor point, but a careful progra mmer should cover all the bases. Here is the full source code for the program: /** * This program reads a sequence of positive integers input * by the user, and it will print out the average of those * integers. The user is prompted to enter one integer at a * time. The user must enter a 0 to mark the end of the * data. (The zero is not counted as part of the data to * be averaged.) The program does not check whether the

98 CHAPTER 3. CONTROL 84 * user’s input is positive, so it will actually add up * both positive and negative input values. */ public class ComputeAverage { public static void main(String[] args) { int inputNumber; // One of the integers input by the user. int sum; // The sum of the positive integers. int count; // The number of positive integers. double average; // The average of the positive integers. /* Initialize the summation and counting variables. */ sum = 0; count = 0; /* Read and process the user’s input. */ System.out.print("Enter your first positive integer: "); inputNumber = TextIO.getlnInt(); while (inputNumber != 0) { sum += inputNumber; // Add inputNumber to running sum. count++; // Count the input by adding 1 to count. System.out.print("Enter your next positive integer, or 0 t o end: "); inputNumber = TextIO.getlnInt(); } /* Display the result. */ if (count == 0) { System.out.println("You didn’t enter any data!"); } else { average = ((double)sum) / count; System.out.println(); System.out.println("You entered " + count + " positive inte gers."); System.out.printf("Their average is %1.3f.\n", average) ; } } // end main() } // end class ComputeAverage 3.3.2 The do..while Statement dition at the end of a loop, instead Sometimes it is more convenient to test the continuation con while loop. The do..while statement is very similar of at the beginning, as is done in the to the while statement, except that the word “while,” along with the cond ition that it tests, has been moved to the end. The word “do” is added to mark the beg inning of the loop. A do..while statement has the form do 〈 statement 〉 while ( 〈 boolean-expression 〉 );

99 CHAPTER 3. CONTROL 85 〈 statement can be a block, or, since, as usual, the 〉 do { statements 〉 〈 〉 } while ( boolean-expression 〈 ); Note the semicolon, ’;’, at the very end. This semicolon is pa rt of the statement, just as the semicolon at the end of an assignment statement or declar ation is part of the statement. statement in Java ends either with a every Omitting it is a syntax error. (More generally, ’.) semicolon or a right brace, ’ } To execute a do , the statement loop, the computer first executes the body of the loop—that is or statements inside the loop—and then it evaluates the bool ean expression. If the value of the expression is , the computer returns to the beginning of the do loop and repeats the true process; if the value is , it ends the loop and continues with the next part of the progr am. false e body of a loop is always Since the condition is not tested until the end of the loop, th do executed at least once. For example, consider the following pseudocode for a game-p laying program. The do loop while loop because with the makes sense here instead of a loop, you know there will be at do least one game. Also, the test that is used at the end of the loo p wouldn’t even make sense at the beginning: do { Play a Game Ask user if he wants to play another game Read the user’s response } while ( the user’s response is yes ); Let’s convert this into proper Java code. Since I don’t want t o talk about game playing at the moment, let’s say that we have a class named Checkers Checkers class contains , and that the playGame() a static member subroutine named that plays one game of checkers against the user. Then, the pseudocode “Play a game” can be expressed as t he subroutine call statement “ Checkers.playGame(); ”. We need a variable to store the user’s response. The TextIO class boolean variable to store the answer to a yes/no question. The makes it convenient to use a input function TextIO.getlnBoolean() allows the user to enter the value as “yes” or “no” be , and “no” is considered to (among other acceptable responses). “Yes” is considered to true false be . So, the algorithm can be coded as boolean wantsToContinue; // True if user wants to play again . do { Checkers.playGame(); System.out.print("Do you want to play again? "); wantsToContinue = TextIO.getlnBoolean(); } while (wantsToContinue == true); boolean variable is set to false When the value of the , it is a signal that the loop should end. When a boolean variable is used in this way—as a signal that is set in one part of the program and tested in another part—it is sometimes called a flag or flag variable (in the sense of a signal flag). sneer at the test By the way, a more-than-usually-pedantic programmer would “ while (wantsToContinue == true) ”. This test is exactly equivalent to “ while (wantsToContinue) ”. Testing whether “ wantsToContinue == true ” is true amounts to the same thing as testing whether “ wantsToContinue ” is true. A little less offensive is an expression

100 CHAPTER 3. CONTROL 86 flag == false ”, where is a boolean variable. The value of “ flag == false ” of the form “ flag ”, where is the boolean negation operator. So !flag is exactly the same as the value of “ ! ” instead of “ while (flag == false) ”, and you can write you can write “ while (!flag) if (!flag) if (flag == false) ”. “ ” instead of “ Although a do..while statement is sometimes more convenient than a while statement, rful. Any problem that can be having two kinds of loops does not make the language more powe do..while solved using while statements, and vice versa. loops can also be solved using only 〈 〉 represents any block of program code, then In fact, if doSomething do { 〈 doSomething 〉 〈 boolean-expression } while ( ); 〉 has exactly the same effect as 〈 doSomething 〉 while ( 〈 boolean-expression 〉 ) { 〈 doSomething 〉 } Similarly, 〈 〉 ) { while ( boolean-expression 〈 doSomething 〉 } can be replaced by 〈 boolean-expression 〉 if ( ) { do { doSomething 〉 〈 } while ( 〈 〉 ); boolean-expression } without changing the meaning of the program in any way. 3.3.3 break and continue The syntax of the while do..while loops allows you to test the continuation condition at and ore natural to have the test either the beginning of a loop or at the end. Sometimes, it is m in the middle of the loop, or to have several tests at different places in the same loop. Java provides a general method for breaking out of the middle of an y loop. It’s called the break statement, which takes the form break; When the computer executes a break statement in a loop, it will immediately jump out of the loop. It then continues on to whatever follows the loop in the program. Consider for example: while (true) { // looks like it will run forever! System.out.print("Enter a positive number: "); N = TextIO.getlnInt(); if (N > 0) // the input value is OK, so jump out of loop break; System.out.println("Your answer must be > 0."); } // continue here after break

101 CHAPTER 3. CONTROL 87 break statement will be executed If the number entered by the user is greater than zero, the puter will print out “Your and the computer will jump out of the loop. Otherwise, the com nput value. > answer must be 0.” and will jump back to the start of the loop to read another i ” might look a bit strange, but it’s perfectly while (true) The first line of this loop, “ while loop can be any boolean-valued expression. The computer legitimate. The condition in a or evaluates this expression and checks whether the value is . The boolean literal true false true So “ while (true) ” can be ” is just a boolean expression that always evaluates to true. “ break statement. y a used to write an infinite loop, or one that will be terminated b break statement terminates the loop that immediately encloses th e break A statement. It is possible to have loops, where one loop statement is contained inside another . If you nested break statement inside a nested loop, it will only break out of that use a loop, not out of labeled break statement lled a the loop that contains the nested loop. There is something ca s not very common, so I will that allows you to specify which loop you want to break. This i go over it quickly. Labels work like this: You can put a label in front of any loop. A label le, a consists of a simple identifier followed by a colon. For examp with a label might while look like “ ”. Inside this loop you can use the labeled break statement mainloop: while... break mainloop; ” to break out of the labeled loop. For example, here is a code s “ egment that checks whether two strings, s1 and s2 , have a character in common. If a common character is found, the value of the flag variable nothingInCommon is set to false , and a labeled break is used to end the processing at that point: boolean nothingInCommon; mmon. nothingInCommon = true; // Assume s1 and s2 have no chars in co int i,j; // Variables for iterating through the chars in s1 an d s2. i = 0; bigloop: while (i < s1.length()) { j = 0; while (j < s2.length()) { if (s1.charAt(i) == s2.charAt(j)) { // s1 and s2 have a common char. nothingInCommon = false; break bigloop; // break out of BOTH loops } j++; // Go on to the next char in s2. } i++; //Go on to the next char in s1. } ∗ ∗ ∗ continue state- break , but less commonly used. A continue The statement is related to ion of the loop. However, instead ment tells the computer to skip the rest of the current iterat of jumping out of the loop altogether, it jumps back to the beg inning of the loop and continues with the next iteration (including evaluating the loop’s co ntinuation condition to see whether any further iterations are required). As with break , when a continue is in a nested loop, it will continue the loop that directly contains it; a “labeled continue” can be used to continue the containing loop instead. do..while continue can be used in while break and loops. They can also be loops and used in for loops, which are covered in the next section. In Section 3.6 , we’ll see that break can statement, also be used to break out of a statement. A break can occur inside an if switch but only if the if statement is nested inside a loop or inside a switch statement. In that case,

102 CHAPTER 3. CONTROL 88 not mean to break out of the . Instead, it breaks out of the loop or switch statement it does if statement. The same consideration applies to statements inside if continue that contains the ifs . 3.4 The for Statement to another type of loop, the for W for loop is e turn in this section statement. Any while loop, so the language doesn’t get any additional power by hav ing for equivalent to some statements. But for a certain type of problem, a loop can be easier to construct and easier for to read than the corresponding loop. It’s quite possible that in real programs, for loops while while actually outnumber loops. 3.4.1 For Loops The for statement makes a common type of while loop easier to write. M any while loops have the general form: initialization 〉 〈 〈 continuation-condition while ( ) { 〉 〈 statements 〉 〈 update 〉 } Section 3.2 : For example, consider this example, copied from an example i n years = 0; // initialize the variable years while ( years < 5 ) { // condition for continuing loop interest = principal * rate; // principal += interest; // do three statements System.out.println(principal); // years++; // update the value of the variable, years } for statement: This loop can be written as the following equivalent for ( years = 0; years < 5; years++ ) { interest = principal * rate; principal += interest; System.out.println(principal); } The initialization, continuation condition, and updating have all been combined in the first line of the for loop. This keeps everything involved in the “control” of the loop in one place, which helps make the loop easier to read and understand. The for loop is executed in exactly the same way as the original code: The initialization part is exe cuted once, before the loop begins. on of the loop, and the loop ends The continuation condition is executed before each executi when this condition is false . The update part is executed at the end of each execution of th e loop, just before jumping back to check the condition. The formal syntax of the for statement is as follows: for ( 〈 initialization 〉 ; 〈 continuation-condition 〉 ; 〈 update 〉 ) 〈 statement 〉

103 CHAPTER 3. CONTROL 89 or, using a block statement: for ( 〉 ; 〈 continuation-condition 〉 ; 〈 update 〉 ) { 〈 initialization statements 〉 〈 } 〉 〉 must be a boolean-valued expression. The 〈 initialization continuation-condition is usu- The 〈 ny expression that would be ally a declaration or an assignment statement, but it can be a 〈 update 〉 can be any simple statement, but is usually allowed as a statement in a program. The f the three parts can be empty. an increment, a decrement, or an assignment statement. Any o were “ true If the continuation condition is empty, it is treated as if it ,” so the loop will be break statement. (Some as a repeated forever or until it ends for some other reason, such for (;;) ” instead of “ while (true) ”.) Here’s a people like to begin an infinite loop with “ for statement: flow control diagram for a For Loop Flow of Control No Is condition true? Yes Do statement for statement assigns a value to some variable, and the Usually, the initialization part of a statement or with an increment update changes the value of that variable with an assignment or decrement operation. The value of the variable is tested i n the continuation condition, and the loop ends when this condition evaluates to false . A variable used in this way is called a loop control variable . In the example given above, the loop control variable was years . Certainly, the most common type of for counting loop , where a loop control loop is the d some maximum value. A variable takes on all integer values between some minimum an counting loop has the form 〈 variable 〉 = 〈 min 〉 ; 〈 variable 〉 for ( 〈 max 〉 ; 〈 variable 〉 ++ ) { <= 〈 statements 〉 } where 〈 min 〉 and 〈 max 〉 are integer-valued expressions (usually constants). The 〈 variable 〉 takes min on the values min 〉 , 〈 min 〉 +1, 〈 〈 〉 +2, . . . , 〈 max 〉 . The value of the loop control variable is often used in the body of the loop. The for loop at the beginning of this section is a counting

104 CHAPTER 3. CONTROL 90 years , takes on the values 1, 2, 3, 4, 5. Here is an even loop in which the loop control variable, simpler example, in which the numbers 1, 2, . . . , 10 are displa yed on standard output: for ( N = 1 ; N <= 10 ; N++ ) System.out.println( N ); For various reasons, Java programmers like to start countin g at 0 instead of 1, and they tend to use a “ <= ”. The following variation of the above loop < ” in the condition, rather than a “ prints out the ten numbers 0, 1, 2, . . . , 9: for ( N = 0 ; N < 10 ; N++ ) System.out.println( N ); < Using <= in the test, or vice versa, is a common source of off-by-one err ors in instead of value to be processed or not? programs. You should always stop and think, Do I want the final t start with 10, decrement It’s easy to count down from 10 to 1 instead of counting up. Jus the loop control variable instead of incrementing it, and co ntinue as long as the variable is greater than or equal to one. for ( N = 10 ; N >= 1 ; N-- ) System.out.println( N ); Now, in fact, the official syntax of a for statement actually allows both the initialization part and the update part to consist of several expressions, s eparated by commas. So we can ime! even count up from 1 to 10 and count down from 10 to 1 at the same t for ( i=1, j=10; i <= 10; i++, j-- ) { System.out.printf("%5d", i); // Output i in a 5-character w ide column. System.out.printf("%5d", j); // Output j in a 5-character c olumn System.out.println(); // and end the line. } for loop that prints out As a final introductory example, let’s say that we want to use a just the even numbers between 2 and 20, that is: 2, 4, 6, 8, 10, 1 2, 14, 16, 18, 20. There are several ways to do this. Just to show how even a very simple pro blem can be solved in many ways, here are four different solutions (three of which would get full credit): (1) // There are 10 numbers to print. // Use a for loop to count 1, 2, // ..., 10. The numbers we want // to print are 2*1, 2*2, ... 2*10. for (N = 1; N <= 10; N++) { System.out.println( 2*N ); } (2) // Use a for loop that counts // 2, 4, ..., 20 directly by // adding 2 to N each time through // the loop. for (N = 2; N <= 20; N = N + 2) { System.out.println( N ); } (3) // Count off all the numbers // 2, 3, 4, ..., 19, 20, but

105 CHAPTER 3. CONTROL 91 // only print out the numbers // that are even. for (N = 2; N <= 20; N++) { if ( N % 2 == 0 ) // is N even? System.out.println( N ); } (4) // Irritate the professor with // a solution that follows the // letter of this silly assignment // while making fun of it. for (N = 1; N <= 1; N++) { System.out.println("2 4 6 8 10 12 14 16 18 20"); } Perhaps it is worth stressing one more time that a for statement, like any statement except rogram. A statement must be for a variable declaration, never occurs on its own in a real p inside the main routine of a program or inside some other subroutine. And tha t subroutine must be defined inside a class. I should also remind you that ev ery variable must be declared able in a before it can be used, and that includes the loop control vari statement. In all for the examples that you have seen so far in this section, the loo p control variables should be int . Here, declared to be of type . It is not required that a loop control variable be an integer for loop in which the variable, ch , is of type char , using the fact that the for example, is a ++ operator can be applied to characters as well as to numbers: // Print out the alphabet on one line of output. char ch; // The loop control variable; // one of the letters to be printed. for ( ch = ’A’; ch <= ’Z’; ch++ ) System.out.print(ch); System.out.println(); 3.4.2 Example: Counting Divisors Let’s look at a less trivial problem that can be solved with a for loop. If N and D are positive integers, we say that D divisor of N if the remainder when D is divided into N is zero. is a (Equivalently, we could say that N D .) In terms of Java programming, D is an even multiple of N if N % D is zero. is a divisor of Let’s write a program that inputs a positive integer, N , from the user and computes how many different divisors has. The numbers that could possibly be divisors of N are 1, 2, . . . , N . N To compute the number of divisors of N , we can just test each possible divisor of N and count the ones that actually do divide N evenly. In pseudocode, the algorithm takes the form Get a positive integer, N, from the user Let divisorCount = 0 for each number, testDivisor, in the range from 1 to N: if testDivisor is a divisor of N: Count it by adding 1 to divisorCount Output the count

106 CHAPTER 3. CONTROL 92 s used when some, but not all, This algorithm displays a common programming pattern that i of a sequence of items are to be processed. The general patter n is for each item in the sequence: if the item passes the test: process it loop in our divisor-counting algorithm can be translated in to Java code as The for for (testDivisor = 1; testDivisor <= N; testDivisor++) { if ( N % testDivisor == 0 ) divisorCount++; } On a modern computer, this loop can be executed very quickly. It is not impossible to run it even for the largest legal value, 2147483647. (If you wanted to run it for even larger int long .) However, it does take a significant int values, you could use variables of type rather than amount of time for very large numbers. So when I implemented t his algorithm, I decided to output a dot every time the computer has tested one million po ssible divisors. In the improved version of the program, there are two types of counting going on. We have to count the number of divisors and we also have to count the number of possible di visors that have been tested. So the program needs two counters. When the second counter re aches 1000000, the program t counting the next group of one outputs a ’.’ and resets the counter to zero so that we can star ike million. Reverting to pseudocode, the algorithm now looks l Get a positive integer, N, from the user Let divisorCount = 0 // Number of divisors found. Let numberTested = 0 // Number of possible divisors tested // since the last period was output. for each number, testDivisor, in the range from 1 to N: if testDivisor is a divisor of N: Count it by adding 1 to divisorCount Add 1 to numberTested if numberTested is 1000000: print out a ’.’ Reset numberTested to 0 Output the count program: Finally, we can translate the algorithm into a complete Java /** * This program reads a positive integer from the user. * It counts how many divisors that number has, and * then it prints the result. */ public class CountDivisors { public static void main(String[] args) { int N; // A positive integer entered by the user. // Divisors of this number will be counted. int testDivisor; // A number between 1 and N that is a // possible divisor of N. int divisorCount; // Number of divisors of N that have been fo und.

107 CHAPTER 3. CONTROL 93 s int numberTested; // Used to count how many possible divisor // of N have been tested. When the number // reaches 1000000, a period is output and // the value of numberTested is reset to zero. /* Get a positive integer from the user. */ while (true) { System.out.print("Enter a positive integer: "); N = TextIO.getlnInt(); if (N > 0) break; ry again."); System.out.println("That number is not positive. Please t } /* Count the divisors, printing a "." after every 1000000 tes ts. */ divisorCount = 0; numberTested = 0; for (testDivisor = 1; testDivisor <= N; testDivisor++) { if ( N % testDivisor == 0 ) divisorCount++; numberTested++; if (numberTested == 1000000) { System.out.print(’.’); numberTested = 0; } } /* Display the result. */ System.out.println(); System.out.println("The number of divisors of " + N + " is " + divisorCount); } // end main() } // end class CountDivisors 3.4.3 Nested for Loops Control structures in Java are statements that contain othe r, simpler statements. In particular, already seen several examples of control structures can contain control structures. You’ve if statements inside loops, and one example of a loop inside another while , but any while combination of one control structure inside another is poss ible. We say that one structure is nested inside another. You can even have multiple levels of nesting, such as a while loop inside an statement inside another while loop. The syntax of Java does not set a limit on if the number of levels of nesting. As a practical matter, thoug h, it’s difficult to understand a program that has more than a few levels of nesting. Nested for loops arise naturally in many algorithms, and it is importan t to understand how they work. Let’s look at a couple of examples. First, conside r the problem of printing out a multiplication table like this one:

108 CHAPTER 3. CONTROL 94 1 2 3 4 5 6 7 8 9 10 11 12 2 4 6 8 10 12 14 16 18 20 22 24 3 6 9 12 15 18 21 24 27 30 33 36 4 8 12 16 20 24 28 32 36 40 44 48 5 10 15 20 25 30 35 40 45 50 55 60 6 12 18 24 30 36 42 48 54 60 66 72 7 14 21 28 35 42 49 56 63 70 77 84 8 16 24 32 40 48 56 64 72 80 88 96 9 18 27 36 45 54 63 72 81 90 99 108 10 20 30 40 50 60 70 80 90 100 110 120 11 22 33 44 55 66 77 88 99 110 121 132 12 24 36 48 60 72 84 96 108 120 132 144 The process of printing them The data in the table are arranged into 12 rows and 12 columns. out can be expressed in a pseudocode algorithm as for each rowNumber = 1, 2, 3, ..., 12: Print the first twelve multiples of rowNumber on one line Output a carriage return for The first step in the for loop. We can expand “Print the loop can itself be expressed as a rowNumber first twelve multiples of on one line” as: for N = 1, 2, 3, ..., 12: Print N * rowNumber for so a refined algorithm for printing the table has one loop nested inside another: for each rowNumber = 1, 2, 3, ..., 12: for N = 1, 2, 3, ..., 12: Print N * rowNumber Output a carriage return We want to print the output in neat columns, with each output n umber taking up four spaces. This can be done using formatted output with format specifier %4d rowNumber . Assuming that N int , the algorithm can be expressed in Java as and have been declared to be variables of type for ( rowNumber = 1; rowNumber <= 12; rowNumber++ ) { for ( N = 1; N <= 12; N++ ) { // print in 4-character columns System.out.printf( "%4d", N * rowNumber ); // No carriage re turn ! } System.out.println(); // Add a carriage return at end of the line. } This section has been weighed down with lots of examples of nu merical processing. For our next example, let’s do some text processing. Consider the pr oblem of finding which of the 26 letters of the alphabet occur in a given string. For example, the letters that occur in “Hello World” are D, E, H, L, O, R, and W. More specifically, we will wri te a program that will list all the letters contained in a string and will also count the numb er of different letters. The string will be input by the user. Let’s start with a pseudocode algor ithm for the program. Ask the user to input a string Read the response into a variable, str Let count = 0 (for counting the number of different letters) for each letter of the alphabet: if the letter occurs in str:

109 CHAPTER 3. CONTROL 95 Print the letter Add 1 to count Output the count Since we want to process the entire line of text that is entere d by the user, we’ll use TextIO.getln() er of the al- to read it. The line of the algorithm that reads “for each lett phabet” can be expressed as “ for (letter=’A’; letter<=’Z’; letter++) ”. But the if statement inside the . How for loop needs still more thought before we can write the program letter , occurs in str ? One idea is to look at each do we check whether the given letter, cter is equal to character in the string in turn, and check whether that chara . We can letter get the -th character of str with the function call str.charAt(i) , where i ranges from 0 to i str.length() - 1 . str in either upper or lower case, ’A’ One more difficulty: A letter such as ’A’ can occur in or ’a’. We have to check for both of these. But we can avoid this str difficulty by converting to upper case before processing it. Then, we only have to chec k for the upper case letter. We can now flesh out the algorithm fully: Ask the user to input a string Read the response into a variable, str Convert str to upper case Let count = 0 for letter = ’A’, ’B’, ..., ’Z’: for i = 0, 1, ..., str.length()-1: if letter == str.charAt(i): Print letter Add 1 to count break // jump out of the loop, to avoid counting letter twice Output the count break in the nested Note the use of loop. It is required to avoid printing or counting a given for letter more than once (in the case where it occurs more than on ce in the string). The break statement breaks out of the inner for loop, but not the outer for loop. Upon executing the break , the computer continues the outer loop with the next value of letter . You should try to figure out exactly what would be at the end of this program, if the break statement count were omitted. Here is the complete program: /** * This program reads a line of text entered by the user. * It prints a list of the letters that occur in the text, * and it reports how many different letters were found. */ public class ListLetters { public static void main(String[] args) { String str; // Line of text entered by the user. int count; // Number of different letters found in str. char letter; // A letter of the alphabet. System.out.println("Please type in a line of text."); str = TextIO.getln(); str = str.toUpperCase(); count = 0;

110 CHAPTER 3. CONTROL 96 tters:"); System.out.println("Your input contains the following le System.out.println(); System.out.print(" "); for ( letter = ’A’; letter <= ’Z’; letter++ ) { int i; // Position of a character in str. for ( i = 0; i < str.length(); i++ ) { if ( letter == str.charAt(i) ) { System.out.print(letter); System.out.print(’ ’); count++; break; } } } System.out.println(); System.out.println(); System.out.println("There were " + count + " different lett ers."); } // end main() } // end class ListLetters In fact, there is actually an easier way to determine whether a given letter occurs in a string, . The built-in function str will return -1 if letter does not occur in str.indexOf(letter) the string. It returns a number greater than or equal to zero i f it does occur. So, we could letter ”. str simply by checking “ if (str.indexOf(letter) >= 0) check whether occurs in If we used this technique in the above program, we wouldn’t ne for loop. This gives ed a nested you a preview of how subroutines can be used to deal with compl exity. 3.5 The if Statement T he first of the two branching statements in Java is the if statement, which you Section 3.1 . It takes the form have already seen in 〈 〉 ) if ( boolean-expression 〈 statement-1 〉 else statement-2 〉 〈 As usual, the statements inside an if if statement represents statement can be blocks. The else a two-way branch. The if statement—consisting of the word “else” and the part of an statement that follows it—can be omitted. 3.5.1 The Dangling else Problem Now, an if statement is, in particular, a statement. This means that ei ther 〈 statement-1 〉 or statement-2 〉 in the above if statement can itself be an if statement. A problem arises, 〈 however, if 〈 statement-1 〉 is an if statement that has no else part. This special case is effectively forbidden by the syntax of Java. Suppose, for exa mple, that you type

111 CHAPTER 3. CONTROL 97 if ( x > 0 ) if (y > 0) System.out.println("First case"); else System.out.println("Second case"); Now, remember that the way you’ve indented this doesn’t mean anything at all to the computer. You might think that the else part is the second half of your “ if (x > 0) ” statement, but the rule that the computer follows attaches the if (y > 0) ”, which is closer. That else to “ : is, the computer reads your statement as if it were formatted if ( x > 0 ) if (y > 0) System.out.println("First case"); else System.out.println("Second case"); enclosing the nested in a You can force the computer to use the other interpretation by if block: if ( x > 0 ) { if (y > 0) System.out.println("First case"); } else System.out.println("Second case"); These two if statements have different meanings: In the case when x <= 0 , the first statement doesn’t print anything, but the second statement prints “Se cond case”. 3.5.2 Multiway Branching Much more interesting than this technicality is the case whe re 〈 statement-2 〉 , the else part of the if if statement. The statement would look like this (perhaps statement, is itself an without the final else part): if ( boolean-expression-1 〉 ) 〈 statement-1 〉 〈 else 〈 boolean-expression-2 〉 ) if ( 〈 statement-2 〉 else 〈 statement-3 〉 However, since the computer doesn’t care how a program is lai d out on the page, this is almost always written in the format: if ( 〈 boolean-expression-1 ) 〉 〈 statement-1 〉 else if ( 〈 boolean-expression-2 〉 ) 〈 statement-2 〉 else 〈 statement-3 〉

112 CHAPTER 3. CONTROL 98 three-way branch. When the You should think of this as a single statement representing a 〈 statement-1 〉 , 〈 statement- computer executes this, one and only one of the three stateme nts— , or —will be executed. The computer starts by evaluating statement-3 〉 〉 〈 boolean-expression- 2 〈 〉 true , the computer executes 〈 statement-1 〉 and then jumps all the way to the end of 1 . If it is 〈 statements 〉 . If 〈 boolean-expression-1 〉 is false the outer if statement, skipping the other two , the computer skips statement-1 〉 and executes the second, nested if statement. To do this, 〈 and 〈 and uses it to decide between 〈 statement-2 〉 〉 it tests the value of boolean-expression-2 statement-3 〉 . 〈 ssages, depending on the Here is an example that will print out one of three different me value of a variable named temperature : if (temperature < 50) System.out.println("It’s cold."); else if (temperature < 80) System.out.println("It’s nice."); else System.out.println("It’s hot."); If is, say, 42, the first test is true . The computer prints out the message “It’s temperature cold”, and skips the rest—without even evaluating the secon d condition. For a temperature of 75, the first test is false , so the computer goes on to the second test. This test is true , so the computer prints “It’s nice” and skips the rest. If the tem perature is 173, both of the tests false , so the computer says “It’s hot” (unless its circuits have be evaluate to en fried by the heat, that is). ay branches with any number You can go on stringing together “else-if’s” to make multi-w of cases: test-1 〉 if ( 〈 ) statement-1 〉 〈 〈 else if ( 〉 ) test-2 〈 〉 statement-2 〈 ) 〉 else if ( test-3 〈 〉 statement-3 . . // (more cases) . else if ( 〈 test-N 〉 ) 〈 statement-N 〉 else 〈 statement-(N+1) 〉 ions, one after the other until it The computer evaluates the tests, which are boolean express comes to one that is true . It executes the associated statement and skips the rest. If none of the boolean expressions evaluate to true , then the statement in the else part is executed. This statement is called a multi-way branch because one and o nly one of the statements will be executed. The final else part can be omitted. In that case, if all the boolean expressi ons are false, none of the statements are executed. Of course, each o f the statements can be a block, consisting of a number of statements enclosed between { and } . Admittedly, there is lot of syntax here; as you study and practice, you’ll become comfor table with it. It might be useful to look at a flow control diagram for the general “if..else if” statement shown above:

113 CHAPTER 3. CONTROL 99 Yes No Yes No Do statemen t  Yes Do statemen t-2 Yes No Do statement-(N+1) Do statement-N 3.5.3 If Statement Examples if statements, let’s suppose that As an example of using , y , and z are variables of type int , x and that each variable has already been assigned a value. Con sider the problem of printing out the values of the three variables in increasing order. For ex ample, if the values are 42, 17, and 20, then the output should be in the order 17, 20, 42. One way to approach this is to ask, where does x belong in the list? It comes first if it’s less than both y and z . It comes last if it’s greater than both y and z . Otherwise, it comes in the middle. We can express this with a 3-way if statement, but we still have to worry about y z should be printed. In pseudocode, the order in which and if (x < y && x < z) { output x, followed by y and z in their correct order } else if (x > y && x > z) { output y and z in their correct order, followed by x } else { output x in between y and z in their correct order } Determining the relative order of y and z requires another if statement, so this becomes if (x < y && x < z) { // x comes first if (y < z) System.out.println( x + " " + y + " " + z ); else System.out.println( x + " " + z + " " + y );

114 CHAPTER 3. CONTROL 100 } else if (x > y && x > z) { // x comes last if (y < z) System.out.println( y + " " + z + " " + x ); else System.out.println( z + " " + y + " " + x ); } else { // x in the middle if (y < z) System.out.println( y + " " + x + " " + z); else System.out.println( z + " " + x + " " + y); } e of the values are the same. If You might check that this code will work correctly even if som the values of two variables are the same, it doesn’t matter wh ich order you print them in. Note, by the way, that even though you can say in English “if x i s less than y and z,” you if (x < y && z) can’t say in Java “ && operator can only be used between boolean ”. The values, so you have to make separate tests, and x y ) // z comes last System.out.println( x + " " + y + " " + z); else // z is in the middle System.out.println( x + " " + z + " " + y); } else { // y comes before x if ( z < y ) // z comes first System.out.println( z + " " + y + " " + x); else if ( z > x ) // z comes last System.out.println( y + " " + x + " " + z); else // z is in the middle System.out.println( y + " " + z + " " + x); } Once again, we see how the same problem can be solved in many di fferent ways. The two approaches to this problem have not exhausted all the possib ilities. For example, you might start by testing whether x is greater than y . If so, you could swap their values. Once you’ve done that, you know that should be printed before y . x ∗ ∗ ∗ Finally, let’s write a complete program that uses an if statement in an interesting way. I want a program that will convert measurements of length from one unit of measurement to another, such as miles to yards or inches to feet. So far, the p roblem is extremely under- specified. Let’s say that the program will only deal with meas urements in inches, feet, yards, and miles. It would be easy to extend it later to deal with othe r units. The user will type in a measurement in one of these units, such as “17 feet” or “2.73 miles”. The output will show

115 CHAPTER 3. CONTROL 101 each of the four units of measure. (This is easier than asking the u the length in terms of ser which units to use in the output.) An outline of the process is Read the user’s input measurement and units of measure Express the measurement in inches, feet, yards, and miles Display the four results The program can read both parts of the user’s input from the sa me line by using TextIO.getlnWord() TextIO.getDouble() to read the numerical measurement and to read asure can be simplified by first the unit of measure. The conversion into different units of me converting the user’s input into inches. From there, the num ber of inches can easily be con- nches, we have to test the input to verted into feet, yards, and miles. Before converting into i determine which unit of measure the user has specified: Let measurement = TextIO.getDouble() Let units = TextIO.getlnWord() if the units are inches Let inches = measurement else if the units are feet Let inches = measurement * 12 // 12 inches per foot else if the units are yards Let inches = measurement * 36 // 36 inches per yard else if the units are miles Let inches = measurement * 12 * 5280 // 5280 feet per mile else The units are illegal! Print an error message and stop processing Let feet = inches / 12.0 Let yards = inches / 36.0 Let miles = inches / (12.0 * 5280.0) Display the results Since units is a String , we can use units.equals("inches") to check whether the spec- ified unit of measure is “inches”. However, it would be nice to allow the units to be spec- ssibilities, we can check ified as “inch” or abbreviated to “in”. To allow these three po if (units.equals("inches") || units.equals("inch") || unit s.equals("in")) . It would ”. We can do this by converting also be nice to allow upper case letters, as in “Inches” or “IN to lower case before testing it or by substituting the functi on units.equalsIgnoreCase units for units.equals . In my final program, I decided to make things more interesting by allowing the user to repeat the process of entering a measurement and seeing the r esults of the conversion for each measurement. The program will end only when the user inputs 0 . To program that, I just had to wrap the above algorithm inside a while loop, and make sure that the loop ends when the user inputs a 0. Here’s the complete program: /** * This program will convert measurements expressed in inche s, * feet, yards, or miles into each of the possible units of * measure. The measurement is input by the user, followed by * the unit of measure. For example: "17 feet", "1 inch", or * "2.73 mi". Abbreviations in, ft, yd, and mi are accepted. * The program will continue to read and convert measurements * until the user enters an input of 0. */

116 CHAPTER 3. CONTROL 102 public class LengthConverter { public static void main(String[] args) { double measurement; // Numerical measurement, input by use r. String units; // The unit of measure for the input, also // specified by the user. double inches, feet, yards, miles; // Measurement expresse d in // each possible unit of // measure. System.out.println("Enter measurements in inches, feet, yards, or miles."); "); System.out.println("For example: 1 inch 17 feet 2.73 miles "); System.out.println("You can use abbreviations: in ft yd mi er units"); System.out.println("I will convert your input into the oth System.out.println("of measure."); System.out.println(); while (true) { /* Get the user’s input, and convert units to lower case. */ System.out.print("Enter your measurement, or 0 to end: "); measurement = TextIO.getDouble(); if (measurement == 0) break; // Terminate the while loop. units = TextIO.getlnWord(); units = units.toLowerCase(); // convert units to lower case /* Convert the input measurement to inches. */ if (units.equals("inch") || units.equals("inches") || units.equals("in")) { inches = measurement; } else if (units.equals("foot") || units.equals("feet") || units.equals("ft")) { inches = measurement * 12; } else if (units.equals("yard") || units.equals("yards") || units.equals("yd")) { inches = measurement * 36; } else if (units.equals("mile") || units.equals("miles") || units.equals("mi")) { inches = measurement * 12 * 5280; } else { System.out.println("Sorry, but I don’t understand \"" + units + "\"."); continue; // back to start of while loop } /* Convert measurement in inches to feet, yards, and miles. * / feet = inches / 12; yards = inches / 36;

117 CHAPTER 3. CONTROL 103 miles = inches / (12*5280); /* Output measurement in terms of each unit of measure. */ System.out.println(); System.out.println("That’s equivalent to:"); System.out.printf("%12.5g", inches); System.out.println(" inches"); System.out.printf("%12.5g", feet); System.out.println(" feet"); System.out.printf("%12.5g", yards); System.out.println(" yards"); System.out.printf("%12.5g", miles); System.out.println(" miles"); System.out.println(); } // end while System.out.println(); System.out.println("OK! Bye for now."); } // end main() } // end class LengthConverter (Note that this program uses formatted output with the “g” fo rmat specifier. In this pro- s might be. It could easily gram, we have no control over how large or how small the number rements. The “g” format will make sense for the user to enter very large or very small measu print a real number in exponential form if it is very large or v ery small, and in the usual decimal form otherwise. Remember that in the format specification , the 5 is the total number %12.5g of significant digits that are to be printed, so we will always get the same number of significant digits in the output, no matter what the size of the number. If we had used an “f” format specifier such as %12.5f , the output would be in decimal form with 5 digits after the de cimal point. This would print the number 0.000000000745482 as 0.00000 significant digits , with no 7.4549e-10 at all! With the “g” format specifier, the output would be .) 3.5.4 The Empty Statement tatement in Java: the empty As a final note in this section, I will mention one more type of s . This is a statement that consists simply of a semicolon and w hich tells the computer statement to do nothing. The existence of the empty statement makes the following legal, even though you would not ordinarily see a semicolon after a } : if (x < 0) { x = -x; }; The semicolon is legal after the } , but the computer considers it to be an empty statement, not part of the if statement. Occasionally, you might find yourself using the e mpty statement when what you mean is, in fact, “do nothing.” For example, the rather contrived if statement if ( done ) ; // Empty statement else System.out.println( "Not done yet.");

118 CHAPTER 3. CONTROL 104 boolean variable is true, and prints out “Not done yet” when does nothing when the done it is false. You can’t just leave out the semicolon in this exa mple, since Java syntax requires an actual statement between the . I prefer, though, to use an empty block, if else and the } with nothing between, for such cases. { consisting of and Occasionally, stray empty statements can cause annoying, h ard-to-find errors in a program. once o” just For example, the following program segment prints out “Hell , not ten times: for (i = 0; i < 10; i++); System.out.println("Hello"); Why? Because the “;” at the end of the first line is a statement, and it is this empty statement System.out.println statement is not really inside the for that is executed ten times. The for loop has completed. The for statement at all, so it is executed just once, after the loop just does nothing, ten times! 3.6 The switch Statement T switch statement, which is introduced he second branching statement in Java is the statement is used far less often than the switch statement, but it is in this section. The if sometimes useful for expressing a certain type of multiway b ranch. 3.6.1 The Basic switch Statement on and, depending on that value, A switch statement allows you to test the value of an expressi t. Only expressions of certain to jump directly to some location within the switch statemen primitive integer types , types can be used. The value of the expression can be one of the int , or byte short char type. It can be String . Or it can be an enum type . It can be the primitive (see Subsection 2.3.4 for an introduction to enums). In particular, note that the e xpression cannot be a or float value. double re marked with The positions within a switch statement to which it can jump a case labels 〈 constant 〉 :”. The 〈 constant 〉 here is a literal of the same type as the that take the form: “case switch . A case label marks the position the computer jumps to when th e expression in the 〈 value. As the final case in a switch statement you 〉 expression evaluates to the given constant can, optionally, use the label “default:”, which provides a default jump point that is used when the value of the expression is not listed in any case label. A switch statement, as it is most often used, has the form: switch ( 〈 expression 〉 ) { case 〈 〉 : constant-1 statements-1 〉 〈 break; case 〈 constant-2 〉 : 〈 statements-2 〉 break; . . // (more cases) . case 〈 constant-N 〉 : 〈 statements-N 〉 break; default: // optional default case

119 CHAPTER 3. CONTROL 105 statements-(N+1) 〉 〈 } // end of switch statement if statement, but the This has exactly the same effect as the following multiway switch ate one expression and jump statement can be more efficient because the computer can evalu directly to the correct case, whereas in the statement, the computer must evaluate up to N if expressions before it knows which set of statements to execu te: expression 〉 == 〈 constant-1 〉 ) { // but use .equals for String!! 〈 if ( statements-2 〉 〈 } else if ( expression 〉 == 〈 constant-2 〉 ) { 〈 statements-3 〈 〉 } else . . . 〈 expression 〉 else if ( 〈 constant-N 〉 ) { == 〈 statements-N 〉 } else { statements-(N+1) 〉 〈 } break statements in the are technically optional. The effect of a break is to The switch make the computer jump past the end of the switch statement, s kipping over all the remaining cases. If you leave out the break statement, the computer wil l just forge ahead after completing one case and will execute the statements associated with the next case label. This is rarely what you want, but it is legal. (I will note here—although you won’t understand it until you get to the next chapter—that inside a subroutine, the break statement is sometimes replaced by a return statement, which terminates the subroutine as well as the sw itch.) Note that you can leave out one of the groups of statements ent irely (including the ). break t constants. This just means You then have two case labels in a row, containing two differen that the computer will jump to the same place and perform the s ame action for each of the two constants. Here is an example of a switch statement. This is not a useful e xample, but it should be easy for you to follow. Note, by the way, that the constants in the case labels don’t have to be in any particular order, but they must all be different: switch ( N ) { // (Assume N is an integer variable.) case 1: System.out.println("The number is 1."); break; case 2: case 4: case 8: System.out.println("The number is 2, 4, or 8."); System.out.println("(That’s a power of 2!)"); break; case 3: case 6: case 9:

120 CHAPTER 3. CONTROL 106 System.out.println("The number is 3, 6, or 9."); System.out.println("(That’s a multiple of 3!)"); break; case 5: System.out.println("The number is 5."); break; default: System.out.println("The number is 7 or is outside the range 1 to 9."); } The switch statement is pretty primitive as control structu res go, and it’s easy to make mis- irectly from the older programming takes when you use it. Java takes all its control structures d languages C and C++. The switch statement is certainly one pl ace where the designers of Java should have introduced some improvements. 3.6.2 Menus and switch Statements One application of statements is in processing menus. A menu is a list of options . switch nd to each possible choice in a The user selects one of the options. The computer has to respo umber of the chosen option can different way. If the options are numbered 1, 2, . . . , then the n switch be used in a statement to select the proper response. In a TextIO -based program, the menu can be presented as a numbered list o f options, and the user can choose an option by typing in its number. Here is a n example that could be used in a variation of the LengthConverter example from the previous section: er. int optionNumber; // Option number from menu, selected by us e user. double measurement; // A numerical measurement, input by th // The unit of measurement depends on which // option the user has selected. double inches; // The same measurement, converted into inch es. /* Display menu and get user’s selected option number. */ System.out.println("What unit of measurement does your in put use?"); System.out.println(); System.out.println(" 1. inches"); System.out.println(" 2. feet"); System.out.println(" 3. yards"); System.out.println(" 4. miles"); System.out.println(); System.out.println("Enter the number of your choice: "); optionNumber = TextIO.getlnInt(); /* Read user’s measurement and convert to inches. */ switch ( optionNumber ) { case 1: System.out.println("Enter the number of inches: "); measurement = TextIO.getlnDouble(); inches = measurement; break; case 2: System.out.println("Enter the number of feet: "); measurement = TextIO.getlnDouble(); inches = measurement * 12;

121 CHAPTER 3. CONTROL 107 break; case 3: System.out.println("Enter the number of yards: "); measurement = TextIO.getlnDouble(); inches = measurement * 36; break; case 4: System.out.println("Enter the number of miles: "); measurement = TextIO.getlnDouble(); inches = measurement * 12 * 5280; break; default: System.out.println("Error! Illegal option number! I quit !"); System.exit(1); } // end switch /* Now go on to convert inches to feet, yards, and miles... */ This example could instead be written using a String in the statement: switch String units; // Unit of measurement, entered by user. double measurement; // A numerical measurement, input by th e user. double inches; // The same measurement, converted into inch es. /* Read the user’s unit of measurement. */ System.out.println("What unit of measurement does your in put use?"); or miles : "); System.out.print("Legal responses: inches, feet, yards, units = TextIO.getln().toLowerCase(); /* Read user’s measurement and convert to inches. */ System.out.print("Enter the number of " + units + ": "); measurement = TextIO.getlnDouble(); switch ( units ) { case "inches": inches = measurement; break; case "feet": inches = measurement * 12; break; case "yards": inches = measurement * 36; break; case "miles": inches = measurement * 12 * 5280; break; default: System.out.println("Wait a minute! Illegal unit of measur e! I quit!"); System.exit(1); } // end switch

122 CHAPTER 3. CONTROL 108 3.6.3 Enums in switch Statements The type of the expression in a switch can be an enumerated type. In that case, the constants labels must be values from the enumerated type. For example, case suppose that the in the type of the expression is the enumerated type Season defined by enum Season { SPRING, SUMMER, FALL, WINTER } statement is an expression of type and that the expression in a . The constants switch Season Season.SPRING , Season.SUMMER , in the case label must be chosen from among the values , or Season.FALL . However, there is a quirk in the syntax: when an enum Season.WINTER constant is used in a label, only the simple name, such as “ SPRING ” is used, not the full case Season.SPRING name, such as “ ”. Of course, the computer already knows that the value in the label must belong to the enumerated type, since it can tell th at from the type of expression case constant. For example, assuming used, so there is really no need to specify the type name in the currentSeason is a variable of type Season , then we could have the switch statement: that switch ( currentSeason ) { case WINTER: // ( NOT Season.WINTER ! ) System.out.println("December, January, February"); break; case SPRING: System.out.println("March, April, May"); break; case SUMMER: System.out.println("June, July, August"); break; case FALL: System.out.println("September, October, November"); break; } 3.6.4 Definite Assignment and switch Statements As a somewhat more realistic example, the following switch statement makes a ran- dom choice among three possible alternatives. Recall that t he value of the expression (int)(3*Math.random()) is one of the integers 0, 1, or 2, selected at random with equal probability, so the switch statement below will assign one of the values "Rock" , "Paper" , "Scissors" computerMove , with probability 1/3 for each case: to switch ( (int)(3*Math.random()) ) { case 0: computerMove = "Rock"; break; case 1: computerMove = "Paper"; break; case 2: computerMove = "Scissors"; break; } Now, this switch statement is perfectly OK, but suppose that we use it in the fo llowing code segment:

123 CHAPTER 3. CONTROL 109 String computerMove; switch ( (int)(3*Math.random()) ) { case 0: computerMove = "Rock"; break; case 1: computerMove = "Paper"; break; case 2: computerMove = "Scissors"; break; } // ERROR! System.out.println("The computer’s move is " + computerMo ve); s due to definite assignment, Now there is a subtle error on the last line! The problem here i the idea that the Java compiler must be able to determine that a variable has definitely been Subsection 3.1.4 . assigned a value before its value is used. Definite assignmen t was introduced in In this example, it’s true that the three cases in the cover all the possibilities, but the switch at there is an integer-valued compiler is not smart enough to figure that out; it just sees th switch but not all possible integer values are covered by the given c ases. expression in the A simple solution is to replace the final in the switch statement with default . With case a default case, all possible values of the expression in the switch are certainly covered, and the compiler knows that computerMove is definitely assigned a value: String computerMove; switch ( (int)(3*Math.random()) ) { case 0: computerMove = "Rock"; break; case 1: computerMove = "Paper"; break; default : computerMove = "Scissors"; break; } System.out.println("The computer’s move is " + computerMo ve); // OK! 3.7 Introduction to Exceptions and try..catch I n addition to the control structures that determine the normal flow of control in a program, Java has a way to deal with “exceptional” cases that throw the flow of control off its normal track. When an error occurs during the execution of a p rogram, the default behavior is to terminate the program and to print an error message. How ever, Java makes it possible to “catch” such errors and program a response different from sim ply letting the program crash. This is done with the try..catch statement. In this section, we will take a preliminary and incomplete look the try..catch statement, leaving out a lot of the rather complex syntax of this statement. Error handling is a complex topic, which we w ill return to in Chapter 8 , and we will cover the full syntax of try..catch at that time.

124 CHAPTER 3. CONTROL 110 3.7.1 Exceptions The term le with exception is used to refer to the type of error that one might want to hand . An exception is an exception to the normal flow of control in t he program. a try..catch The term is used in preference to “error” because in some case s, an exception might not be exception as just another way considered to be an error at all. You can sometimes think of an to organize a program. Exceptions in Java are represented as objects of type Exception . Actual exceptions are . Different subclasses represent different types of Exception usually defined by subclasses of NumberFormatException exceptions. We will look at only two types of exception in thi s section: . IllegalArgumentException and can occur when an attempt is made to convert a string A NumberFormatException Such conversions are done by the functions Integer.parseInt into a number. and (See Double.parseDouble . .) Consider the function call Subsection 2.5.7 where str Integer.parseInt(str) String . If the value of str is the is a variable of type string , then the function call will correctly convert the string in to the int 42. However, "42" str is, say, , the function call will fail because "fred" is not a legal "fred" if the value of value. In this case, an exception of type NumberFormatException int string representation of an am will crash. occurs. If nothing is done to handle the exception, the progr IllegalArgumentException can occur when an illegal value is passed as a parameter to a An ameter be greater than or equal to subroutine. For example, if a subroutine requires that a par IllegalArgumentException might occur when a negative value is passed to the subroutine . zero, an How to respond to the illegal value is up to the person who wrot e the subroutine, so we can’t simply say that every illegal parameter value will res ult in an IllegalArgumentException . However, it is a common response. 3.7.2 try..catch When an exception occurs, we say that the exception is “throw n”. For example, we say that throws an exception of type when the value Integer.parseInt(str) NumberFormatException is illegal. When an exception is thrown, it is possible to “ca tch” the exception and str of try..catch statement. In simplified prevent it from crashing the program. This is done with a form, the syntax for a try..catch can be: try { statements-1 〈 〉 } ) { exception-class-name 〉 〈 catch ( 〉 〈 variable-name 〈 statements-2 〉 } The 〈 exception-class-name 〉 could be NumberFormatException , IllegalArgumentException , or some other exception class. When the computer executes this try..catch statement, it exe- try 〈 statements- cutes the statements in the part. If no exception occurs during the execution of 〉 , then the computer just skips over the 1 part and proceeds with the rest of the pro- catch gram. However, if an exception of type 〈 exception-class-name 〉 occurs during the execution of 〈 statements-1 〉 , the computer immediately jumps from the point where the exc eption occurs to the part and executes 〈 statements-2 〉 , skipping any remaining statements in 〈 statements- catch 1 〉 . Note that only one type of exception is caught; if some other type of exception occurs during the execution of 〈 statements-1 〉 , it will crash the program as usual.

125 CHAPTER 3. CONTROL 111 〈 statements-2 , the 〈 variable-name 〉 represents the exception object, During the execution of 〉 ct contains information about so that you can, for example, print it out. The exception obje the cause of the exception. This includes an error message, w hich will be displayed if you print out the exception object. part, the computer proceeds with the rest of the program; the After the end of the catch rogram. exception has been caught and handled and does not crash the p { and } , are part of the syntax of the try..catch By the way, note that the braces, ent between the braces. This is statement. They are required even if there is only one statem aces around a single statement different from the other statements we have seen, where the br are optional. As an example, suppose that String whose value might or might str is a variable of type not represent a legal real number. Then we could say: double x; try { x = Double.parseDouble(str); System.out.println( "The number is " + x ); } catch ( NumberFormatException e ) { System.out.println( "Not a legal number." ); x = Double.NaN; } If an error is thrown by the call to Double.parseDouble(str) , then the output statement in try part is skipped, and the statement in the catch part is executed. (In this example, the I set x to be the value Double.NaN when an exception occurs. Double.NaN is the special “not-a-number” value for type double .) not rogram. Often that It’s always a good idea to catch exceptions and continue with the p can just lead to an even bigger mess later on, and it might be be tter just to let the exception crash the program at the point where it occurs. However, some times it’s possible to recover from an error. age of a sequence of real Suppose, for example, we want a program that will find the aver end of the sequence by entering numbers entered by the user, and we want the user to signal the from Section 3.3 , but a blank line. (This is similar to the sample program in that program the user entered a zero to signal end-of-inpu t.) If we use TextIO.getlnInt() to read the user’s input, we will have no way of detecting the b lank line, since that function simply skips over blank lines. A solution is to use TextIO.getln() to read the user’s input. non-blank inputs to numbers This allows us to detect a blank input line, and we can convert using . And we can use try..catch to avoid crashing the program when Double.parseDouble the user’s input is not a legal number. Here’s the program: public class ComputeAverage2 { public static void main(String[] args) { String str; // The user’s input. double number; // The input converted into a number. double total; // The total of all numbers entered. double avg; // The average of the numbers. int count; // The number of numbers entered. total = 0; count = 0; System.out.println("Enter your numbers, press return to e nd.");

126 CHAPTER 3. CONTROL 112 while (true) { System.out.print("? "); str = TextIO.getln(); if (str.equals("")) { break; // Exit the loop, since the input line was blank. } try { number = Double.parseDouble(str); // If an error occurs, the next 2 lines are skipped! total = total + number; count = count + 1; } catch (NumberFormatException e) { System.out.println("Not a legal number! Try again."); } } avg = total/count; System.out.printf("The average of %d numbers is %1.6g%n", count, avg); } } 3.7.3 Exceptions in TextIO TextIO When r’s response is reads a numeric value from the user, it makes sure that the use while try..catch in the previous example. loop and legal, using a technique similar to the Subsection 2.4.4 .) TextIO However, can read data from other sources besides the user. (See When it is reading from a file, there is no reasonable way for TextIO to recover from an illegal value in the input, so it responds by throwing an exception. T o keep things simple, TextIO only throws exceptions of type IllegalArgumentException , no matter what type of error it encounters. For example, an exception will occur if an attempt is made to r ead from a file after all the data TextIO IllegalArgumentException . If in the file has already been read. In , the exception is of type you have a better response to file errors than to let the progra m crash, you can use a try..catch IllegalArgumentException . to catch exceptions of type rogram. In this case, we will As an example, we will look at yet another number-averaging p read the numbers from a file. Assume that the file contains noth ing but real numbers, and we want a program that will read the numbers and find their sum and their average. Since it is unknown how many numbers are in the file, there is the question of when to stop reading. One approach is simply to try to keep reading indefinitely. When t he end of the file is reached, an exception occurs. This exception is not really an error—it’ s just a way of detecting the end of the data, so we can catch the exception and finish up the progra m. We can read the data in a while (true) loop and break out of the loop when an exception occurs. This i s an example of the somewhat unusual technique of using an exception as part of the expected flow of control in a program. To read from the file, we need to know the file’s name. To make the program more general, we can let the user enter the file name, instead of hard-coding a fixed file name in the program. However, it is possible that the user will enter the name of a fi le that does not exist. When we use TextIO.readfile to open a file that does not exist, an exception of type IllegalArgu- mentException occurs. We can catch this exception and ask the user to enter a different file name. Here is a complete program that uses all these ideas:

127 CHAPTER 3. CONTROL 113 /** * This program reads numbers from a file. It computes the sum a nd * the average of the numbers that it reads. The file should con tain * nothing but numbers of type double; if this is not the case, t he * output will be the sum and average of however many numbers we re * successfully read from the file. The name of the file will be * input by the user. */ public class AverageNumbersFromFile { public static void main(String[] args) { while (true) { String fileName; // The name of the file, to be input by the use r. System.out.print("Enter the name of the file: "); fileName = TextIO.getln(); try { t. TextIO.readFile( fileName ); // Try to open the file for inpu break; // If that succeeds, break out of the loop. } catch ( IllegalArgumentException e ) { e + "\"."); System.out.println("Can’t read from the file \"" + fileNam System.out.println("Please try again.\n"); } } /* At this point, TextIO is reading from the file. */ double number; // A number read from the data file. double sum; // The sum of all the numbers read so far. int count; // The number of numbers that were read. sum = 0; count = 0; try { while (true) { // Loop ends when an exception occurs. number = TextIO.getDouble(); count++; // This is skipped when the exception occurs sum += number; } } catch ( IllegalArgumentException e ) { // We expect this to occur when the end-of-file is encountere d. // We don’t consider this to be an error, so there is nothing to do // in this catch clause. Just proceed with the rest of the prog ram. } // At this point, we’ve read the entire file. System.out.println(); System.out.println("Number of data values read: " + count) ; System.out.println("The sum of the data values: " + sum); if ( count == 0 ) System.out.println("Can’t compute an average of 0 values. "); else System.out.println("The average of the values: " + (sum/co unt));

128 CHAPTER 3. CONTROL 114 } } 3.8 Introduction to Arrays we have already covered all of Java’s control struc- I n previous sections of this chapter, reliminary looks at two additional tures. But before moving on to the next chapter, we will take p topics that are at least somewhat related to control structu res. This section is an introduction to arrays. Arrays are a basic and very commonly used data structure, and array processing is often an exercise in using control structures. The next to apply what you know about section will introduce computer graphics and will allow you control structures in another context. 3.8.1 Creating and Using Arrays A data structure consists of a number of data items chunked together so that th ey can be array is a data structure in which the items are arranged as a number ed treated as a unit. An ts position number. In Java— sequence, so that each individual item can be referred to by i of the same type, and the but not in other programming languages—all the items must be al new terms to talk about arrays: numbering always starts at zero. You will need to learn sever The number of items in an array is called the length of the array. The type of the individual items in an array is called the base type of the array. And the position number of an item in index an array is called the of that item. Suppose that you want to write a program that will process the names of, say, one thousand ou knew about arrays, you might people. You will need a way to deal with all that data. Before y have thought that the program would need a thousand variable s to hold the thousand names, and if you wanted to print out all the names, you would need a th ousand print statements. Clearly, that would be ridiculous! In reality, you can put al l the names into an array. The array is a represented by a single variable, but it holds the entire list of names. The length of the array would be 1000, since there are 1000 individual names. T he base type of the array would String e at index 0 in the be since the items in the array are strings. The first name would b array, the second name at index 1, and so on, up to the thousand th name at index 999. The base type of an array can be any Java type, but for now, we wi ll stick to arrays whose String or one of the eight primitive types. If the base type of an arra y is base type is , it int is referred to as an “array of ints .” An array with base type String is referred to as an “array of Strings .” However, an array is not, properly speaking, a list of inte gers or strings or other values . It is better thought of as a list of variables of type int , or a list of variables of type String confusion between the two , or of some other type. As always, there is some potential for uses of a variable: as a name for a memory location and as a name for the value stored in that memory location. Each position in an array acts as a variable . Each position can hold a value of a specified type (the base type of the array), just as a varia ble can hold a value. The value can be changed at any time, just as the value of a variable can b e changed. The items in an array—really, the individual variables that make up the arr ay—are more often referred to as the elements of the array. As I mentioned above, when you use an array in a program, you ca n use a variable to refer to array as a whole. But you often need to refer to the individu al elements of the array. The

129 CHAPTER 3. CONTROL 115 y and the index number of name for an element of an array is based on the name for the arra namelist[7] . the element. The syntax for referring to an element looks, fo r example, like this: is the variable that names the array as a whole, and namelist[7] Here, namelist refers to ment of an array, you use the the element at index 7 in that array. That is, to refer to an ele array name, followed by element index enclosed in square bra ckets. An element name of this form can be used like any other variable: You can assign a valu e to it, print it out, use it in an expression. ngth. For example, you can refer An array also contains a kind of variable representing its le as namelist.length . However, you cannot assign a value to the length of the array namelist , since the length of an array cannot be changed. to namelist.length Before you can use a variable to refer to an array, that variab le must be declared, and it Strings must have a type. For an array of , for example, the type for the array variable would be , and for an array of ints , it would be int[ ] . In general, an array type consists of the String[ ] ets. Array types can be used to base type of the array followed by a pair of empty square brack declare variables; for example, String[] namelist; int[] A; double[] prices; and variables declared in this way can refer to arrays. Howev er, declaring a variable does not has to be assigned a value before make the actual array. Like all variables, an array variable to be created using a special it can be used. In this case, the value is an array. Arrays have are actually objects, but that syntax. (The syntax is related to the fact that arrays in Java perator named new doesn’t need to concern us here.) Arrays are created with an o . Here are some examples: namelist = new String[1000]; A = new int[5]; prices = new double[100]; The general syntax is 〈 array-variable 〉 = new 〈 base-type 〉 [ 〈 array-length 〉 ]; The length of the array can be given as either an integer or an i nteger-valued expression. For A = new int[5]; ”, A is an array containing the five example, after the assignment statement “ A[0] , A[1] , A[2] , A[3] , and A[4] . Also, A.length would have the value 5. integer elements It’s useful to have a picture in mind: ve The statement The array contains  A: A = new int[5]; elements, which are (5) A.length: referred to as creates an array 0 A[0]: A[0], A[1], A[2], A[3], A[4] . ve that holds  0 A[1]: elements of type Each element is a variable 0 A[2]: int. of type . The array also int A is a name 0 A[3]: for the whole array. contains A.length , whose 00 A[4]: value cannot be changed. When you create an array of int , each element of the array is automatically initialized to zero. Any array of numbers is filled with zeros when it is creat ed. An array of boolean is filled with the value false . And an array of char is filled with the character that has Unicode code

130 CHAPTER 3. CONTROL 116 String , the initial value is , a special value used for objects number zero. (For an array of null .) Section 5.1 that we won’t encounter officially until 3.8.2 Arrays and For Loops A lot of the real power of arrays comes from the fact that the in dex of an element can be given list is an array by an integer variable or even an integer-valued expression . For example, if is a variable of type int , then you can use list[i] and even list[2*i+1] as variable and i list[i] depends on the value of i . This becomes especially useful names. The meaning of t can be done with a when we want to process all the elements of an array, since tha loop. for list For example, to print out all the items in an array, , we can just write int i; // the array index for (i = 0; i < list.length; i++) { System.out.println( list[i] ); } i is 0, and list[i] refers to list[0] The first time through the loop, . So, it is the value stored in the variable that is printed. The second time through the loop, i is 1, and list[0] list[1] is printed. The loop ends after printing the value of list[4] , the value stored in when i becomes equal to 5 and the continuation condition “ i < list.length ” is no longer true. This is a typical example of using a loop to process an ar ray. A is an array of , and we want to Let’s look at a few more examples. Suppose that double for find the average of all the elements of the array. We can use a loop to add up the numbers, and then divide by the length of the array to get the average: double total; // The sum of the numbers in the array. double average; // The average of the numbers. int i; // The array index. total = 0; for ( i = 0; i < A.length; i++ ) { total = total + A[i]; // Add element number i to the total. } average = total / A.length; // A.length is the number of items Another typical problem is to find the largest number in the ar A . The strategy is to ray go through the array, keeping track of the largest number fou nd so far. We’ll store the largest number found so far in a variable called max . As we look through the array, whenever we find a number larger than the current value of max max to that larger value. , we change the value of max After the whole array has been processed, is the largest item in the array overall. The only question is, what should the original value of max be? One possibility is to start with max equal to A[0] , and then to look through the rest of the array, starting from A[1] , for larger items: double max; // The largest number seen so far. max = A[0]; // At first, the largest number seen is A[0]. int i; for ( i = 1; i < A.length; i++ ) { if (A[i] > max) { max = A[i]; } } // at this point, max is the largest item in A

131 CHAPTER 3. CONTROL 117 y. In that case, you can use Sometimes, you only want to process some elements of the arra statement inside the for loop to decide whether or not to process a given element. Let’ s an if this time, suppose that we only look at the problem of averaging the elements of an array, but want to average the non-zero elements. In this case, the numb er of items that we add up can be less than the length of the array, so we will need to keep a co unt of the number of items added to the sum: double total; // The sum of the non-zero numbers in the array. int count; // The number of non-zero numbers. double average; // The average of the non-zero numbers. int i; total = 0; count = 0; for ( i = 0; i < A.length; i++ ) { if ( A[i] != 0 ) { total = total + A[i]; // Add element to the total count = count + 1; // and count it. } } if (count == 0) { System.out.println("There were no non-zero elements."); } else { average = total / count; // Divide by number of items System.out.printf("Average of %d elements is %1.5g%n", count, average); } 3.8.3 Random Access So far, my examples of array processing have used sequential access . That is, the elements of the array were processed one after the other in the sequence i n which they occur in the array. random access But one of the big advantages of arrays is that they allow . That is, every element of the array is equally accessible at any given time. As an example, let’s look at a well-known problem called the b irthday problem: Suppose N people in a room. What’s the chance that there are two people i that there are n the room who have the same birthday? (That is, they were born on the sam e day in the same month, but not necessarily in the same year.) Most people severely u nderestimate the probability. We will actually look at a different version of the question: Sup pose you choose people at random and check their birthdays. How many people will you check bef ore you find one who has the same birthday as someone you’ve already checked? Of course, the answer in a particular case depends on random factors, but we can simulate the experimen t with a computer program and run the program several times to get an idea of how many people need to be checked on average. To simulate the experiment, we need to keep track of each birt hday that we find. There are 365 different possible birthdays. (We’ll ignore leap years. ) For each possible birthday, we need to keep track of whether or not we have already found a person w ho has that birthday. The answer to this question is a boolean value, true or false. To h old the data for all 365 possible birthdays, we can use an array of 365 boolean values: boolean[] used; used = new boolean[365];

132 CHAPTER 3. CONTROL 118 4. The value of used[i] For this problem, the days of the year are numbered from 0 to 36 is i r . Initially, all the values in the true if someone has been selected whose birthday is day numbe array are false. (Remember that this is done automatically w hen the array is created.) When we select someone whose birthday is day number used[i] is true . i , we first check whether true If it is e. On the other , then this is the second person with that birthday. We are don hand, if is false , we set used[i] to be true used[i] to record the fact that we’ve encountered someone with that birthday, and we go on to the next person. He re is a program that carries out the simulated experiment (of course, in the program, the re are no simulated people, only simulated birthdays): /** * Simulate choosing people at random and checking the day of t he year they * were born on. If the birthday is the same as one that was seen p reviously, * stop, and output the number of people who were checked. */ public class BirthdayProblem { public static void main(String[] args) { boolean[] used; // For recording the possible birthdays // that have been seen so far. A value // of true in used[i] means that a person // whose birthday is the i-th day of the // year has been found. int count; // The number of people who have been checked. used = new boolean[365]; // Initially, all entries are false . count = 0; while (true) { // Select a birthday at random, from 0 to 364. // If the birthday has already been used, quit. // Otherwise, record the birthday as used. int birthday; // The selected birthday. birthday = (int)(Math.random()*365); count++; System.out.printf("Person %d has birthday number %d", cou nt, birthday); System.out.println(); if ( used[birthday] ) { // This day was found before; it’s a duplicate. We are done. break; } used[birthday] = true; } // end while System.out.println(); System.out.println("A duplicate birthday was found after " + count + " tries."); } } // end class BirthdayProblem

133 CHAPTER 3. CONTROL 119 w it uses the array. Also, try You should study the program to understand how it works and ho it out! You will probably find that a duplicate birthday tends to occur sooner than you expect. 3.8.4 Partially Full Arrays t to store in an array changes Consider an application where the number of items that we wan ed, a separate counter variable as the program runs. Since the size of the array can’t be chang must be used to keep track of how many spaces in the array are in use. (Of course, every space in the array has to contain something; the question is, how ma ny spaces contain useful or valid items?) Consider, for example, a program that reads positive intege rs entered by the user and stores e user inputs a number that is them for later processing. The program stops reading when th rray, less than or equal to zero. The input numbers can be kept in an a , of type int[ ] . numbers size of the array can be fixed Let’s say that no more than 100 numbers will be input. Then the at 100. But the program must keep track of how many numbers hav e actually been read and stored in the array. For this, it can use an integer variable. Each time a number is stored in the array, we have to count it; that is, value of the counter va riable must be incremented by one. One question is, when we add a new item to the array, where do we put it? Well, if the number of items is count , then they would be stored in the array in positions number 0, 1, . . . , (count-1). The next open spot would be position number count , so that’s where we should put the new item. As a rather silly example, let’s write a program that will rea d the numbers input by the user and then print them in the reverse of the order in which th ey were entered. Assume that , at least, a processing task an input value equal to zero marks the end of the data. (This is that requires that the numbers be saved in an array. Note that many types of processing, such as finding the sum or average or maximum of the numbers, can be d one without saving the individual numbers.) public class ReverseInputNumbers { public static void main(String[] args) { int[] numbers; // An array for storing the input values. int count; // The number of numbers saved in the array. int num; // One of the numbers input by the user. int i; // for-loop variable. numbers = new int[100]; // Space for 100 ints. count = 0; // No numbers have been saved yet. System.out.println("Enter up to 100 positive integers; en ter 0 to end."); while (true) { // Get the numbers and put them in the array. System.out.print("? "); num = TextIO.getlnInt(); if (num <= 0) { // Zero marks the end of input; we have all the numbers. break; } numbers[count] = num; // Put num in position count. count++; // Count the number }

134 CHAPTER 3. CONTROL 120 \n"); System.out.println("\nYour numbers in reverse order are: for ( i = count - 1; i >= 0; i-- ) { System.out.println( numbers[i] ); } } // end main(); } // end class ReverseInputNumbers plays a dual role. It is the number It is especially important to note how the variable count of items that have been entered into the array. But it is also t he index of the next available spot in the array. When the time comes to print out the numbers in the array, the l ast occupied spot in the array is location for loop prints out values starting from location count - 1 count - 1 , so the he elements of an array in reverse and going down to 0. This is also a nice example of processing t order. ∗ ∗ ∗ You might wonder what would happen in this program if the user tries to input more than 100 numbers. The result would be an error that would crash the program. When the user enters the 101-st number, the program tries to store that number in a number[100] . n array element ems in the array, and the However, there is no such array element. There are only 100 it number[100] generates an exception of type index of the last item is 99. The attempt to use ArrayIndexOutOfBoundsException . Exceptions of this type are a common source of run-time errors in programs that use arrays. 3.8.5 Two-dimensional Arrays al.” This means that the array The arrays that we have considered so far are “one-dimension consists of a sequence of elements that can be thought of as be ing laid out along a line. It two-dimensional arrays , where the elements can be laid out in a is also possible to have Section 7.5 . rectangular grid. We consider them only briefly here, but wil l return to the topic in In a two-dimensional, or “2D,” array, the elements can be arr anged in rows and columns. Here, for example, is a 2D array of int that has five rows and seven columns: 6 0 1 2 3 4 5 13 92 33 13 7 54 -1 0 -5 67 18 42 0 8 0 -3 1 44 22 72 78 -5 90 79 2 -12 17 1 100 43 -6 12 3 58 58 87 2 36 0 21 4 This 5-by-7 grid contains a total of 35 elements. The rows in a 2D array are numbered 0, 1, 2, . . . , up to the number of rows minus one. Similarly, the column s are numbered from zero up to the number of columns minus one. Each individual element i n the array can be picked out by specifying its row number and its column number. (The illu stration shown here is not what the array actually looks like in the computer’s memory, but i t does show the logical structure of the array.) In Java, the syntax for two-dimensional arrays is similar to the syntax for one-dimensional arrays, except that an extra index is involved, since pickin g out an element requires both a row

135 CHAPTER 3. CONTROL 121 A is a 2D array of , then A[3][2] would be number and a column number. For example, if int 7 in the array shown above. the element in row 3, column 2. That would pick out the number 1 The type for int[ ][ ] , with two pairs of empty brackets. To declare the array would be given as A variable and create the array, you could say, int[][] A; A = new int[5][7]; The second line creates a 2D array with 5 rows and 7 columns. Tw o-dimensional arrays are for loops. For example, the following code segment will print ou t often processed using nested A the elements of in neat columns: and columns in A int row, col; // loop-control-variables for accessing rows for ( row = 0; row < 5; row++ ) { for ( col = 0; col < 7; col++ ) { System.out.printf( "%7d", A[row][col] ); } System.out.println(); } ys of type The base type of a 2D array can be anything, so you can have arra , double[ ][ ] String[ ][ ] , and so on. There are some natural uses for 2D arrays. For example, a 2D ar ray can be used to store the contents of the board in a game such as chess or checkers. And a n example in Subsection 4.6.3 uses a 2D array to hold the colors of a grid of colored squares. But sometimes two-dimensional y obvious. Consider a company arrays are used in problems in which the grid is not so visuall he profit earned at each store that owns 25 stores. Suppose that the company has data about t for each month in the year 2014. If the stores are numbered fro m 0 to 24, and if the twelve months from January 2014 through December 2014 are numbered from 0 to 11, then the profit profit data could be stored in an array, , created as follows: double[][] profit; profit = new double[25][12]; profit[3][2] would be the amount of profit earned at store number 3 in March, and more generally, profit[storeNum][monthNum] would be the amount of profit earned in store number storeNum in month number monthNum (where the numbering, remember, starts from zero). Let’s assume that the array has already been filled with data. This data can be profit processed in a lot of interesting ways. For example, the tota l profit for the company—for the whole year from all its stores—can be calculated by adding up all the entries in the array: double totalProfit; // Company’s total profit in 2014. int store, month; // variables for looping through the store s and the months totalProfit = 0; for ( store = 0; store < 25; store++ ) { for ( month = 0; month < 12; month++ ) totalProfit += profit[store][month]; } Sometimes it is necessary to process a single row or a single c olumn of an array, not the entire array. For example, to compute the total profit earned by the company in December, that is, in month number 11, you could use the loop:

136 CHAPTER 3. CONTROL 122 double decemberProfit; int storeNum; decemberProfit = 0.0; for ( storeNum = 0; storeNum < 25; storeNum++ ) { decemberProfit += profit[storeNum][11]; } uch less common than one- Two-dimensional arrays are sometimes useful, but they are m dimensional arrays. Java actually allows arrays of even hig her dimension, but they are only rarely encountered in practice. 3.9 Introduction to GUI Programming or the past two chapters , you’ve been learning the sort of programming that is done F inside a single subroutine, “programming in the small.” In t he rest of this book, we’ll be more he material that you’ve already concerned with the larger scale structure of programs, but t me. In this section, we see how learned will be an important foundation for everything to co ontext of graphical programming. techniques that you have learned so far can be applied in the c computer screen. As When you run a GUI program, it opens one or more windows on your a programmer, you can have complete control over what appear s in the window and how the user can interact with it. For our first encounter, we look at o ne simple example: the ability of a program to display simple shapes like rectangles and lin es in the window, with no user interaction. For now, the main point is to take a look at how pr ogramming-in-the-small can be used in other contexts besides text-based, command-line-s tyle programs. You will see that a knowledge of programming-in-the-small applies to writing the guts of any subroutine, not just main() . 3.9.1 Drawing Shapes To understand computer graphics, you need to know a little ab out pixels and coordinate sys- pixels tems. The computer screen is made up of small squares called , arranged in rows and columns, usually about 100 pixels per inch. The computer con trols the color of the pixels, and drawing is done by changing the colors of individual pixels. Each pixel has a pair of integer coordinates, often called and y , that specify the pixel’s horizontal and vertical position . For x a graphics context drawing to a rectangular area on the scree n, the coordinates of the pixel in the upper left corner of the rectangle are (0,0). The x coordinate increases from the left to right, and the coordinate increases from top to bottom. Shapes are specifie d using pixels. For y example, a rectangle is specified by the x and y coordinates of its upper left corner and by its width and height measured in pixels. Here’s a picture of a rec tangular drawing area, showing the ranges of x and y coordinates. The “width” and “height” in this picture give t he size of the drawing area, in pixels:

137 CHAPTER 3. CONTROL 123 width 0 x 0 y Hello World height tangle in the upper left of the Assuming that the drawing area is 800-by-500 pixels, the rec picture would have, approximately, width 200, height 150, a nd upper left corner at coordinates (50,50). ∗ ∗ ∗ graphics context . A graphics context is an object. As Drawing in Java is done using a an object, it can include subroutines and data. Among the sub routines in a graphics context les, ovals, and text. (When text are routines for drawing basic shapes such as lines, rectang appears on the screen, the characters have to be drawn there b y the computer, just like the computer draws any other shapes.) Among the data in a graphic s context are the color and font that are currently selected for drawing. (A font determines the style and size of characters.) One other piece of data in a graphics context is the “drawing s urface” on which the drawing computer screen, although it can is done. Generally, the drawing surface is a rectangle on the ics context objects can draw to be other surfaces such as a page to be printed. Different graph be the content area of a window, different drawing surfaces. For us, the drawing surface will not including its border or title bar. Graphics (just A graphics context is represented by a variable. The type for the variable is like the type for a string variable is ). The variable is often named g , but the name of the String e subroutines that are available variable is of course up to the programmer. Here are a few of th g in a graphics context : g.setColor(c) , is called to set the color to be used for drawing. The paramet er, • is an c object belonging to a class named Color . There are about a dozen constants representing standard colors that can be used as the parameter in this subr outine. The standard colors include Color.BLACK Color.WHITE , Color.LIGHT , , , Color.GREEN , and GRAY Color.RED . (Later, we will see that it is also possible to create new col ors.) For example, Color.BLUE g.setColor(Color.RED); ”. The specified if you want to draw in red, you would say “ the next time g.setColor() color is used for all subsequent drawing operations up until is called. g.drawLine(x1,y1,x2,y2) draws a line from the point with coordinates (x1,y1) to the • point with coordinates (x2,y2) . • g.drawRect(x,y,w,h) l sides. draws the outline of a rectangle with vertical and horizonta x , The parameters , w , and h must be integers or integer-valued expressions. This sub- y routine draws the outline of the rectangle whose top-left co rner is x pixels from the left edge of the drawing area and pixels down from the top. The width of the rectangle is w y pixels, and the height is h pixels. The color that is used is black, unless a different col or has been set by calling g.setColor() .

138 CHAPTER 3. CONTROL 124 g.fillRect(x,y,w,h) is similar to except that it fills in the inside of the • g.drawRect() rectangle instead of drawing an outline. g.drawOval(x,y,w,h) angle • draws the outline of an oval. The oval just fits inside the rect that would be drawn by g.drawRect(x,y,w,h) . To get a circle, use the same values for h w and for . g.fillOval(x,y,w,h) is similar to g.drawOval() except that it fills in the inside of the • oval instead of drawing an outline. This is enough information to draw some pictures using Java g raphics. To start with something simple, let’s say that we want to draw a set of ten pa rallel lines, something like this: nce from each line to the next Let’s say that the lines are 200 pixels long and that the dista el with coordinates (100,50). To is 10 pixels, and let’s put the start of the first line at the pix draw one line, we just have to call g.drawLine(x1,y1,x2,y2) with appropriate values for the x -coordinate 100, so we can use the constant 100 as parameters. Now, all the lines start at the value for . Since the lines are 200 pixels long, we can use the constant 3 00 as the value x1 for x2 . The y -coordinates of the lines are different, but we can see that bo th endpoints of a line have the same y -coordinates, so we can use a single variable as the value for y1 and for y2 . Using as the name of that variable, the command for drawing one of th e lines becomes y . The value of is 50 for the top line and increases by 10 each time g.drawLine(100,y,300,y) y that y takes on the correct we move down from one line to the next. We just need to make sure sequence of values. We can use a for loop that counts from 1 to 1 0: int y; // y-coordinate for the line int i; // loop control variable y = 50; // y starts at 50 for the first line for ( i = 1; i <= 10; i++ ) { g.drawLine( 100, y, 300, y ); y = y + 10; // increase y by 10 before drawing the next line. } Alternatively, we could use y itself as the loop control variable, noting that the value of y for the last line is 140: int y; for ( y = 50; y <= 140; y = y + 10 ) g.drawLine( 100, y, 300, y ); If we wanted to set the color of the lines, we could do that by ca lling g.setColor() before drawing them. If we just draw the lines without setting the co lor, they will be black. For something a little more complicated, let’s draw a large n umber of randomly colored, randomly positioned, filled circles. Since we only know a few colors, I will randomly select the color to be red, green, or blue. That can be done with a simple s witch statement, similar to the ones in Subsection 3.6.4 :

139 CHAPTER 3. CONTROL 125 switch ( (int)(3*Math.random()) ) { case 0: g.setColor( Color.RED ); break; case 1: g.setColor( Color.GREEN ); break; case 2: g.setColor( Color.BLUE ); break; } I will choose the center points of the circles at random. Let’ s say that the width of the drawing area is given by a variable, width . Then we want a random value in the range 0 to for the horizontal position of the center. Similarly, the ve rtical position of the width-1 center will a random value in the range to height-1 . That leaves the size of the circle to be 0 ixels. We can draw the circle with determined; I will make the radius of each circle equal to 50 p g.fillOval(x,y,w,h) . However, in this command, x and y are not a statement of the form the coordinates of the center of the circle; they are the uppe r left corner of a rectangle drawn around the circle. To get values for x y , we have to move back from the center of the circle and arameters give the and h by 50 pixels, an amount equal to the radius of the circle. The p w width and height of the rectangle, which has to be twice the ra dius, or 100 pixels in this case. Taking all this into account, here is a code segment for drawi ng a random circle: centerX = (int)(width*Math.random()); centerY = (int)(height*Math.random()); g.fillOval( centerX - 50, centerY - 50, 100, 100 ); This code comes after the color-setting code given above. In the end, I found that the picture looks better if I also draw a black outline around each filled c ircle, so I added this code at the end: g.setColor( Color.BLACK ); g.drawOval( centerX - 50, centerY - 50, 100, 100 ); Finally, to get a large number of circles, I put all of the abov e code into a for loop that runs for 500 executions. Here’s a typical drawing from the progra m, shown at reduced size: 3.9.2 Drawing in a Program Now, as you know, you can’t just have a bunch of Java code stand ing by itself. The code has to be inside a subroutine definition that is itself inside a class definition. In fact, for my circle-drawing program, the complete subroutine for drawi ng the picture looks like this:

140 CHAPTER 3. CONTROL 126 th, int height) { public void drawFrame(Graphics g, int frameNumber, int wid int centerX; // The x-coord of the center of a disk. int centerY; // The y-coord of the center of a disk. int colorChoice; // Used to select a random color. int count; // Loop control variable for counting disks. for (count = 0; count < 500; count++) { colorChoice = (int)(3*Math.random()); switch (colorChoice) { case 0: g.setColor(Color.RED); break; case 1: g.setColor(Color.GREEN); break; case 2: g.setColor(Color.BLUE); break; } centerX = (int)(width*Math.random()); centerY = (int)(height*Math.random()); g.fillOval( centerX - 50, centerY - 50, 100, 100 ); g.setColor(Color.BLACK); g.drawOval( centerX - 50, centerY - 50, 100, 100 ); } } er than main() , but you will This is the first subroutine definition that you have seen, oth learn all about defining subroutines in the next chapter. The first line of the definition makes e graphics context available certain values that are used in the subroutine: th and the width g and height of the drawing area. (Ignore frameNumber for now.) These values come from outside the subroutine, but the subroutine can use them. The point he re is that to draw something, you just have to fill in the inside of the subroutine, just as yo u write a program by filling in the main() . inside of The subroutine definition still has to go inside a class that d efines the program. In this case, the class is named RandomCircles , and the complete program is available in the sample source . You can run that program to see the drawing. code file There’s a lot in the program that you won’t understand. To mak e your own drawing, all you have to do is erase the inside of the drawFrame() routine in the source code and substitute your own drawing code. You don’t need to understa nd the rest. The source code file can be used as a basis for your own first graphics explorations . It’s essentially the same as but with the drawing code omitted. You’ll need it to do some of the exercises for this chapter. (By the way, you might notice that the main() subroutine uses the word static in its definition, but drawFrame() does not. This has to do with the fact that the drawing area in this program is an object, and drawFrame is a subroutine in that object. The difference between static and non-static subroutines is important but not some thing that we need to worry about for the time being. It will become important for us in Chapter 5 .)

141 CHAPTER 3. CONTROL 127 3.9.3 Animation The name “SimpleAnimationStarter” should give you a clue th at we are looking at the possi- bility of more than just individual drawings here. A compute r animation is simply a sequence of individual pictures, displayed quickly one after the oth er. If the change from each picture to the next is small, the user will perceive the sequence of im ages as a continuous animation. . Each picture in the animation is called a frame is configured d. (In , to draw fifty frames every second, although that can be change it has been changed to one frame every three seconds, so that t he program actually draws a new set of random circles every three seconds.) The frames in the animation are numbered 0, 1, 2, 3, . . . , and the value of in the drawFrame() subroutine tells you which frameNumber s to base what you draw on frame you are drawing. The key to programming the animation i frameNumber . the ectangles. The rectangles As an example of animation, we look at drawing a set of nested r sion of infinite motion. Here’s one will shrink towards the center of the drawing, giving an illu frame from the animation: Consider how to draw a picture like this one. The rectangles c an be drawn with a while loop, which draws the rectangles starting from the one on the outside and moving in. Think about what variables will be needed and how they change from o ne iteration of the while loop to awn is smaller than the previous the next. Each time through the loop, the rectangle that is dr rectangles is in their size one and is moved down and over a bit. The difference between two and in the coordinates of the upper left corner. We need a vari able to represent the size . The x and y-coordinates are the same, and they can be represented by the same variable. I call that variable inset , since it is the amount by which the edges of the rectangle are inset from the edges of the drawing area. The size decreases from one rectangle to the next, while the inset increases. The while loop ends when size becomes less than or equal to zero. In general outline, the algorithm for drawing one frame is routine) Set the drawing color to light gray (using the g.setColor sub Fill in the entire picture (using the g.fillRect subroutine ) Set the drawing color to black Set the amount of inset for the first rectangle Set the rectangle width and height for the first rectangle while the width and height are both greater than zero: draw a rectangle (using the g.drawRect subroutine) increase the inset (to move the next rectangle over and down) decrease width the height (the make the next rectangle small er) In my program, each rectangle is 15 pixels away from the recta ngle that surrounds it, so the inset is increased by 15 each time through the while loop. The rectangle shrinks by 15 pixels

142 CHAPTER 3. CONTROL 128 and by 15 pixels on the right, so the width of the rectangle shrink 30 before on the left s by els each time through the loop. drawing the next rectangle. The height also shrinks by 30 pix The pseudocode is then easy to translate into Java, except th at we need to know what rst rectangle. To figure that out, initial values to use for the inset, width, and height of the fi we have to think about the fact that the picture is animated, s o that what we draw will depend in some way on the frame number. From one frame to the next fram e of the animation, the hat is, the top-left corner of the outer rectangle moves over and down; t for the outer inset rectangle increases from one frame to the next. We can make th is happen by setting the inset on. But that can’t go on for frame number 0 to 0, the inset for frame number 1 to 1, and so In fact, when the animation gets to forever, or eventually all the rectangles would disappear. rawing area—but it’s not really frame 15, a new rectangle should appear at the outside of the d a “new rectangle,” it’s just that the for the outer rectangle goes back to zero. So, as the inset animation proceeds, the inset should go through the sequenc e of values 0, 1, 2, . . . , 14 over and over. We can accomplish that very easily by setting inset = frameNumber % 15; Finally, note that the first rectangle fills the drawing area e xcept for a border of size inset idth of the rectangle is the width around the outside of the rectangle. This means that the the w or the height. Here, then is the of the drawing area minus two times the inset, and similarly f drawFrame() subroutine for the moving rectangle example: th, int height) { public void drawFrame(Graphics g, int frameNumber, int wid ectangle. int inset; // Gap between edges of drawing area and the outer r int rectWidth, rectHeight; // The size of one of the rectangl es. g.setColor(Color.LIGHT GRAY); g.fillRect(0,0,width,height); // Fill drawing area with l ight gray. g.setColor(Color.BLACK); // Draw the rectangles in black. inset = frameNumber % 15; // inset for the outer rectangle rectWidth = width - 2*inset; // drawing area width minus two i nsets rectHeight = height - 2*inset; // drawing area height minus t wo insets while (rectWidth >= 0 && rectHeight >= 0) { g.drawRect(inset, inset, rectWidth, rectHeight); inset += 15; // rectangles are 15 pixels apart rectWidth -= 30; rectHeight -= 30; } } . You can find the full source code for the program is in the sampl e program

143 Exercises 129 Exercises for Chapter 3 (solution) 1. How many times do you have to roll a pair of dice before they com e up snake eyes? You mputer program that could do the experiment by rolling the dice by hand. Write a co simulates the experiment. The program should report the num ber of rolls that it makes before the dice come up snake eyes. (Note: “Snake eyes” means that both dice show a value of 1.) Exercise 2.2 explained how to simulate rolling a pair of dice. Which integer between 1 and 10000 has the largest number of di (solution) 2. visors, and how many divisors does it have? Write a program to find the answers and p rint out the results. It is possible that several integers in this range have the same, m aximum number of divisors. Subsection 3.4.2 discussed Your program only has to print out one of them. An example in divisors. The source code for that example is . basic idea is You might need some hints about how to find a maximum value. The to go through all the integers, keeping track of the largest n umber of divisors that you’ve so far . Also, keep track of the integer that had that number of divis ors. seen Write a program that will evaluate simple expressions such a s 17 + 3 and 3.14159 * 4.7. 3. (solution) The expressions are to be typed in by the user. The input alway s consists of a number, followed by an operator, followed by another number. The ope rators that are allowed are +, -, *, and /. You can read the numbers with TextIO.getDouble() and the operator with TextIO.getChar() ad . Your program should read an expression, print its value, re hould end when the user another expression, print its value, and so on. The program s enters 0 as the first number on the line. 4. Write a program that reads one line of input text and breaks it up into words. The (solution) uence of letters. Any words should be output one per line. A word is defined to be a seq characters in the input that are not letters should be discar ded. For example, if the user inputs the line He said, "That’s not a good idea." then the output of the program should be He said That s not a good idea An improved version of the program would list “that’s” as a si ngle word. An apostrophe can be considered to be part of a word if there is a letter on eac h side of the apostrophe. To test whether a character is a letter, you might use (ch >= ’a’ && ch <= ’z’) || (ch >= ’A’ && ch <= ’Z’) . However, this only works in English and similar languages. A better choice is to call the standard function Character.isLetter(ch) , which returns a boolean value of true if ch is a letter and false if it is not. This works for any Unicode character.

144 Exercises 130 (solution) Suppose that a file contains information about sales figures f 5. or a company in various cities. :) followed by the data for Each line of the file contains a city name, followed by a colon ( that city. The data is a number of type However, for some cities, no data was double. available. In these lines, the data is replaced by a comment e xplaining why the data is missing. For example, several lines from the file might look l ike: San Francisco: 19887.32 Chicago: no report received New York: 298734.12 om all the cities together. Write a program that will compute and print the total sales fr The program should also report the number of cities for which data was not available. The name of the file is “sales.dat”. To complete this program, you’ll need one fact about file inpu t with TextIO that was not covered in . Since you don’t know in advance how many lines there Subsection 2.4.4 end of the file. When are in the file, you need a way to tell when you have gotten to the is reading from a file, the function TextIO.eof() can be used to test for end of TextIO . This boolean -valued function returns true file if the file has been entirely read and returns if there is more data to read in the file. This means that you can read the false lines of the file in a loop . The loop will end when while (TextIO.eof() == false)... all the lines of the file have been read. Suggestion: For each line, read and ignore characters up to t he colon. Then read the rest of the line into a variable of type String . Try to convert the string into a number, and use try..catch to test whether the conversion succeeds. (solution) Exercise 3.2 asked you to find the number in the range 1 to 10000 6. that has the largest number of divisors. You only had to print out one such number. Revise the program so that it will print out all numbers that have the maximum number of divisors. Use an arra y ach count in an array. Then as follows: As you count the divisors for each number, store e t out all the numbers at the end of the program, you can go through the array and prin that have the maximum count. The output from the program shou ld look something like this: Among integers between 1 and 10000, The maximum number of divisors was 64 Numbers with that many divisors include: 7560 9240 7. An example in Subsection 3.8.3 tried to answer the question, How many random people do (solution) urce code for that program you have to select before you find a duplicate birthday? The so can be found in the file . Here are some related questions: • How many random people do you have to select before you find three people who share the same birthday? (That is, all three people were born on the same day in the same month, but not necessarily in the same year.) • Suppose you choose 365 people at random. How many different bi rthdays will they have? (The number could theoretically be anywhere from 1 to 3 65). • How many different people do you have to check before you’ve fo und at least one person with a birthday on each of the 365 days of the year?

145 Exercises 131 three programs to answer these questions. Each of your programs sh Write ould sim- s. (In each case, ignore the ulate choosing people at random and checking their birthday possibility of leap years.) (solution) 8. Write a GUI program that draws a checkerboard. Base your solu tion on the sample program , even though you are creating only a static picture he drawFrame() subroutine. rather than an animation. You will draw the checkerboard in t ges that you might need You should read the comments in the file to discover other chan to make. Assume that the size of the drawing area is 400-by-400 pixels . A checkerboard contains 8 rows and 8 columns of squares. If the size of the drawing area is 400, that means that each square can be 50-by-50 pixels. The squares are red and bl ack (or whatever other colors you choose). Here is a tricky way to determine whether a given square should be red or black: The rows and columns can be thought of as numbere d from 0 to 7. If the row number of the square and the column number of the square are ei ther both even or both odd, then the square is red. Otherwise, it is black. Note that a square is just a rectangle in which the height is equal to the width, so you can use the sub routine g.fillRect() to draw the squares. Here is a reduced-size image of the check erboard that you want to draw: 9. ery so many frames. Some- (solution) Often, some element of an animation repeats over and over, ev times, the repetition is “cyclic,” meaning that at the end it jumps back to the start. Sometimes the repetition is “oscillating,” like a back-and -forth motion where the second half is the same as the first half played in reverse. Write an animation that demonstrates both cyclic and oscill ating motions at various speeds. For cyclic motion, you can use a square that moves acr oss the drawing area, then jumps back to the start, and then repeats the same motion over and over. For oscillating motion, you can do something similar, but the square should m ove back and forth between the two edges of the drawing area; that is, it moves left-to-r ight during the first half of the animation and then backwards from right-to-left during the second half. To write the program, you can start with a copy of the sample program , as in the previous exercise. A cyclic motion has to repeat every N frames for some value of N . What you draw in some frame of the animation depends on the frameNumber . The frameNumber just keeps

146 Exercises 132 ally want is a “cyclic frame increasing forever. To implement cyclic motion, what you re . , (N-1), 0, 1, 2, . . . . You number” that takes on the values 0, 1, 2, . . . , (N-1), 0, 1, 2, . . can derive the value that you need from frameNumber simply by saying cyclicFrameNumber = frameNumber % N; cyclicFrameNumber instead of on Then, you just have to base what you draw on frameNumber . Similarly, for an oscillating animation, you need an “osci llation frame number” that takes on the values 0, 1, 2, . . . (N-1), N, (N-1), ( N-2), . . . 2, 1, 0, 1, 2, and so on, repeating the back and forth motion forever. You can co mpute the value that you need with oscilationFrameNumber = frameNumber % (2*N); if (oscillationFrameNumber > N) oscillationFrameNumber = (2*N) - oscillationFrameNumber ; Here is a screen shot from my version of the program. I use six s quares. The top three do cyclic motion at various speeds, while the bottom three do oscillating motion. I drew black lines across the drawing area to separate the squares a nd to give them “channels” to move in.

147 Quiz 133 Quiz on Chapter 3 (answers) algorithm ? 1. What is an ful in the development Explain briefly what is meant by “pseudocode” and how is it use 2. of algorithms. block statement? How are block statements used in Java programs? 3. What is a while loop and a do..while loop? 4. What is the main difference between a 5. prime a loop? What does it mean to 6. animation and how a computer displays an animation. Explain what is meant by an Write a t is: 3 6 9 12 loop that will print out all the multiples of 3 from 3 to 36, tha 7. for 15 18 21 24 27 30 33 36. 8. main() routine so that it will ask the user to enter an integer, read Fill in the following the user’s response, and tell the user whether the number ent ered is even or odd. (You can use TextIO.getInt() to read the integer. Recall that an integer n is even if n % 2 == 0 .) public static void main(String[] args) { // Fill in the body of this subroutine! } 9. different random integers selected from the Write a code segment that will print out two range 1 to 10. All possible outputs should have the same proba bility. Hint: You can easily select two random numbers, but you have to account for the fac t that the two numbers that you pick might be the same. Suppose that s1 and s2 are variables of type String , whose values are expected to be 10. string representations of values of type int . Write a code segment that will compute and print the integer sum of those values, or will print an error m essage if the values cannot successfully be converted into integers. (Use a try..catch statement.) 11. Show the exact output that would be produced by the following main() routine: public static void main(String[] args) { int N; N = 1; while (N <= 32) { N = 2 * N; System.out.println(N); } } 12. Show the exact output produced by the following main() routine:

148 Quiz 134 public static void main(String[] args) { int x,y; x = 5; y = 1; while (x > 0) { x = x - 1; y = y * x; System.out.println(y); } } What output is produced by the following program segment? Why? 13. (Recall that name.charAt(i) name .) is the i-th character in the string, String name; int i; boolean startWord; name = "Richard M. Nixon"; startWord = true; for (i = 0; i < name.length(); i++) { if (startWord) System.out.println(name.charAt(i)); if (name.charAt(i) == ’ ’) startWord = true; else startWord = false; } Suppose that numbers 14. int[ ] . Write a code segment that will count and is an array of type output the number of times that the number 42 occurs in the arr ay. 15. Define the range of an array of numbers to be the maximum value in the array minu s the minimum value. Suppose that raceTimes is an array of type double[ ] . Write a code segment that will find and print the range of raceTimes .

149 Chapter 4 Programming in the Large I: Subroutines O subroutines . ne way to break up a complex program into manageable pieces is to use certain task, grouped together and A subroutine consists of the instructions for carrying out a given a name. Elsewhere in the program, that name can be used a s a stand-in for the whole set of instructions. As a computer executes a program, whenever it encounters a subroutine name, it executes all the instructions necessary to carry out the t ask associated with that subroutine. Subroutines can be used over and over, at different places in t he program. A subroutine can even be used inside another subroutine. This allows you t o write simple subroutines and an then be used in turn in other then use them to help write more complex subroutines, which c up step-by-step, where each step subroutines. In this way, very complex programs can be built in the construction is reasonably simple. Subroutines in Java can be either static or non-static. This chapter covers static subroutines. Non-static subroutines, which are used in true object-orie nted programming, will be covered in the next chapter. 4.1 Black Boxes A subroutine consists of instructions for performing some task, chunked together and given a name. “Chunking” allows you to deal with a potentiall y very complicated task as eps that the computer might a single concept. Instead of worrying about the many, many st er the name of the subroutine. have to go though to perform that task, you just need to rememb Whenever you want your program to perform the task, you just c all the subroutine. Subroutines are a major tool for dealing with complexity. can’t see what’s “inside” A subroutine is sometimes said to be a “black box” because you it (or, to be more precise, you usually don’t want to see inside it, because then you would have to deal with all the complexity that the subroutine is me ant to hide). Of course, a black box that has no way of interacting with the rest of the world wo uld be pretty useless. A black box needs some kind of interface with the rest of the world, which allows some interaction between what’s inside the box and what’s outside. A physical black box might have buttons on the outside that you can push, dials that you can set, and sl ots that can be used for passing information back and forth. Since we are trying to hide compl exity, not create it, we have the first rule of black boxes: 135

150 CHAPTER 4. SUBROUTINES 136 The interface of a black box should be fairly straight- forward, well-defined, and easy to understand. Are there any examples of black boxes in the real world? Yes; i n fact, you are surrounded efrigerator. . . . You can turn your by them. Your television, your car, your mobile phone, your r television on and off, change channels, and set the volume by u sing elements of the television’s interface—dials, remote control, don’t forget to plug in th e power—without understanding anything about how the thing actually works. The same goes fo r a mobile phone, although the interface in that case is a lot more complicated. Now, a black box does have an inside—the code in a subroutine t hat actually performs the task, or all the electronics inside your television set. The inside of a black box is called its implementation . The second rule of black boxes is that: To use a black box, you shouldn’t need to know any- thing about its implementation; all you need to know is its interface. In fact, it should be possible to the implementation, as long as the behavior of the change e, when the insides of TV sets box, as seen from the outside, remains unchanged. For exampl of the sets didn’t need to know went from using vacuum tubes to using transistors, the users about it—or even know what it means. Similarly, it should be p ossible to rewrite the inside of affecting the programs that use a subroutine, to use more efficient code, for example, without that subroutine. Of course, to have a black box, someone must have designed and built the implementation in the first place. The black box idea works to the advantage of the implementor as well as the user of the black box. After all, the black box might be use d in an unlimited number of different situations. The implementor of the black box doesn ’t need to know about any of that. The implementor just needs to make sure that the box performs its assigned task and interfaces black boxes: correctly with the rest of the world. This is the third rule of The implementor of a black box should not need to know anything about the larger systems in which the box will be used. In a way, a black box divides the world into two parts: the insi de (implementation) and the outside. The interface is at the boundary, connecting those two parts. ∗ ∗ ∗ not think of an interface as just the physical connection betwee n By the way, you should the box and the rest of the world. The interface also includes a specification of what the box does and how it can be controlled by using the elements of t he physical interface. It’s not enough to say that a TV set has a power switch; you need to speci fy that the power switch is used to turn the TV on and off! To put this in computer science terms, the interface of a subr outine has a semantic as well as a syntactic component. The syntactic part of the interfac e tells you just what you have to type in order to call the subroutine. The semantic compone nt specifies exactly what task the subroutine will accomplish. To write a legal program, yo u need to know the syntactic specification of the subroutine. To understand the purpose o f the subroutine and to use it effectively, you need to know the subroutine’s semantic spec ification. I will refer to both parts of the interface—syntactic and semantic—collectively as t he contract of the subroutine.

151 CHAPTER 4. SUBROUTINES 137 t you have to do to use me, The contract of a subroutine says, essentially, “Here is wha and here is what I will do for you, guaranteed.” When you write a subroutine, the comments ry clear. (I should admit that that you write for the subroutine should make the contract ve in practice, subroutines’ contracts are often inadequatel y specified, much to the regret and annoyance of the programmers who have to use them.) For the rest of this chapter, I turn from general ideas about b lack boxes and subroutines in general to the specifics of writing and using subroutines i n Java. But keep the general ideas and principles in mind. They are the reasons that subroutine s exist in the first place, and they are your guidelines for using them. This should be especiall y clear in Section 4.6 , where I will discuss subroutines as a tool in program development. ∗ ∗ ∗ ple of black boxes in You should keep in mind that subroutines are not the only exam ee that a class can have a programming. For example, a class is also a black box. We’ll s part that is entirely inside its hidden “public” part, representing its interface, and a “private” implementation. All the principles of black boxes apply to c lasses as well as to subroutines. 4.2 Static Subroutines and Static Variables very subroutine in Java must be defined inside some class. This makes Java rather E allow free-floating, independent unusual among programming languages, since most languages subroutines. One purpose of a class is to group together rela ted subroutines and variables. Perhaps the designers of Java felt that everything must be re lated to something. As a less philosophical motivation, Java’s designers wanted to plac e firm controls on the ways things are named, since a Java program potentially has access to a huge n umber of subroutines created by many different programmers. The fact that those subroutines are grouped into named classes e later) helps control the confusion (and classes are grouped into named “packages,” as we will se that might result from so many different names. There is a basic distinction in Java between static and non-static subroutines. A class definition can contain the source code for both types of subro utine, but what’s done with them when the program runs is very different. Static subroutines a re easier to understand: In a running program, a static subroutine is a member of the class itself. Non-static subroutine definitions, on the other hand, are only there to be used when o bjects are created, and the subroutines themselves become members of the objects. Non- static subroutines only become relevant when you are working with objects. The distinction between static and non-static also applies to variables and to other things that can occur in cla ss definitions. This chapter will deal with static subroutines and static variables almost ex clusively. We’ll turn to non-static stuff and to object-oriented programming in the next chapter . A subroutine that is in a class or object is often called a method , and “method” is the term that most people prefer for subroutines in Java. I will start using the term “method” occa- sionally; however, I will continue to prefer the more genera l term “subroutine” in this chapter, at least for static subroutines. However, you should start t hinking of the terms “method” and “subroutine” as being essentially synonymous as far as Java is concerned. 4.2.1 Subroutine Definitions A subroutine must be defined somewhere. The definition has to i nclude the name of the subroutine, enough information to make it possible to call t he subroutine, and the code that

152 CHAPTER 4. SUBROUTINES 138 tine definition in Java takes the will be executed each time the subroutine is called. A subrou form: parameter-list 〉 〈 subroutine-name 〉 ( 〈 〉 〈 〉 ) { 〈 return-type modifiers 〉 〈 statements } t all this means in detail. Of It will take us a while—most of the chapter—to get through wha main() course, you’ve already seen examples of subroutines in prev ious chapters, such as the routine of a program and the drawFrame() routine of the animation programs in Section 3.9 . So you are familiar with the general format. 〈 statements 〉 between the braces, { The } , in a subroutine definition make up the body and of the subroutine. These statements are the inside, or imple mentation part, of the “black box,” ons that the computer executes when as discussed in the previous section. They are the instructi the method is called. Subroutines can contain any of the stat ements discussed in Chapter 2 Chapter 3 . and The modifiers 〉 that can occur at the beginning of a subroutine definition are words that 〈 set certain characteristics of the subroutine, such as whet her it is static or not. The modifiers that you’ve seen so far are “ ” and “ public ”. There are only about a half-dozen possible static modifiers altogether. If the subroutine is a function, whose job is to compute some v 〈 return-type 〉 alue, then the is used to specify the type of value that is returned by the fun ction. It can be a type name such as String or int or even an array type such as double[ ] . We’ll be looking at functions and return types in some detail in Section 4.4 〈 return-type 〉 is . If the subroutine is not a function, then the void , which indicates that no value is returned. The term “void” replaced by the special value is meant to indicate that the return value is empty or non-exi stent. Finally, we come to the 〈 parameter-list of the method. Parameters are part of the interface 〉 of a subroutine. They represent information that is passed i nto the subroutine from outside, oncrete example, imagine a class to be used by the subroutine’s internal computations. For a c named Television changeChannel() . The immediate question that includes a method named o answer this question. Since is: What channel should it change to? A parameter can be used t the channel number is an integer, the type of the parameter wo int , and the declaration uld be of the changeChannel() method might look like public void changeChannel(int channelNum) { ... } This declaration specifies that changeChannel() has a parameter named channelNum of type int . However, does not yet have any particular value. A value for channelNum is channelNum changeChannel(17); provided when the subroutine is called; for example: ist of one or more parameter The parameter list in a subroutine can be empty, or it can cons 〈 declarations of the form 〉 〈 parameter-name 〉 . If there are several declarations, they are type separated by commas. Note that each declaration can name onl y one parameter. For example, if you want two parameters of type , you have to say “ double x, double y ”, rather double than “ double x, y ”. Parameters are covered in more detail in the next section. Here are a few examples of subroutine definitions, leaving ou t the statements that define what the subroutines do: public static void playGame() { // "public" and "static" are modifiers; "void" is the // return-type; "playGame" is the subroutine-name;

153 CHAPTER 4. SUBROUTINES 139 // the parameter-list is empty. . . . // Statements that define what playGame does go here. } int getNextN(int N) { // There are no modifiers; "int" in the return-type; // "getNextN" is the subroutine-name; the parameter-list // includes one parameter whose name is "N" and whose // type is "int". . . . // Statements that define what getNextN does go here. } static boolean lessThan(double x, double y) { // "static" is a modifier; "boolean" is the // return-type; "lessThan" is the subroutine-name; // the parameter-list includes two parameters whose names a re // "x" and "y", and the type of each of these parameters // is "double". . . . // Statements that define what lessThan does go here. } In the second example given here, getNextN is a non-static method, since its definition does static ”—and so it’s not an example that we should be looking at in not include the modifier “ public this chapter! The other modifier shown in the examples is “ ”. This modifier indicates from outside the class where that the method can be called from anywhere in a program, even private ”, which indicates that the method the method is defined. There is another modifier, “ only from inside the same class. The modifiers public and private can be called are called access specifiers . If no access specifier is given for a method, then by default, that method can be called from anywhere in the “package” that contains th e class, but not from outside Subsection 2.6.6 , and you’ll learn more about them that package. (Packages were mentioned in later in this chapter, in Section 4.5 .) There is one other access modifier, , which will protected mming in only become relevant when we turn to object-oriented progra . Chapter 5 Note, by the way, that the main() routine of a program follows the usual syntax rules for a subroutine. In public static void main(String[] args) { ... } the modifiers are and static , the return type is void , the subroutine name is main , public and the parameter list is “ String[] args ”. In this case, the type for the parameter is the array type String[ ] . entation of a subroutine. In You’ve already had some experience with filling in the implem this chapter, you’ll learn all about writing your own comple te subroutine definitions, including the interface part. 4.2.2 Calling Subroutines When you define a subroutine, all you are doing is telling the c omputer that the subroutine exists and what it does. The subroutine doesn’t actually get executed until it is called. (This is true even for the routine in a class—even though you don’t call it, it is called by the main() system when the system runs your program.) For example, the playGame() method given as an example above could be called using the following subrout ine call statement: playGame();

154 CHAPTER 4. SUBROUTINES 140 cludes the definition of This statement could occur anywhere in the same class that in main() method or in some other subroutine. Since playGame() playGame() , whether in a method, it can also be called from other classes, but in that c public ase, you have to tell is a is a static the computer which class it comes from. Since playGame() method, its full name , for example, that playGame() is includes the name of the class in which it is defined. Let’s say Poker . Then to call playGame() from outside the Poker class, you defined in a class named would have to say Poker.playGame(); o look in to find the method. It The use of the class name here tells the computer which class t and other potential playGame() methods also lets you distinguish between Poker.playGame() or Blackjack.playGame() . defined in other classes, such as Roulette.playGame() subroutine call statement More generally, a static subroutine takes the form for a 〈 subroutine-name 〉 ( 〈 parameters 〉 ); if the subroutine that is being called is in the same class, or 〈 class-name 〉 . 〈 subroutine-name 〉 ( 〈 parameters 〉 ); if the subroutine is defined elsewhere, in a different class. ( Non-static methods belong to objects ad of class names. More on that later.) rather than classes, and they are called using objects inste example, but the parentheses Note that the parameter list can be empty, as in the playGame() r of parameters that you must be there even if there is nothing between them. The numbe provide when you call a subroutine must match the number list ed in the parameter list in the subroutine definition, and the types of the parameters in the call statement must match the types in the subroutine definition. 4.2.3 Subroutines in Programs It’s time to give an example of what a complete program looks l ike, when it includes other subroutines in addition to the routine. Let’s write a program that plays a guessing main() etween 1 and 100, and the game with the user. The computer will choose a random number b user will try to guess it. The computer tells the user whether the guess is high or low or correct. If the user gets the number after six guesses or fewer, the use r wins the game. After each game, the user has the option of continuing with another game. Since playing one game can be thought of as a single, coherent task, it makes sense to write a subroutine that will play one guessing game with the user. T he main() routine will use a loop to call the playGame() ay. subroutine over and over, as many times as the user wants to pl playGame() subroutine the same way we write a We approach the problem of designing the main() pwise refinement. Here is routine: Start with an outline of the algorithm and apply ste a short pseudocode algorithm for a guessing game routine: Pick a random number while the game is not over: Get the user’s guess Tell the user whether the guess is high, low, or correct. The test for whether the game is over is complicated, since th e game ends if either the user makes a correct guess or the number of guesses is six. As in man y cases, the easiest thing to do is to use a “ while (true) ” loop and use break to end the loop whenever we find a reason to do so. Also, if we are going to end the game after six guesses , we’ll have to keep track of the number of guesses that the user has made. Filling out the algo rithm gives:

155 CHAPTER 4. SUBROUTINES 141 Let computersNumber be a random number between 1 and 100 Let guessCount = 0 while (true): Get the user’s guess Count the guess by adding 1 to guess count if the user’s guess equals computersNumber: Tell the user he won break out of the loop if the number of guesses is 6: Tell the user he lost break out of the loop if the user’s guess is less than computersNumber: Tell the user the guess was low else if the user’s guess is higher than computersNumber: Tell the user the guess was high this becomes the definition of the With variable declarations added and translated into Java, routine. A random integer between 1 and 100 can be computed as playGame() (int)(100 * . I’ve cleaned up the interaction with the user to make it flow b etter. Math.random()) + 1 static void playGame() { int computersNumber; // A random number picked by the comput er. int usersGuess; // A number entered by user as a guess. int guessCount; // Number of guesses the user has made. computersNumber = (int)(100 * Math.random()) + 1; // The value assigned to computersNumber is a randomly // chosen integer between 1 and 100, inclusive. guessCount = 0; System.out.println(); System.out.print("What is your first guess? "); while (true) { usersGuess = TextIO.getInt(); // Get the user’s guess. guessCount++; if (usersGuess == computersNumber) { System.out.println("You got it in " + guessCount + " guesses! My number was " + computersNumber); break; // The game is over; the user has won. } if (guessCount == 6) { System.out.println("You didn’t get the number in 6 guesses ."); System.out.println("You lose. My number was " + computersN umber); break; // The game is over; the user has lost. } // If we get to this point, the game continues. // Tell the user if the guess was too high or too low. if (usersGuess < computersNumber) System.out.print("That’s too low. Try again: "); else if (usersGuess > computersNumber) System.out.print("That’s too high. Try again: "); } System.out.println(); } // end of playGame()

156 CHAPTER 4. SUBROUTINES 142 e same class as the main() Now, where exactly should you put this? It should be part of th inside the main routine. It is not legal to have one subroutine routine, but physically nested not routine will call playGame() inside another. The main() , but not contain its definition, only playGame() either before or after the main() a call statement. You can put the definition of routine. Java is not very picky about having the members of a c lass in any particular order. It’s pretty easy to write the main routine. You’ve done thing s like this before. Here’s what am needs more comments than I’ve the complete program looks like (except that a serious progr included here). public class GuessingGame { public static void main(String[] args) { etween"); System.out.println("Let’s play a game. I’ll pick a number b System.out.println("1 and 100, and you try to guess it."); boolean playAgain; do { playGame(); // call subroutine to play one game System.out.print("Would you like to play again? "); playAgain = TextIO.getlnBoolean(); } while (playAgain); System.out.println("Thanks for playing. Goodbye."); } // end of main() static void playGame() { int computersNumber; // A random number picked by the comput er. int usersGuess; // A number entered by user as a guess. int guessCount; // Number of guesses the user has made. computersNumber = (int)(100 * Math.random()) + 1; // The value assigned to computersNumber is a randomly // chosen integer between 1 and 100, inclusive. guessCount = 0; System.out.println(); System.out.print("What is your first guess? "); while (true) { usersGuess = TextIO.getInt(); // Get the user’s guess. guessCount++; if (usersGuess == computersNumber) { System.out.println("You got it in " + guessCount + " guesses! My number was " + computersNumber); break; // The game is over; the user has won. } if (guessCount == 6) { System.out.println("You didn’t get the number in 6 guesses ."); System.out.println("You lose. My number was " + computersN umber); break; // The game is over; the user has lost. } // If we get to this point, the game continues. // Tell the user if the guess was too high or too low. if (usersGuess < computersNumber) System.out.print("That’s too low. Try again: "); else if (usersGuess > computersNumber) System.out.print("That’s too high. Try again: "); } System.out.println();

157 CHAPTER 4. SUBROUTINES 143 } // end of playGame() } // end of class GuessingGame Take some time to read the program carefully and figure out how it works. And try to convince yourself that even in this relatively simple case, breaking up the program into two made it easier to write each methods makes the program easier to understand and probably piece. 4.2.4 Member Variables ticular, it can also include variable A class can include other things besides subroutines. In par declarations. Of course, you can declare variables subroutines. Those are called local inside ubroutine. To variables. However, you can also have variables that are not part of any s member variables distinguish such variables from local variables, we call th em , since they . global variable are members of a class. Another term for them is tic or non-static. In this chapter, Just as with subroutines, member variables can be either sta we’ll stick to static variables. A static member variable be longs to the class as a whole, and it exists as long as the class exists. Memory is allocated for th e variable when the class is first loaded by the Java interpreter. Any assignment statement th at assigns a value to the variable gnment statement is located in changes the content of that memory, no matter where that assi the program. Any time the variable is used in an expression, t he value is fetched from that program. This means that the same memory, no matter where the expression is located in the value of a static member variable can be set in one subroutine and used in another subroutine. utines in the class. A local variable Static member variables are “shared” by all the static subro in a subroutine, on the other hand, exists only while that sub routine is being executed, and is completely inaccessible from outside that one subroutine. The declaration of a member variable looks just like the decl aration of a local variable de any subroutine (although it except for two things: The member variable is declared outsi ked with modifiers such as static , still has to be inside a class), and the declaration can be mar , and private . Since we are only working with static member variables for n ow, every public declaration of a member variable in this chapter will includ e the modifier static . They might also be marked as public private . For example: or static String usersName; public static int numberOfPlayers; private static double velocity, time; A static member variable that is not declared to be private can be accessed from outside the class where it is defined, as well as inside. When it is used in some other class, it must be 〈 class-name 〉 referred to with a compound identifier of the form 〈 variable-name 〉 . For example, . the System class contains the public static member variable named out , and you use this variable in your own classes by referring to System.out . Similarly, Math.PI is a public static member variable in the Math numberOfPlayers is a public static member variable in a class named . If Poker Poker class would refer to it simply as numberOfPlayers , while code , then code in the in another class would refer to it as Poker.numberOfPlayers . As an example, let’s add a couple static member variable to th GuessingGame class that e we wrote earlier in this section. We add a variable named gamesPlayed to keep track of how many games the user has played and another variable named gamesWon to keep track of the number of games that the user has won. The variables are decla red as static member variables:

158 CHAPTER 4. SUBROUTINES 144 static int gamesPlayed; static int gamesWon; routine, we always add 1 to gamesPlayed , and we add 1 to gamesWon if the In the playGame() routine, we print out the values of both variables. user wins the game. At the end of the main() It would be impossible to do the same thing with local variabl es, since both subroutines need e subroutine. to access the variables, and local variables exist in only on assign a value to that variable When you declare a local variable in a subroutine, you have to before you can do anything with it. Member variables, on the o ther hand are automatically same as those that are used when initialized with a default value. The default values are the s, the default value is zero; for initializing the elements of an array: For numeric variable boolean false char variables, it’s the character that has Unicode code variables, the default is ; for Strings , the default initial value is the special value null number zero; and for objects, such as . Since they are of type int , the static member variables gamesPlayed and gamesWon au- tomatically get zero as their initial value. This happens to be the correct initial value for a variable that is being used as a counter. You can, of course, a ssign a value to a variable at the main() e, or if you beginning of the routine if you are not satisfied with the default initial valu want to emphasize that you are depending on the default. Here’s the revised version of . The changes from the above version are shown in italic: public class GuessingGame2 { static int gamesPlayed; // The number of games played. static int gamesWon; // The number of games won. public static void main(String[] args) { gamesPlayed = 0; gamesWon = 0; // This is actually redundant, since 0 is // the default initial value. System.out.println("Let’s play a game. I’ll pick a number b etween"); System.out.println("1 and 100, and you try to guess it."); boolean playAgain; do { playGame(); // call subroutine to play one game System.out.print("Would you like to play again? "); playAgain = TextIO.getlnBoolean(); } while (playAgain); System.out.println(); System.out.println("You played " + gamesPlayed + " games," ); System.out.println("and you won " + gamesWon + " of those gam es."); System.out.println("Thanks for playing. Goodbye."); } // end of main() static void playGame() { int computersNumber; // A random number picked by the comput er. int usersGuess; // A number entered by user as a guess. int guessCount; // Number of guesses the user has made. gamesPlayed++; // Count this game. computersNumber = (int)(100 * Math.random()) + 1; // The value assigned to computersNumber is a randomly // chosen integer between 1 and 100, inclusive. guessCount = 0; System.out.println();

159 CHAPTER 4. SUBROUTINES 145 System.out.print("What is your first guess? "); while (true) { usersGuess = TextIO.getInt(); // Get the user’s guess. guessCount++; if (usersGuess == computersNumber) { System.out.println("You got it in " + guessCount + " guesses! My number was " + computersNumber); gamesWon++; // Count this win. break; // The game is over; the user has won. } if (guessCount == 6) { System.out.println("You didn’t get the number in 6 guesses ."); System.out.println("You lose. My number was " + computersN umber); break; // The game is over; the user has lost. } // If we get to this point, the game continues. // Tell the user if the guess was too high or too low. if (usersGuess < computersNumber) System.out.print("That’s too low. Try again: "); else if (usersGuess > computersNumber) System.out.print("That’s too high. Try again: "); } System.out.println(); } // end of playGame() } // end of class GuessingGame2 ∗ ∗ ∗ the static subroutines or (By the way, notice that in my example programs, I didn’t mark variables as being public or private . You might wonder what it means to leave out both modifiers. Recall that global variables and subroutines wit h no access modifier can be used anywhere in the same package as the class where they are define d, but not in other packages. ge. So, any class in the default Classes that don’t declare a package are in the default packa gamesPlayed , gamesWon , and playGame() package would have access to —and that includes pretty much every class in this book. In fact, it is considere d to be good practice to make member variables and subroutines private , unless there is a reason for doing otherwise.) 4.3 Parameters I f a subroutine is a black box , then a parameter is something that provides a mechanism for passing information from the outside world into the box. Parameters are part of the interface of a subroutine. They allow you to customize the behavior of a subroutine to adapt it to a particular situation. As an analogy, consider a thermostat—a black box whose task i t is to keep your house at a certain temperature. The thermostat has a parameter, na mely the dial that is used to set the desired temperature. The thermostat always perform s the same task: maintaining a constant temperature. However, the exact task that it perfo rms—that is, which temperature it maintains—is customized by the setting on its dial.

160 CHAPTER 4. SUBROUTINES 146 4.3.1 Using Parameters As an example, let’s go back to the “3N+1” problem that was dis cussed in Subsection 3.2.2 . (Recall that a 3N+1 sequence is computed according to the rul e, “if N is odd, multiply it by 3 and add 1; if N is even, divide it by 2; continue until N is equal to 1.” For example, starting from N=3 we get the sequence: 3, 10, 5, 16, 8, 4, 2, 1.) Suppose that w e want to write a subroutine to print out such sequences. The subroutine will always perf orm the same task: Print out a n the starting value of N. So, 3N+1 sequence. But the exact sequence it prints out depends o the starting value of N would be a parameter to the subroutine . The subroutine can be written like this: /** using * This subroutine prints a 3N+1 sequence to standard output, umber * startingValue as the initial value of N. It also prints the n ngValue, * of terms in the sequence. The value of the parameter, starti * must be a positive integer. */ static void print3NSequence(int startingValue) { int N; // One of the terms in the sequence. int count; // The number of terms. N = startingValue; // The first term is whatever value // is passed to the subroutine as // a parameter. count = 1; // We have one term, the starting value, so far. System.out.println("The 3N+1 sequence starting from " + N) ; System.out.println(); System.out.println(N); // print initial term of sequence while (N > 1) { if (N % 2 == 1) // is N odd? N = 3 * N + 1; else N = N / 2; count++; // count this term System.out.println(N); // print this term } System.out.println(); System.out.println("There were " + count + " terms in the seq uence."); } // end print3NSequence The parameter list of this subroutine, “ (int startingValue) ”, specifies that the subroutine has one parameter, of type int . Within the body of the subroutine, the parameter name can be used in the same way as a variable name. But notice that ther e is nothing in the subroutine definition that gives a value to the parameter! The parameter outside gets its initial value from the subroutine. When the subroutine is called, a value must b e provided for the parameter in the subroutine call statement. This value will be assigned t o startingValue before the body of the subroutine is executed. For example, the subroutine c ould be called using the subroutine call statement “ print3NSequence(17); ”. When the computer executes this statement, the computer first assigns the value 17 to startingValue and then executes the statements in the

161 CHAPTER 4. SUBROUTINES 147 If K int , subroutine. This prints the 3N+1 sequence starting from 17. is a variable of type ”. When the computer print3NSequence(K); then the subroutine can be called by saying “ of the variable K , assigns that value executes this subroutine call statement, it takes the value , and then executes the body of the subroutine. to startingValue print3NSequence can contain a routine (or other subrou- The class that contains main() print3NSequence main() program that prints out 3N+1 tines) that call . For example, here is a sequences for various starting values specified by the user: public static void main(String[] args) { ences"); System.out.println("This program will print out 3N+1 sequ ."); System.out.println("for starting values that you specify System.out.println(); int K; // Input from user; loop ends when K < 0. do { System.out.println("Enter a starting value."); System.out.print("To end the program, enter 0: "); K = TextIO.getInt(); // Get starting value from user. if (K > 0) // Print sequence, but only if K is > 0. print3NSequence(K); } while (K > 0); // Continue only if K > 0. } // end main Remember that before you can use this program, the definition main and of s of print3NSequence must both be wrapped inside a class definition. 4.3.2 Formal and Actual Parameters Note that the term “parameter” is used to refer to two differen t, but related, concepts. There are parameters that are used in the definitions of subroutine s, such as startingValue in the above example. And there are parameters that are used in subr outine call statements, such as the K print3NSequence(K); ”. Parameters in a subroutine definition are in the statement “ formal parameters dummy parameters . The parameters that are passed to a called or actual parameters or arguments . When a subroutine subroutine when it is called are called ement are evaluated and the values is called, the actual parameters in the subroutine call stat are assigned to the formal parameters in the subroutine’s de finition. Then the body of the subroutine is executed. A formal parameter must be a name , that is, a simple identifier. A formal parameter is very much like a variable, and—like a variable—it has a specified t ype such as int , boolean , String , or double[ ] . An actual parameter is a , and so it can be specified by any expression, provided value type of the actual parameter must that the expression computes a value of the correct type. The be one that could legally be assigned to the formal parameter with an assignment statement. For example, if the formal parameter is of type double , then it would be legal to pass an int as the actual parameter since ints can legally be assigned to doubles . When you call a subroutine, you must provide one actual parameter for each formal parame ter in the subroutine’s definition. Consider, for example, a subroutine static void doTask(int N, double x, boolean test) { // statements to perform the task go here } This subroutine might be called with the statement doTask(17, Math.sqrt(z+1), z >= 10);

162 CHAPTER 4. SUBROUTINES 148 ly the same effect as the block of When the computer executes this statement, it has essential statements: { s. int N; // Allocate memory locations for the formal parameter double x; boolean test; N = 17; // Assign 17 to the first formal parameter, N. x = Math.sqrt(z+1); // Compute Math.sqrt(z+1), and assign i t to // the second formal parameter, x. test = (z >= 10); // Evaluate "z >= 10" and assign the resulting // true/false value to the third formal // parameter, test. // statements to perform the task go here } (There are a few technical differences between this and “ doTask(17,Math.sqrt(z+1),z>=10); ” ope of variables and what hap- —besides the amount of typing—because of questions about sc .) pens when several variables or parameters have the same name urprisingly confusing. Call- Beginning programming students often find parameters to be s a of providing information to the ing a subroutine that already exists is not a problem—the ide subroutine in a parameter is clear enough. Writing the subro utine definition is another matter. A common beginner’s mistake is to assign values to the formal parameters at the beginning of This represents a fundamental the subroutine, or to ask the user to input their values. When the statements in the subroutine are executed, the form al param- misunderstanding. eters have already been assigned initial values! The comput er automatically assigns values to the parameters before it starts executing the code inside th e subroutine. The values come from the subroutine call statement. Remember that a subrout ine is not independent. It is called by some other routine, and it is the subroutine call st atement’s responsibility to provide appropriate values for the parameters. 4.3.3 Overloading e, you need to know how many In order to call a subroutine legally, you need to know its nam parameter. This information is formal parameters it has, and you need to know the type of each called the subroutine’s signature . The signature of the subroutine doTask , used as an example above, can be expressed as: . Note that the signature does not doTask(int,double,boolean) include the names of the parameters; in fact, if you just want to use the subroutine, you don’t even need to know what the formal parameter names are, so the n ames are not part of the interface. Java is somewhat unusual in that it allows two different subro utines in the same class to have the same name, provided that their signatures are differ ent. When this happens, we say that the name of the subroutine is overloaded because it has several different meanings. The computer doesn’t get the subroutines mixed up. It can tell wh ich one you want to call by the number and types of the actual parameters that you provide in the subroutine call statement. You have already seen overloading used with System.out . This object includes many different methods named println , for example. These methods all have different signatures, s uch as: println(int) println(double) println(char) println(boolean) println()

163 CHAPTER 4. SUBROUTINES 149 based on the type of the The computer knows which of these subroutines you want to use calls the subroutine with sig- actual parameter that you provide. System.out.println(17) , while calls the subroutine with signature println(int) System.out.println(’A’) nature println(char) . Of course all these different subroutines are semantically related, which is why it is acceptable programming style to use the same name fo r them all. But as far as the is very different from printing out a char , which is computer is concerned, printing out an int , and so forth—so that each of these operations requires different from printing out a boolean a different subroutine. not include the subroutine’s return type. It is Note, by the way, that the signature does illegal to have two subroutines in the same class that have th e same signature but that have different return types. For example, it would be a syntax erro r for a class to contain two subroutines defined as: int getln() { ... } double getln() { ... } This is why in the class, the subroutines for reading different types are not al l named TextIO . In a given class, there can only be one routine that has the na getln with no getln() me parameters. So, the input routines in TextIO are distinguished by having different names, such getlnInt() and getlnDouble() . as 4.3.4 Subroutine Examples Let’s do a few examples of writing small subroutines to perfo rm assigned tasks. Of course, sk performed by a subroutine is this is only one side of programming with subroutines. The ta se programs—of deciding how to always a subtask in a larger program. The art of designing tho with subroutines. We’ll return break them up into subtasks—is the other side of programming to the question of program design in Section 4.6 . As a first example, let’s write a subroutine to compute and pri nt out all the divisors of a given positive integer. The integer will be a parameter to th e subroutine. Remember that the syntax of any subroutine is: 〈 〉 〈 return-type 〉 〈 subroutine-name 〉 ( 〈 parameter-list 〉 ) { modifiers statements 〈 〉 } this case, the statement of the Writing a subroutine always means filling out this format. In int problem tells us that there is one parameter, of type , and it tells us what the statements ing with static subroutines in the body of the subroutine should do. Since we are only work static for now, we’ll need to use public or as a modifier. We could add an access modifier ( private ), but in the absence of any instructions, I’ll leave it out. S ince we are not told to return a value, the return type is void . Since no names are specified, we’ll have to make up names for the formal parameter and for the subroutine itself . I’ll use for the parameter and N for the subroutine name. The subroutine will look like printDivisors static void printDivisors( int N ) { statements 〉 〈 } and all we have left to do is to write the statements that make u p the body of the routine. This is not difficult. Just remember that you have to write the body a ssuming that N already has D a value! The algorithm is: “For each possible divisor in the range from 1 to N , if D evenly divides N , then print D .” Written in Java, this becomes:

164 CHAPTER 4. SUBROUTINES 150 /** * Print all the divisors of N. * We assume that N is a positive integer. */ static void printDivisors( int N ) { int D; // One of the possible divisors of N. System.out.println("The divisors of " + N + " are:"); for ( D = 1; D <= N; D++ ) { if ( N % D == 0 ) // Dose D evenly divide N? System.out.println(D); } } I’ve added a comment before the subroutine definition indica ting the contract of the es. The contract includes the subroutine—that is, what it does and what assumptions it mak assumption that N is a positive integer. It is up to the caller of the subroutine to make sure that this assumption is satisfied. private subroutine named As a second short example, consider the problem: Write a . It should have a parameter printRow of type char and a parameter N of type int . The ch N copies of the character ch . subroutine should print out a line of text containing e two parameters, and we Here, we are told the name of the subroutine and the names of th private , so we don’t have much choice about the first line of are told that the subroutine is the subroutine definition. The task in this case is pretty sim ple, so the body of the subroutine is easy to write. The complete subroutine is given by /** * Write one line of output containing N copies of the * character ch. If N <= 0, an empty line is output. */ private static void printRow( char ch, int N ) { int i; // Loop-control variable for counting off the copies. for ( i = 1; i <= N; i++ ) { System.out.print( ch ); } System.out.println(); } t Note that in this case, the contract makes no assumption abou , but it makes it clear what N will happen in all cases, including the unexpected case that N < 0 . Finally, let’s do an example that shows how one subroutine ca n build on another. Let’s write a subroutine that takes a String as a parameter. For each character in the string, it should print a line of output containing 25 copies of that character . It should use the printRow() subroutine to produce the output. the parameter. I’ll call Again, we get to choose a name for the subroutine and a name for the subroutine printRowsFromString and the parameter str . The algorithm is pretty clear: For each position i in the string str , call printRow(str.charAt(i),25) to print one line of the output. So, we get: /** * For each character in str, write a line of output * containing 25 copies of that character. */ private static void printRowsFromString( String str ) {

165 CHAPTER 4. SUBROUTINES 151 int i; // Loop-control variable for counting off the chars. for ( i = 0; i < str.length(); i++ ) { printRow( str.charAt(i), 25 ); } } We could use in a main() routine such as printRowsFromString public static void main(String[] args) { String inputLine; // Line of text input by user. System.out.print("Enter a line of text: "); inputLine = TextIO.getln(); System.out.println(); printRowsFromString( inputLine ); } main() Of course, the three routines, printRowsFromString() , and printRow() , would , have to be collected together inside the same class. The prog ram is rather useless, but it does , if demonstrate the use of subroutines. You’ll find the program i n the file you want to take a look. 4.3.5 Array Parameters It’s possible for the type of a parameter to be an array type. T his means that an entire array of values can be passed to the subroutine as a single paramete r. For example, we might want at format, separated by commas a subroutine to print all the values in an integer array in a ne ay to print, the subroutine would and enclosed in a pair of square brackets. To tell it which arr have a parameter of type int[ ] : static void printValuesInList( int[] list ) { System.out.print(’[’); int i; for ( i = 0; i < list.length; i++ ) { if ( i > 0 ) System.out.print(’,’); // No comma in front of list[0] System.out.print(list[i]); } System.out.println((’]’); } To use this subroutine, you need an actual array. Here is a leg al, though not very realistic, code segment that creates an array just to pass it as an argument to the subroutine: int[] numbers; numbers = new int[3]; numbers[0] = 42; numbers[1] = 17; numbers[2] = 256; printValuesInList( numbers ); The output produced by the last statement would be [42,17,256] .

166 CHAPTER 4. SUBROUTINES 152 4.3.6 Command-line Arguments The String[ ] . When the main routine is main routine of a program has a parameter of type must be passed to as the value of the parameter. The String called, some actual array of main() , so the values come from outside the system provides the actual parameter when it calls main() program. Where do the strings in the array come from, and what do they mean? The strings in the array are command-line arguments from the command that was used to run the program. When using a command-line interface, the user type s a command to tell the system command, beyond the name of to execute a program. The user can include extra input in this ments. The system takes the the program. This extra input becomes the command-line argu and passes that array to . command-line arguments, puts them into an array of strings, main() For example, if the name of the program is myProg , then the user can type “ java myProg ” ne arguments. But if the user to execute the program. In this case, there are no command-li types the command java myProg one two three then the command-line arguments are the strings “one”, “two ”, and “three”. The system puts these strings into an array of Strings and passes that array as a parameter to the main() routine. Here, for example, is a short program that simply prints out a ny command line arguments entered by the user: public class CLDemo { public static void main(String[] args) { System.out.println("You entered " + args.length + " command-line arguments"); if (args.length > 0) { System.out.println("They were:"); int i; for ( i = 0; i < args.length; i++ ) System.out.println(" " + args[i]); } } // end main() } // end class CLDemo args , can be an array of length zero. This just means that the user Note that the parameter, did not include any command-line arguments when running the program. In practice, command-line arguments are often used to pass t he names of files to a program. For example, consider the following program for making a cop y of a text file. It does this by copying one line at a time from the original file to the copy, using TextIO. The function TextIO.eof() boolean -valued function that is true if the end of the file has been reached. is a /** * Requires two command line arguments, which must be file nam es. The * the first must be the name of an existing file. The second is t he name * of a file to be created by the program. The contents of the fir st file * are copied into the second. WARNING: If the second file alre ady * exists when the program is run, its previous contents will b e lost! * This program only works for plain text files. */ public class CopyTextFile { public static void main( String[] args ) {

167 CHAPTER 4. SUBROUTINES 153 if (args.length < 2 ) { System.out.println("Two command-line arguments are requ ired!"); System.exit(1); } TextIO.readFile( args[0] ); // Open the original file for re ading. TextIO.writeFile( args[1] ); // Open the copy file for writi ng. int lineCount; // Number of lines copied lineCount = 0; while ( TextIO.eof() == false ) { // Read one line from the original file and write it to the copy . String line; line = TextIO.getln(); TextIO.putln(line); lineCount++; } System.out.printf( "%d lines copied from %s to %s%n", lineCount, args[0], args[1] ); } } ommand-line arguments Since most programs are run in a GUI environment these days, c de a nice example of how array aren’t as important as they used to be. But at least they provi parameters can be used. 4.3.7 Throwing Exceptions I have been talking about the “contract” of a subroutine. The contract says what the subroutine will do, provided that the caller of the subroutine provides acceptable values for the subroutine’s broutine do when the caller violates parameters. The question arises, though, what should the su the contract by providing bad parameter values? We’ve already seen that some subroutines respond to bad para meter values by throw- Section 3.7 .) For example, the contract of the built-in subroutine ing exceptions. (See Double.parseDouble says that the parameter should be a string representation of a num- ber of type double ; if this is true, then the subroutine will convert the string into the equivalent numeric value. If the caller violates the contract by passin g an invalid string as the actual n of type . parameter, the subroutine responds by throwing an exceptio NumberFormatException Many subroutines throw IllegalArgumentExceptions in response to bad parameter values. be done with a You might want to do the same in your own subroutines. This can throw statement . An exception is an object, and in order to throw an exception , you must create an exception object. You won’t officially learn how to do this u ntil Chapter 5 , but for now, you can use the following syntax for a throw statement that throws an IllegalArgumentException : throw new IllegalArgumentException( 〈 〉 ); error-message where error-message 〉 is a string that describes the error that has been detected. ( The word 〈 “new” in this statement is what creates the object.) To use th is statement in a subroutine, you would check whether the values of the parameters are lega l. If not, you would throw the exception. For example, consider the print3NSequence subroutine from the beginning of this section. The parameter of print3NSequence is supposed to be a positive integer. We can modify the subroutine definition to make it throw an exceptio n when this condition is violated:

168 CHAPTER 4. SUBROUTINES 154 static void print3NSequence(int startingValue) { if (startingValue < = 0) // The contract is violated! be positive." ); throw new IllegalArgumentException( "Starting value must . . // (The rest of the subroutine is the same as before.) . If the start value is bad, the computer executes the throw statement. This will immediately terminate the subroutine, without executing the rest of the body of the subroutine. Further- s “caught” and handled elsewhere more, the program as a whole will crash unless the exception i Section 3.7 . For this to work, the in the program by a try..catch statement, as discussed in subroutine call would have to be in the “try” part of the state ment. 4.3.8 Global and Local Variables ve three different sorts of vari- I’ll finish this section on parameters by noting that we now ha eclared in the subroutine, formal ables that can be used inside a subroutine: local variables d parameter names, and static member variables that are decla red outside the subroutine. Local variables have no connection to the outside world; the y are purely part of the internal working of the subroutine. Parameters are used to “drop” values into the subroutine whe n it is called, but once the subroutine starts executing, parameters act much like loca l variables. Changes made inside a subroutine to a formal parameter have no effect on the rest of the program (at least if the type of the parameter is one of the primitive types—things ar e more complicated in the case of arrays and objects, as we’ll see later). Things are different when a subroutine uses a variable that is defined outside the subroutine. That variable exists independently of the subroutine, and i t is accessible to other parts of the global program as well. Such a variable is said to be to the subroutine, as opposed to the local variables defined inside the subroutine. A global vari able can be used in the entire class in which it is defined and, if it not private , in other classes as well. Changes made to a global variable can have effects that extend outside the subr outine where the changes are made. You’ve seen how this works in the last example in the previous section, where the values of the global variables, gamesPlayed and gamesWon , are computed inside a subroutine and are used in the main() routine. It’s not always bad to use global variables in subroutines, b ut you should realize that the global variable then has to be considered part of the subrout ine’s interface. The subroutine uses the global variable to communicate with the rest of the p rogram. This is a kind of sneaky, back-door communication that is less visible than communic ation done through parameters, and it risks violating the rule that the interface of a black b ox should be straightforward and easy to understand. So before you use a global variable in a su broutine, you should consider whether it’s really necessary. I don’t advise you to take an absolute stand against using glo bal variables inside subroutines. There is at least one good reason to do it: If you think of the cl ass as a whole as being a kind of black box, it can be very reasonable to let the subroutines inside that box be a little sneaky about communicating with each other, if that will make the cl ass as a whole look simpler from the outside.

169 CHAPTER 4. SUBROUTINES 155 4.4 Return Values A function . A given function can only subroutine that returns a value is called a of the function. A function call return type return a value of a specified type, called the ng to find a value, such as the right generally occurs in a position where the computer is expecti side of an assignment statement, as an actual parameter in a s ubroutine call, or in the middle of some larger expression. A boolean-valued function can ev en be used as the test condition in , while , an or do..while statement. if for ment, just as if it were a (It is also legal to use a function call as a stand-alone state regular subroutine. In this case, the computer ignores the v alue computed by the subrou- tine. Sometimes this makes sense. For example, the function TextIO.getln() , with a return String type of y, the line that , reads and returns a line of input typed in by the user. Usuall is returned is assigned to a variable to be used later in the pr ogram, as in the statement name = TextIO.getln(); ”. However, this function is also useful as a subroutine call “ state- ”, which still reads all input up to and including the next car riage TextIO.getln(); ment “ r used in an expression, it is simply return. Since the return value is not assigned to a variable o discarded. So, the effect of the subroutine call is to read and discard some input. Sometimes, discarding unwanted input is exactly what you need to do.) 4.4.1 The return statement You’ve already seen how functions such as and TextIO.getInt() can be used. Math.sqrt() What you haven’t seen is how to write functions of your own. A f unction takes the same form as a regular subroutine, except that you have to specify the v alue that is to be returned by the subroutine. This is done with a return statement , which has the following syntax: return 〈 expression 〉 ; Such a return and the type statement can only occur inside the definition of a function, 〈 〉 must match the return type that was specified for the function . (More of the expression exactly, it must be legal to assign the expression to a variab le whose type is specified by the return statement, it evaluates the expression, return type.) When the computer executes this terminates execution of the function, and uses the value of t he expression as the returned value of the function. For example, consider the function definition static double pythagoras(double x, double y) { // Computes the length of the hypotenuse of a right // triangle, where the sides of the triangle are x and y. return Math.sqrt( x*x + y*y ); } Suppose the computer executes the statement “ totalLength = 17 + pythagoras(12,5); ”. When it gets to the term pythagoras(12,5) , it assigns the actual parameters 12 and 5 to the formal parameters x y in the function. In the body of the function, it evaluates and , which works out to Math.sqrt(12.0*12.0 + 5.0*5.0) . This value is “returned” by the 13.0 function, so the 13.0 essentially replaces the function call in the assignment st atement, which then has the same effect as the statement “ totalLength = 17+ 13.0 ”. The return value is added to , and the result, 30.0, is stored in the variable, totalLength . 17 Note that a return statement does not have to be the last statement in the functi on definition. At any point in the function where you know the val ue that you want to return, you

170 CHAPTER 4. SUBROUTINES 156 ately, skipping any subsequent can return it. Returning a value will end the function immedi statements in the function. However, it must be the case that the function definitely does return takes through the code. some value, no matter what path the execution of the function You can use a statement inside an ordinary subroutine, one with declared return return ”. Since a void subroutine does not return a value, the return statement does not type “ void ”. The effect of this statement is to return; include an expression; it simply takes the form “ terminate execution of the subroutine and return control ba ck to the point in the program from which the subroutine was called. This can be convenient if yo u want to terminate execution return somewhere in the middle of the subroutine, but statements are optional in non-function subroutines. In a function, on the other hand, a return state ment, with expression, is always required. Note that a inside a loop will end the loop as well as the subroutine that c ontains return return in a switch statement breaks out of the switch it. Similarly, a statement as well as the subroutine. So, you will sometimes use return in contexts where you are used to seeing a break . 4.4.2 Function Examples Here is a very simple function that could be used in a program t o compute 3N+1 sequences. (The 3N+1 sequence problem is one we’ve looked at several tim es already, including in the previous section.) Given one term in a 3N+1 sequence, this fu nction computes the next term of the sequence: static int nextN(int currentN) { if (currentN % 2 == 1) // test if current N is odd return 3*currentN + 1; // if so, return this value else return currentN / 2; // if not, return this instead } return statements. Exactly one of the two return This function has two statements is executed to give the value of the function. Some people prefer to use a s ingle return statement at the very end of the function when possible. This allows the reade r to find the return statement easily. You might choose to write nextN() like this, for example: static int nextN(int currentN) { int answer; // answer will be the value returned if (currentN % 2 == 1) // test if current N is odd answer = 3*currentN+1; // if so, this is the answer else answer = currentN / 2; // if not, this is the answer return answer; // (Don’t forget to return the answer!) } Here is a subroutine that uses this nextN function. In this case, the improvement from the version of the subroutine in Section 4.3 is not great, but if nextN() were a long function that performed a complex computation, then it would make a lot of s ense to hide that complexity inside a function: static void print3NSequence(int startingValue) { int N; // One of the terms in the sequence. int count; // The number of terms found.

171 CHAPTER 4. SUBROUTINES 157 . N = startingValue; // Start the sequence with startingValue count = 1; System.out.println("The 3N+1 sequence starting from " + N) ; System.out.println(); System.out.println(N); // print initial term of sequence while (N > 1) { N = nextN( N ); // Compute next term, using the function nextN. count++; // Count this term. System.out.println(N); // Print this term. } System.out.println(); System.out.println("There were " + count + " terms in the seq uence."); } ∗ ∗ ∗ Here are a few more examples of functions. The first one comput es a letter grade corre- le: sponding to a given numerical grade, on a typical grading sca /** * Returns the letter grade corresponding to the numerical * grade that is passed to this function as a parameter. */ static char letterGrade(int numGrade) { if (numGrade >= 90) return ’A’; // 90 or above gets an A else if (numGrade >= 80) return ’B’; // 80 to 89 gets a B else if (numGrade >= 65) return ’C’; // 65 to 79 gets a C else if (numGrade >= 50) return ’D’; // 50 to 64 gets a D else return ’F’; // anything else gets an F } // end of function letterGrade letterGrade() is char The type of the return value of . Functions can return values of any type at all. Here’s a function whose return value is of type boolean . It demonstrates some interesting programming points, so you should read the comm ents: /** * This function returns true if N is a prime number. A prime num ber * is an integer greater than 1 that is not divisible by any posi tive * integer, except itself and 1. If N has any divisor, D, in the r ange * 1 < D < N, then it has a divisor in the range 2 to Math.sqrt(N), n amely * either D itself or N/D. So we only test possible divisors fro m 2 to * Math.sqrt(N). */ static boolean isPrime(int N) { int divisor; // A number we will test to see whether it evenly d ivides N.

172 CHAPTER 4. SUBROUTINES 158 if (N <= 1) return false; // No number <= 1 is a prime. int maxToTry; // The largest divisor that we need to test. maxToTry = (int)Math.sqrt(N); // We will try to divide N by numbers between 2 and maxToTry. // If N is not evenly divisible by any of these numbers, then // N is prime. (Note that since Math.sqrt(N) is defined to // return a value of type double, the value must be typecast // to type int before it can be assigned to maxToTry.) for (divisor = 2; divisor <= maxToTry; divisor++) { if ( N % divisor == 0 ) // Test if divisor evenly divides N. return false; // If so, we know N is not prime. // No need to continue testing! } // If we get to this point, N must be prime. Otherwise, // the function would already have been terminated by // a return statement in the previous loop. return true; // Yes, N is prime. } // end of function isPrime Finally, here is a function with return type . This function has a String as parameter. String ample, the reverse of “Hello The returned value is a reversed copy of the parameter. For ex World” is “dlroW olleH”. The algorithm for computing the rev str , is to erse of a string, start with an empty string and then to append each character f rom str , starting from the last character of str and working backwards to the first: static String reverse(String str) { String copy; // The reversed copy. int i; // One of the positions in str, // from str.length() - 1 down to 0. copy = ""; // Start with an empty string. for ( i = str.length() - 1; i >= 0; i-- ) { // Append i-th char of str to copy. copy = copy + str.charAt(i); } return copy; } A palindrome is a string that reads the same backwards and forwards, such a s “radar”. The reverse() function could be used to check whether a string, word , is a palindrome by testing “ ”. if (word.equals(reverse(word))) By the way, a typical beginner’s error in writing functions i s to print out the answer, instead of returning it. This represents a fundamental misunderstanding. The task of a function is to compute a value and return it to the point in the program w here the function was called. That’s where the value is used. Maybe it will be printed out. M aybe it will be assigned to a variable. Maybe it will be used in an expression. But it’s not for the function to decide.

173 CHAPTER 4. SUBROUTINES 159 4.4.3 3N+1 Revisited I’ll finish this section with a complete new version of the 3N+ 1 program. This will give me a , which was defined above, used in a complete program. chance to show the function nextN() ing it to print the terms of the I’ll also take the opportunity to improve the program by gett sequence in columns, with five terms on each line. This will ma ke the output more presentable. The idea is this: Keep track of how many terms have been printe d on the current line; when that number gets up to 5, start a new line of output. To make the terms line up into neat columns, I use formatted output. /** s. Starting * A program that computes and displays several 3N+1 sequence equence * values for the sequences are input by the user. Terms in the s t. * are printed in columns, with five terms on each line of outpu * After a sequence has been displayed, the number of terms in t hat * sequence is reported to the user. */ public class ThreeN2 { public static void main(String[] args) { System.out.println("This program will print out 3N+1 sequ ences"); System.out.println("for starting values that you specify ."); System.out.println(); int K; // Starting point for sequence, specified by the user. do { System.out.println("Enter a starting value;"); System.out.print("To end the program, enter 0: "); K = TextIO.getlnInt(); // get starting value from user if (K > 0) // print sequence, but only if K is > 0 print3NSequence(K); } while (K > 0); // continue only if K > 0 } // end main /** * print3NSequence prints a 3N+1 sequence to standard output , using * startingValue as the initial value of N. It also prints the n umber * of terms in the sequence. The value of the parameter, starti ngValue, * must be a positive integer. */ static void print3NSequence(int startingValue) { int N; // One of the terms in the sequence. int count; // The number of terms found. int onLine; // The number of terms that have been output // so far on the current line. N = startingValue; // Start the sequence with startingValue ; count = 1; // We have one term so far. System.out.println("The 3N+1 sequence starting from " + N) ; System.out.println(); System.out.printf("%8d", N); // Print initial term, using 8 characters. onLine = 1; // There’s now 1 term on current output line.

174 CHAPTER 4. SUBROUTINES 160 while (N > 1) { N = nextN(N); // compute next term count++; // count this term if (onLine == 5) { // If current output line is full System.out.println(); // ...then output a carriage return onLine = 0; // ...and note that there are no terms // on the new line. } System.out.printf("%8d", N); // Print this term in an 8-cha r column. onLine++; // Add 1 to the number of terms on this line. } System.out.println(); // end current line of output System.out.println(); // and then add a blank line System.out.println("There were " + count + " terms in the seq uence."); } // end of print3NSequence /** * nextN computes and returns the next term in a 3N+1 sequence, * given that the current term is currentN. */ static int nextN(int currentN) { if (currentN % 2 == 1) return 3 * currentN + 1; else return currentN / 2; } // end of nextN() } // end of class ThreeN2 You should read this program carefully and try to understand how it works. 4.5 APIs, Packages, and Javadoc A have become easier to use, they have also s computers and their user interfaces te programs for a simple become more complex for programmers to deal with. You can wri console-style user interface using just a few subroutines t hat write output to the console and face, with windows, buttons, scroll read the user’s typed replies. A modern graphical user inter bars, menus, text-input boxes, and so on, might make things e asier for the user, but it forces the programmer to cope with a hugely expanded array of possib ilities. The programmer sees this increased complexity in the form of great numbers of sub routines that are provided for managing the user interface, as well as for other purposes. 4.5.1 Toolboxes Someone who wanted to program for Macintosh computers—and t o produce programs that look and behave the way users expect them to—had to deal with t he Macintosh Toolbox, a collection of well over a thousand different subroutines. Th ere are routines for opening and closing windows, for drawing geometric figures and text to wi ndows, for adding buttons to windows, and for responding to mouse clicks on the window. Th ere are other routines for

175 CHAPTER 4. SUBROUTINES 161 s. Aside from the user interface, creating menus and for reacting to user selections from menu there are routines for opening files and reading data from the m, for communicating over a nication between programs, and network, for sending output to a printer, for handling commu in general for doing all the standard things that a computer h as to do. Microsoft Windows provides its own set of subroutines for programmers to use, a nd they are quite a bit different from the subroutines used on the Mac. Linux has several differ ent GUI toolboxes for the programmer to choose from. The analogy of a “toolbox” is a good one to keep in mind. Every p rogramming project . A programmer is given a set of involves a mixture of innovation and reuse of existing tools tools to work with, starting with the set of basic tools that a re built into the language: things like variables, assignment statements, if statements, and loops. To these, the programmer can add existing toolboxes full of routines that have already be en written for performing certain true black boxes: They can be called tasks. These tools, if they are well-designed, can be used as articular steps they go through to to perform their assigned tasks without worrying about the p is to take all these tools and apply accomplish those tasks. The innovative part of programming g, keeping track of bank accounts, them to some particular project or problem (word-processin processing image data from a space probe, Web browsing, comp uter games, . . . ). This is called applications programming . A software toolbox is a kind of black box, and it presents a cer tain interface to the pro- re in the toolbox, what parameters grammer. This interface is a specification of what routines a titutes the API , or Application they use, and what tasks they perform. This information cons Programming Interface , associated with the toolbox. The Macintosh API is a specific ation of all the routines available in the Macintosh Toolbox. A com pany that makes some hard- ware device—say a card for connecting a computer to a network —might publish an API for that device consisting of a list of routines that programmer s can call in order to communicate tines for doing some kind of with and control the device. Scientists who write a set of rou ns,” say—would provide an API to complex computation—such as solving “differential equatio allow others to use those routines without understanding th e details of the computations they perform. ∗ ∗ ∗ The Java programming language is supplemented by a large, st andard API. You’ve seen ines such as part of this API already, in the form of mathematical subrout , the Math.sqrt() String data type and its associated routines, and the System.out.print() routines. The standard Java API includes routines for working with graphi cal user interfaces, for network communication, for reading and writing files, and more. It’s tempting to think of these routines as being built into the Java language, but they are technical ly subroutines that have been written and made available for use in Java programs. Java is platform-independent. That is, the same program can run on platforms as diverse as k on all these platforms. Mac OS, Windows, Linux, and others. The same Java API must wor But notice that it is the interface implementation varies that is platform-independent; the from one platform to another. A Java system on a particular co mputer includes implementations of all the standard API routines. A Java program includes onl y calls to those routines. When the Java interpreter executes a program and encounters a cal l to one of the standard routines, it will pull up and execute the implementation of that routin e which is appropriate for the particular platform on which it is running. This is a very pow erful idea. It means that you only need to learn one API to program for a wide variety of platform s.

176 CHAPTER 4. SUBROUTINES 162 4.5.2 Java’s Standard Packages Like all subroutines in Java, the routines in the standard AP I are grouped into classes. To packages rouped into , which were provide larger-scale organization, classes in Java can be g introduced briefly in Subsection 2.6.6 . You can have even higher levels of grouping, since packages can also contain other packages. In fact, the entir e standard Java API is implemented in several packages. One of these, which is named “ java ”, contains several non-GUI packages ”, was javax as well as the original AWT graphics user interface classes. Another package, “ added in Java version 1.2 and contains the classes used by the Swing graphical user interface and other additions to the API. A package can contain both classes and other packages. A pack age that is contained in java package and the javax he another package is sometimes called a “sub-package.” Both t java , for example, is called “ awt ”. package contain sub-packages. One of the sub-packages of Since is contained within java , its full name is actually java.awt . This package contains awt classes that represent GUI components such as buttons and me nus in the AWT. AWT is the d. However, also older of the two Java GUI toolboxes and is no longer widely use java.awt contains a number of classes that form the foundation for all GUI programming, such as the Graphics class which provides routines for drawing on the screen, the Color class which repre- Font class which represents the fonts that are used to display cha sents colors, and the racters on the screen. Since these classes are contained in the packa java.awt , their full names ge java.awt.Graphics are actually java.awt.Color , and java.awt.Font . (I hope that by now , you’ve gotten the hang of how this naming thing works in Java. ) Similarly, javax contains a sub-package named javax.swing, javax.swing.JButton , which includes such GUI classes as , and . The GUI classes in javax.swing , together javax.swing.JMenu javax.swing.JFrame with the foundational classes in java.awt , are all part of the API that makes it possible to program graphical user interfaces in Java. java package includes several other sub-packages, such as The , which provides fa- cilities for input/output, , which deals with network communication, and java.util , which provides a variety of “utility” classes. The most basi c package is called java.lang . This package contains fundamental classes such as String , Math , Integer , and Double . It might be helpful to look at a graphical representation of t he levels of nesting in the package, its sub-packages, the classes in those sub-packag es, and the subroutines in those java classes. This is not a complete picture, since it shows only a very few of the many items in each element: java util awt lang Graphics Math sqrt() drawRect() setColor() random() Color String Integer Font Subroutines classes nested in two layers of packages . nested in . java.lang . Math . sqrt() The full name of sqrt() is

177 CHAPTER 4. SUBROUTINES 163 9 different packages, including The official documentation for the standard Java 7 API lists 20 sub-packages, and it lists 4024 classes in these packages. M any of these are rather obscure or cumentation to see what is very specialized, but you might want to browse through the do available. As I write this, the documentation for the comple te API can be found at Even an expert programmer won’t be familiar with the entire A PI, or even a majority of it. In this book, you’ll only encounter several dozen classes, and those will be sufficient for writing a wide variety of programs. 4.5.3 Using Classes from Packages in a program that you are writing. Let’s say that you want to use the class java.awt.Color Like any class, java.awt.Color is a type, which means that you can use it to declare variables and parameters and to specify the return type of a function. O ne way to do this is to use the full name of the class as the name of the type. For example, sup pose that you want to declare a variable named of type java.awt.Color . You could say: rectColor java.awt.Color rectColor; 〈 〉 〈 variable-name 〉 ;”. Of This is just an ordinary variable declaration of the form “ type-name course, using the full name of every class can get tiresome, a nd you will hardly ever see full names like used in a program. Java makes it possible to avoid using the fu ll java.awt.Color name of a class by importing the class. If you put import java.awt.Color; at the beginning of a Java source code file, then, in the rest of the file, you can abbreviate the full name java.awt.Color to just the simple name of the class, which is Color . Note that the import line comes at the start of a file (after the statement, if there is one) and is package a statement, it is more properly not inside any class. Although it is sometimes referred to as import directive since it is not a statement in the usual sense. The import directive called an import java.awt.Color ” would allow you to say “ Color rectColor; to declare the variable. Note that the only effect of the directive is to allow you to use import ou aren’t really importing anything simple class names instead of full “package.class” names. Y import directive, you can still access the class—you just have substantial; if you leave out the to use its full name. There is a shortcut for importing all the classes from a given package. You can import all the classes from java.awt by saying import java.awt.*; * ” is a wildcard that matches every class in the package. (However, it does no t match The “ sub-packages; for example, you cannot import the entire contents of all the sub-packages of the java package by saying import java.* .) Some programmers think that using a wildcard in an statement is bad style, since import it can make a large number of class names available that you ar e not going to use and might not even know about. They think it is better to explicitly imp ort each individual class that you want to use. In my own programming, I often use wildcards t o import all the classes from the most relevant packages, and use individual imports when I am using just one or two classes from a given package.

178 CHAPTER 4. SUBROUTINES 164 e is likely to use many In fact, any Java program that uses a graphical user interfac and javax.swing packages as well as from another package named classes from the java.awt , and I often begin such programs with java.awt.event import java.awt.*; import java.awt.event.*; import javax.swing.*; A program that works with networking might include the line “ import*; ”, while ”. But when you start importing one that reads or writes files might use “ import*; lots of packages in this way, you have to be careful about one t hing: It’s possible for two classes that are in different packages to have the same name. For examp package le, both the java.awt java.util List . If you import both java.awt.* and and the package contain a class named java.util.* List will be ambiguous. If you try to declare a variable of , the simple name type , you will get a compiler error message about an ambiguous cla ss name. You can List e class, either or still use both classes in your program: Use the full name of th java.awt.List java.util.List . Another solution, of course, is to use import to import the individual classes you need, instead of importing entire packages. java.lang is so fundamental, all the classes in Because the package are auto- java.lang matically imported into every program. It’s as if every program began w ith the statement “ import java.lang.*; ”. This is why we have been able to use the class name String instead of java.lang.String , and Math.sqrt() instead of java.lang.Math.sqrt() . It would still, however, be perfectly legal to use the longer forms of the nam es. ome classes that you are Programmers can create new packages. Suppose that you want s . Then the source code file that defines those writing to be in a package named utilities classes must begin with the line package utilities; This would come even before any import directive in that file. Furthermore, the source code file would be placed in a folder with the same name as the packag e, “utilities” in this example. And a class that is in a subpackage must be in a subfolder. For e xample, a class in a package named would be in folder named “net” inside a folder named “utiliti es”. A class that is in a package automatically has access to other c lasses in the same package; that fined. is, a class doesn’t have to import the package in which it is de In projects that define large numbers of classes, it makes sen se to organize those classes into packages. It also makes sense for programmers to create new packages as toolboxes that provide functionality and APIs for dealing with areas not co vered in the standard Java API. (And in fact such “toolmaking” programmers often have more p restige than the applications programmers who use their tools.) However, with just a couple of exceptions, I will not be creat ing packages in this textbook. mainly so that you will be able For the purposes of this book, you need to know about packages to import the standard packages. These packages are always a vailable to the programs that you write. You might wonder where the standard classes are ac tually located. Again, that can depend to some extent on the version of Java that you are using , but in recent standard versions, they are stored in jar files in a subdirectory named lib inside the Java Runtime Environment installation directory. A jar (or “Java archive”) file is a si ngle file that can contain many classes. Most of the standard classes can be found in a jar file named rt.jar . In fact, Java programs are generally distributed in the form of jar files, instead of as individual class files. Although we won’t be creating packages explicitly, every class is actually part of a package. If a class is not specifically placed in a package, then it is pu t in something called the default

179 CHAPTER 4. SUBROUTINES 165 , which has no name. Almost all the examples that you see in thi s book are in the package default package. 4.5.4 Javadoc The documentation for most To use an API effectively, you need good documentation for it. Java APIs is prepared using a system called . For example, this system is used to Javadoc prepare the documentation for Java’s standard packages. An d almost everyone who creates a toolbox in Java publishes Javadoc documentation for it. Javadoc documentation is prepared from special comments th at are placed in the Java /* and ends with */ source code file. Recall that one type of Java comment begins w ith . A /** /* . You have Javadoc comment takes the same form, but it begins with rather than simply his book. already seen comments of this form in many of the examples in t before the subroutine that it is com- Note that a Javadoc comment must be placed just menting on. This rule is always followed. You can have Javado c comments for subroutines, for member variables, and for classes. The Javadoc comment alwa precedes the ys immediately thing it is commenting on. r when the file is compiled. Like any comment, a Javadoc comment is ignored by the compute that reads Java source code files, extracts any Javadoc But there is a tool called javadoc ng the comments in a nicely comments that it finds, and creates a set of Web pages containi formatted, interlinked form. By default, will only collect information about public javadoc classes, subroutines, and member variables, but it allows t he option of creating documentation javadoc for non-public things as well. If doesn’t find any Javadoc comment for something, it will construct one, but the comment will contain only basic i nformation such as the name and ter list of a subroutine. This type of a member variable or the name, return type, and parame is syntactic tics, you have to information. To add information about semantics and pragma write a Javadoc comment. As an example, you can look at the documentation Web page for TextIO . The documentation page was created by applying the javadoc tool to the source code file, . If you ntation can be found in the have downloaded the on-line version of this book, the docume directory, or you can find a link to it in the on-line version of this section. Javadoc TextIO * javadoc tool In a Javadoc comment, the ’s at the start of each line are optional. The will remove them. In addition to normal text, the comment can contain certain special codes. HTML mark-up For one thing, the comment can contain commands. HTML is the language that is used to create web pages, and Javadoc comments are mea nt to be shown on web pages. javadoc tool will copy any HTML commands in the comments to the web pag es that it The ou can add

to indicate creates. The book will not teach you HTML, but as an example, y the start of a new paragraph. (Generally, in the absence of HT ML commands, blank lines and extra spaces in the comment are ignored. Furthermore, the ch aracters & and < have special meaning in HTML and should not be used in Javadoc comments exc ept with those meanings; & < .) they can be written as and In addition to HTML commands, Javadoc comments can include , which are doc tags processed as commands by the javadoc tool. A doc tag has a name that begins with the character @ . I will only discuss four tags: @author , @param , @return , and @throws . The @author tag can be used only for a class, and should be followed by the n ame of the author. The other three tags are used in Javadoc comments for a subrou tine to provide information about its parameters, its return value, and the exceptions t hat it might throw. These tags

180 CHAPTER 4. SUBROUTINES 166 be placed at the end of the comment, after any description of t he subroutine itself. The must syntax for using them is: 〈 〈 description-of-parameter 〉 parameter-name 〉 @param 〉 description-of-return-value @return 〈 @throws 〉 〈 description-of-exception 〉 〈 exception-class-name 〈 descriptions 〉 can extend over several lines. The description ends at the ne xt doc tag or at The @param the end of the comment. You can include a tag for every parameter of the subroutine and a for as many types of exception as you want to document. You sho uld have @throws @return e given in any a tag only for a non-void subroutine. These tags do not have to b particular order. Here is an example that doesn’t do anything exciting but that does use all three types of doc tag: /** width * This subroutine computes the area of a rectangle, given its * and its height. The length and the width should be positive n umbers. * @param width the length of one side of the rectangle * @param height the length the second side of the rectangle * @return the area of the rectangle * @throws IllegalArgumentException if either the width or t he height * is a negative number. */ public static double areaOfRectangle( double length, doub le width ) { if ( width < 0 || height < 0 ) throw new IllegalArgumentException("Sides must have posi tive length."); double area; area = width * height; return area; } I use Javadoc comments for many of my examples. I encourage yo u to use them in your ation of your work, since it’s own code, even if you don’t plan to generate Web page document a standard format that other Java programmers will be famili ar with. un the javadoc tool. This If you do want to create Web-page documentation, you need to r t was discussed in tool is available as a command in the Java Development Kit tha . Section 2.6 javadoc java javac and You can use in a command line interface similarly to the way that the ted development environments commands are used. Javadoc can also be applied in the integra Section 2.6 . I won’t go into any of the details here; consult the that were also discussed in documentation for your programming environment. 4.5.5 Static Import Before ending this section, I will mention an extension of th import directive. We have seen e import that java.awt.Color using its simple name, makes it possible to refer to a class such as Color . But you still have to use compound names to refer to static me mber variables such as System.out and to static methods such as Math.sqrt . There is another form of the directive that can be used to import static members import of a class in the same way that the ordinary import directive imports classes from a package. That form of the directive is called a static import , and it has syntax

181 CHAPTER 4. SUBROUTINES 167 〈 package-name . 〈 class-name 〉 . 〈 static-member-name 〉 ; import static 〉 to import one static member name from a class, or .*; 〉 . 〈 class-name 〉 package-name import static 〈 ple, if you preface a class to import all the public static members from a class. For exam definition with import static java.lang.System.out; then you can use the simple name instead of the compound name System.out . This means out you can say instead of System.out.println . If you are going to work extensively out.println Math with the class, you can preface your class definition with import static java.lang.Math.*; sqrt instead of Math.sqrt , log This would allow you to say Math.log , PI instead instead of of Math.PI , and so on. Note that the static import directive requires a 〈 package-name 〉 , even for classes in the standard package java.lang rom . One consequence of this is that you can’t do a static import f ble to do a static import from my a class in the default package. In particular, it is not possi TextIO into a package. TextIO class—if you want to do that, you have to move 4.6 More on Program Design nderstanding how programs work is one thing. Designing a program to perform some U particular task is another thing altogether. In , I discussed how pseudocode and Section 3.2 stepwise refinement can be used to methodically develop an al gorithm. We can now see how subroutines can fit into the process. Stepwise refinement is inherently a top-down process, but th e process does have a “bottom,” that is, a point at which you stop refining the pseudocode algo rithm and translate what you have directly into proper program code. In the absence of sub routines, the process would not bottom out until you get down to the level of assignment st atements and very primitive input/output operations. But if you have subroutines lying around to perform certain useful tasks, you can stop refining as soon as you’ve managed to expre ss your algorithm in terms of those tasks. This allows you to add a bottom-up element to the top-down app roach of stepwise re- routines that perform tasks finement. Given a problem, you might start by writing some sub lbox of ready-made tools that relevant to the problem domain. The subroutines become a too ernatively, you might be able to you can integrate into your algorithm as you develop it. (Alt ning subroutines that you can buy or find a software toolbox written by someone else, contai use in your project as black boxes.) Subroutines can also be helpful even in a strict top-down app roach. As you refine your algorithm, you are free at any point to take any sub-task in th e algorithm and make it into a subroutine. Developing that subroutine then becomes a sepa rate problem, which you can work on separately. Your main algorithm will merely call the subr outine. This, of course, is just a way of breaking your problem down into separate, smaller pr oblems. It is still a top-down approach because the top-down analysis of the problem tells you what subroutines to write. In the bottom-up approach, you start by writing or obtaining subroutines that are relevant to the problem domain, and you build your solution to the proble m on top of that foundation of subroutines.

182 CHAPTER 4. SUBROUTINES 168 4.6.1 Preconditions and Postconditions When working with subroutines as building blocks, it is impo rtant to be clear about how a contract raction is specified by the subroutine interacts with the rest of the program. This inte Section 4.1 . A convenient way to express the contract of a of the subroutine, as discussed in subroutine is in terms of preconditions postconditions . and A precondition of a subroutine is something that must be true when the subroutine is called, Math.sqrt(x) , a uilt-in function if the subroutine is to work correctly. For example, for the b precondition is that the parameter, x , is greater than or equal to zero, since it is not possible to take the square root of a negative number. In terms of a cont ract, a precondition represents caller an obligation of the ts of the subroutine. If you call a subroutine without meeting i precondition, then there is no reason to expect it to work pro perly. The program might crash ot the subroutine. or give incorrect results, but you can only blame yourself, n the contract. It is something A postcondition of a subroutine represents the other side of that will be true after the subroutine has run (assuming that its preconditions were met—and that there are no bugs in the subroutine). The postcondition of the function Math.sqrt() is is equal to the parameter that is that the square of the value that is returned by this function only be true if the precondition— provided when the subroutine is called. Of course, this will that the parameter is greater than or equal to zero—is met. A p ostcondition of the built-in subroutine System.out.print(x) is that the value of the parameter has been displayed on the screen. Preconditions most often give restrictions on the acceptab le values of parameters, as in the example of Math.sqrt(x) . However, they can also refer to global variables that are us ed in the subroutine. Or if it only makes sense to call the subroutine a t certain times, the precondition broutine is called. might refer to the state that the program must be in when the su The postcondition of a subroutine, on the other hand, specifi es the task that it performs. hat the function returns. For a function, the postcondition should specify the value t Subroutines are sometimes described by comments that expli citly specify their preconditions tine, a statement of its precon- and postconditions. When you are given a pre-written subrou ditions and postconditions tells you how to use it and what it does. When you are assigned s give you an exact specification of to write a subroutine, the preconditions and postcondition h in the example that constitutes what the subroutine is expected to do. I will use this approac Javadoc comments, but I will the rest of this section. The comments are given in the form of any computer scientists think that explicitly label the preconditions and postconditions. (M @precondition new doc tags @postcondition should be added to the Javadoc system for and explicit labeling of preconditions and postconditions, bu t that has not yet been done.) 4.6.2 A Design Example Let’s work through an example of program design using subrou tines. In this example, we will lso design new subroutines that we use pre-written subroutines as building blocks and we will a need to complete the project. The API that I will use here is de fined in , which . To compile and run a program that uses the API, in turns depends on the classes Mosaic and MosaicPanel must be available. That is, the files and , or the the corresponding compiled class files, must be in the same folder as the class that defines the program. So, suppose that I have found an already-written class calle d Mosaic . This class allows a program to work with a window that displays little colored re ctangles arranged in rows and

183 CHAPTER 4. SUBROUTINES 169 ipulated with static member columns. The window can be opened, closed, and otherwise man class. In fact, the class defines a toolbox or API that can be subroutines defined in the Mosaic able routines in the API, with used for working with such windows. Here are some of the avail Javadoc-style comments. (Remeber that a Javadoc comment co mes before the thing that it is commenting on.) /** * Opens a "mosaic" window on the screen. * ive integers. * Precondition: The parameters rows, cols, w, and h are posit ay rows and * Postcondition: A window is open on the screen that can displ * columns of colored rectangles. Each rectangle is w pixels * wide and h pixels high. The number of rows is given by * the first parameter and the number of columns by the * second. Initially, all rectangles are black. * are * Note: The rows are numbered from 0 to rows - 1, and the columns * numbered from 0 to cols - 1. */ public static void open(int rows, int cols, int w, int h) /** * Sets the color of one of the rectangles in the window. * * Precondition: row and col are in the valid range of row and co lumn numbers, * and r, g, and b are in the range 0 to 255, inclusive. * Postcondition: The color of the rectangle in row number row and column * number col has been set to the color specified by r, g, * and b. r gives the amount of red in the color with 0 * representing no red and 255 representing the maximum * possible amount of red. The larger the value of r, the * more red in the color. g and b work similarly for the * green and blue color components. */ public static void setColor(int row, int col, int r, int g, in t b) /** * Gets the red component of the color of one of the rectangles. * lumn numbers. * Precondition: row and col are in the valid range of row and co * Postcondition: The red component of the color of the specif ied rectangle is * returned as an integer in the range 0 to 255 inclusive. */ public static int getRed(int row, int col) /** * Like getRed, but returns the green component of the color. */ public static int getGreen(int row, int col) /** * Like getRed, but returns the blue component of the color. */

184 CHAPTER 4. SUBROUTINES 170 public static int getBlue(int row, int col) /** * Tests whether the mosaic window is currently open. * * Precondition: None. * Postcondition: The return value is true if the window is ope n when this * function is called, and it is false if the window is * closed. */ public static boolean isOpen() /** h the colors * Inserts a delay in the program (to regulate the speed at whic * are changed, for example). * * Precondition: milliseconds is a positive integer. ified number * Postcondition: The program has paused for at least the spec * of milliseconds, where one second is equal to 1000 * milliseconds. */ public static void delay(int milliseconds) Mosaic class, so when they are called Remember that these subroutines are members of the Mosaic , the name of the class must be included as part of the name of th e routine. from outside Mosaic.isOpen() rather than simply isOpen() . For example, we’ll have to use the name You’ll notice that the comments on the subroutine don’t spec ify what happens when the preconditions are not met. Although a subroutine is not really obligated by its con tract to do anything particular in that case, it would be good to know w hat happens. For example, and column numbers,” on if the precondition, “row and col are in the valid range of row setColor() or getRed() routine is violated, an IllegalArgumentException will be thrown. the h and handle the exception, Knowing that fact would allow you to write programs that catc and it would be good to document it with a @throws doc tag in the Javadoc comment. Other questions remain about the behavior of the subroutines. For example, what happens if you call and there is already a mosaic window open on the screen? (In fa ct, the old one will be closed, and a new one will be created.) It’s difficult to fully document the behavior of a piece of software—sometimes, you just have to experiment o r look at the full source code. ∗ ∗ ∗ My idea for a program is to use the Mosaic class as the basis for a neat animation. I want to fill the window with randomly colored squares, and then ran domly change the colors in a loop that continues as long as the window is open. “Randomly c hange the colors” could mean a lot of different things, but after thinking for a while, I dec ide it would be interesting to have a “disturbance” that wanders randomly around the window, ch anging the color of each square that it encounters. Here’s a picture showing what the conten ts of the window might look like at one point in time:

185 CHAPTER 4. SUBROUTINES 171 ion, I can turn to the specific With basic routines for manipulating the window as a foundat problem at hand. A basic outline for my program is Open a Mosaic window Fill window with random colors Move around, changing squares at random Filling the window with random colors seems like a nice coher ent task that I can work on o do it. The third step can be separately, so let’s decide to write a separate subroutine t expanded a bit more, into the steps: Start in the middle of the window, then keep moving hould continue as long as the to new squares and changing the color of those squares. This s o: mosaic window is still open. Thus we can refine the algorithm t Open a Mosaic window Fill window with random colors Set the current position to the middle square in the window As long as the mosaic window is open: Randomly change color of the square at the current position Move current position up, down, left, or right, at random I need to represent the current position in some way. That can be done with two int variables named currentRow and currentColumn that hold the row number and the column number of the square where the disturbance is currently located. I’ll use 16 rows and 20 columns of squares er means setting currentRow to 8 in my mosaic, so setting the current position to be in the cent currentColumn to 10. I already have a subroutine, , to open the window, and and I have a function, Mosaic.isOpen() , to test whether the window is open. To keep the main routine simple, I decide that I will write two more subro utines of my own to carry out the two tasks in the while loop. The algorithm can then be writ ten in Java as:,20,25,25) fillWithRandomColors(); currentRow = 8; // Middle row, halfway down the window. currentColumn = 10; // Middle column. while ( Mosaic.isOpen() ) { changeToRandomColor(currentRow, currentColumn); randomMove(); }

186 CHAPTER 4. SUBROUTINES 172 main() routine of my program. It turns out I With the proper wrapper, this is essentially the from running much, much too have to make one small modification: To prevent the animation while loop. Mosaic.delay(1); ” is added to the fast, the line “ have to write the routine is taken care of, but to complete the program, I still The main() subroutines changeToRandomColor(int,int) , and randomMove() . fillWithRandomColors() , The fillWithRandomColors() Writing each of these subroutines is a separate, small task. routine is defined by the postcondition that “each of the rect angles in the mosaic has been complish this task can be given changed to a random color.” Pseudocode for an algorithm to ac as: For each row: For each column: set the square in that row and column to a random color “For each row” and “for each column” can be implemented as for loops. We’ve already planned that can be used to set the color. (The possi- changeToRandomColor to write a subroutine bility of reusing subroutines in several places is one of the big payoffs of using them!) So, fillWithRandomColors() can be written in proper Java as: static void fillWithRandomColors() { int row, column; for ( row = 0; row < 16; row++ ) for ( column = 0; column < 20; column++ ) changeToRandomColor(row,column); } Turning to the changeToRandomColor subroutine, we already have a method in the Mosaic class, Mosaic.setColor() , that can be used to change the color of a square. If we want a ra n- dom color, we just have to choose random values for r , g , and b . According to the precondition of the Mosaic.setColor() e from subroutine, these random values must be integers in the rang (int)(256*Math.random()) 0 to 255. A formula for randomly selecting such an integer is “ ”. So the random color subroutine becomes: static void changeToRandomColor(int rowNum, int colNum) { int red = (int)(256*Math.random()); int green = (int)(256*Math.random()); int blue = (int)(256*Math.random()); Mosaic.setColor(rowNum,colNum,red,green,blue); } randomMove subroutine, which is supposed to randomly move the Finally, consider the disturbance up, down, left, or right. To make a random choice among four directions, we can choose a random integer in the range 0 to 3. If the integer i s 0, move in one direction; if it is 1, move in another direction; and so on. The position o f the disturbance is given by the variables currentRow and currentColumn . To “move up” means to subtract 1 from currentRow currentRow becomes -1, which . This leaves open the question of what to do if would put the disturbance above the window (which would viol ate a precondition of several of the Mosaic subroutines). Rather than let this happen, I decide to move t he disturbance to the opposite edge of the grid by setting currentRow to 15. (Remember that the 16 rows are numbered from 0 to 15.) An alternative to jumping to the oppos ite edge would be to simply do nothing in this case. Moving the disturbance down, left, o r right is handled similarly. If we use a switch statement to decide which direction to move, the code for randomMove becomes:

187 CHAPTER 4. SUBROUTINES 173 int directionNum; directionNum = (int)(4*Math.random()); switch (directionNum) { case 0: // move up currentRow--; if (currentRow < 0) // CurrentRow is outside the mosaic; currentRow = 15; // move it to the opposite edge. break; case 1: // move right currentColumn++; if (currentColumn >= 20) currentColumn = 0; break; case 2: // move down currentRow++; if (currentRow >= 16) currentRow = 0; break; case 3: // move left currentColumn--; if (currentColumn < 0) currentColumn = 19; break; } 4.6.3 The Program gram. Note that I’ve added Javadoc- Putting this all together, we get the following complete pro style comments for the class itself and for each of the subrou tines. The variables currentRow and currentColumn are defined as static members of the class, rather than local v ariables, because each of them is used in several different subroutines . You can find a copy of the source . Remember that this program actually depends on two other code in files, and . /** * This program opens a window full of randomly colored square s. A "disturbance" * moves randomly around in the window, randomly changing the color of each * square that it visits. The program runs until the user close s the window. */ public class RandomMosaicWalk { urbance. static int currentRow; // Row currently containing the dist static int currentColumn; // Column currently containing d isturbance. /** * The main program creates the window, fills it with random co lors, * and then moves the disturbance in a random walk around the wi ndow * as long as the window is open. */ public static void main(String[] args) {,20,25,25); fillWithRandomColors(); currentRow = 8; // start at center of window currentColumn = 10;

188 CHAPTER 4. SUBROUTINES 174 while (Mosaic.isOpen()) { changeToRandomColor(currentRow, currentColumn); randomMove(); Mosaic.delay(1); } } // end main /** * Fills the window with randomly colored squares. * Precondition: The mosaic window is open. * Postcondition: Each square has been set to a random color. */ static void fillWithRandomColors() { int row, column; for ( row=0; row < 16; row++ ) { for ( column=0; column < 20; column++ ) { changeToRandomColor(row, column); } } } // end fillWithRandomColors /** * Changes one square to a new randomly selected color. * Precondition: The specified rowNum and colNum are in the va lid range * of row and column numbers. * Postcondition: The square in the specified row and column h as * been set to a random color. * @param rowNum the row number of the square, counting rows do wn * from 0 at the top * @param colNum the column number of the square, counting col umns over * from 0 at the left */ static void changeToRandomColor(int rowNum, int colNum) { int red = (int)(256*Math.random()); // Choose random level s in range int green = (int)(256*Math.random()); // 0 to 255 for red, gr een, onents. int blue = (int)(256*Math.random()); // and blue color comp Mosaic.setColor(rowNum,colNum,red,green,blue); } // end changeToRandomColor /** * Move the disturbance. * Precondition: The global variables currentRow and curren tColumn * are within the legal range of row and column numbers. * Postcondition: currentRow or currentColumn is changed to one of the * neighboring positions in the grid -- up, down, left, or * right from the current position. If this moves the * position outside of the grid, then it is moved to the * opposite edge of the grid. */ static void randomMove() { int directionNum; // Randomly set to 0, 1, 2, or 3 to choose dir ection. directionNum = (int)(4*Math.random()); switch (directionNum) { case 0: // move up currentRow--;

189 CHAPTER 4. SUBROUTINES 175 if (currentRow < 0) currentRow = 15; break; case 1: // move right currentColumn++; if (currentColumn >= 20) currentColumn = 0; break; case 2: // move down currentRow ++; if (currentRow >= 16) currentRow = 0; break; case 3: // move left currentColumn--; if (currentColumn < 0) currentColumn = 19; break; } } // end randomMove } // end class RandomMosaicWalk 4.7 The Truth About Declarations ames are fundamental to programming , as I said a few chapters ago. There are a lot N of details involved in declaring and using names. I have been avoiding some of those details. In this section, I’ll reveal most of the truth (although still n ot the full truth) about declaring and using variables in Java. The material in the subsections “In itialization in Declarations” and e using it regularly from now on. “Named Constants” is particularly important, since I will b 4.7.1 Initialization in Declarations When a variable declaration is executed, memory is allocate d for the variable. This memory variable can be used in an expres- must be initialized to contain some definite value before the n followed closely by an assignment sion. In the case of a local variable, the declaration is ofte statement that does the initialization. For example, int count; // Declare a variable named count. count = 0; // Give count its initial value. However, the truth about declaration statements is that it i s legal to include the initializa- tion of the variable in the declaration statement. The two st atements above can therefore be abbreviated as int count = 0; // Declare count and give it an initial value. The computer still executes this statement in two steps: Dec lare the variable count , then assign the value 0 to the newly created variable. The initial value d oes not have to be a constant. It can be any expression. It is legal to initialize several vari ables in one declaration statement. For example,

190 CHAPTER 4. SUBROUTINES 176 char firstInitial = ’D’, secondInitial = ’E’; int x, y = 1; // OK, but only y has been initialized! int N = 3, M = N+2; // OK, N is initialized // before its value is used. for loops, since it makes it possible to declare a loop control This feature is especially common in variable at the same point in the loop where it is initialized . Since the loop control variable generally has nothing to do with the rest of the program outsi de the loop, it’s reasonable to have its declaration in the part of the program where it’s act ually used. For example: int i = 0 ; i < 10; i++ ) { for ( System.out.println(i); } he following, where I’ve added You should remember that this is simply an abbreviation for t i an extra pair of braces to show that for statement and no is considered to be local to the for longer exists after the loop ends: { int i; for ( i = 0; i < 10; i++ ) { System.out.println(i); } } A member variable can also be initialized at the point where i t is declared, just as for a local variable. For example: public class Bank { private static double interestRate = 0.05; private static int maxWithdrawal = 200; . . // More variables and subroutines. . } ded by the Java interpreter, and A static member variable is created as soon as the class is loa the initialization is also done at that time. In the case of me mber variables, this is not simply an abbreviation for a declaration followed by an assignment statement. Declaration statements outine. Assignment statements are the only type of statement that can occur outside of a subr cannot, so the following is illegal: public class Bank { private static double interestRate; interestRate = 0.05; // ILLEGAL: . // Can’t be outside a subroutine! : . . lude initial values. In fact, as Because of this, declarations of member variables often inc mentioned in Subsection 4.2.4 , if no initial value is provided for a member variable, then a default initial value is used. For example, when declaring a n integer member variable, count , “ static int count; ” is equivalent to “ static int count = 0; ”. Even array variables can be initialized. An array contains s everal elements, not just a single value. To initialize an array variable, you can provide a lis t of values, separated by commas, and enclosed between a pair of braces. For example:

191 CHAPTER 4. SUBROUTINES 177 int[] smallPrimes = { 2, 3, 5, 7, 11, 13, 17, 23, 29 }; In this statement, an array of int of length 9 is created and filled with the values in the list. The length of the array is determined by the number of items in the list. cannot Note that this syntax for initializing arrays be used in assignment statements. It e array variable is declared. can only be used in a declaration statement at the time when th It is also possible to initialize an array variable with an ar new operator ray created using the also be used in assignment statements). For example: (which can String[] namelist = new String[100]; heir default value. but in that case, of course, all the array elements will have t 4.7.2 Named Constants fter it is initialized. For example, Sometimes, the value of a variable is not supposed to change a in the above example where is initialized to the value 0.05 , it’s quite possible interestRate am. In that case, the programmer that 0.05 is meant to be the value throughout the entire progr interestRate is probably defining the variable, , to give a meaningful name to the otherwise 0.05 . It’s easier to understand what’s going on when a program say meaningless number, s ” rather than “ principal += principal*0.05; principal += principal*interestRate; “ ”. In Java, the modifier “ final ” can be applied to a variable declaration to ensure that the able has been initialized. For value stored in the variable cannot be changed after the vari interestRate example, if the member variable is declared with final static double interestRate = 0.05; public then it would be impossible for the value of to change anywhere else in the interestRate program. Any assignment statement that tries to assign a val ue to interestRate will be rejected by the computer as a syntax error when the program is compiled. (A “final” modifier on a public interest rate makes a lot of sense—a bank might wan t to publish its interest rate, ges to it!) but it certainly wouldn’t want to let random people make chan modifier to local variables and even to formal parameters, It is legal to apply the final to a static member variable that but it is most useful for member variables. I will often refer is declared to be as a named constant , since its value remains constant for the whole final time that the program is running. The readability of a progra m can be greatly enhanced by using named constants to give meaningful names to important quantities in the program. A mes that consist entirely of recommended style rule for named constants is to give them na upper case letters, with underscore characters to separate words if necessary. For example, the preferred style for the interest rate constant would be public final static double INTEREST RATE = 0.05; This is the style that is generally used in Java’s standard cl asses, which define many named constants. For example, we have already seen that the Math class contains a variable Math.PI . This variable is declared in the Math double . class as a “public final static” variable of type Color class contains named constants such as Similarly, the and Color.YELLOW Color.RED which are public final static variables of type Color . Many named constants are created just to give meaningful names to be used as parameters in subroutine calls. For example, the standard , and class named contains named constants Font.PLAIN , Font.BOLD Font Font.ITALIC . These constants are used for specifying different styles of text wh en calling various subroutines in the Font class.

192 CHAPTER 4. SUBROUTINES 178 Enumerated type constants (see Subsection 2.3.3 ) are also examples of named constants. The enumerated type definition enum Alignment { LEFT, RIGHT, CENTER } Alignment.RIGHT , and Alignment.CENTER . Technically, , Alignment.LEFT defines the constants bers of that class. is a class, and the three constants are public final static mem Alignment Defining the enumerated type is similar to defining three cons : tants of type, say, int public static final int ALIGNMENT LEFT = 0; public static final int ALIGNMNENT RIGHT = 1; CENTER = 2; public static final int ALIGNMENT In fact, this is how things were generally done before the int roduction of enumerated types, Font.PLAIN and it is what is done with the constants Font.BOLD , and Font.ITALIC mentioned , above. Using the integer constants, you could define a variab int and assign it the le of type ALIGNMENT values , ALIGNMENT RIGHT , or ALIGNMENT CENTER to represent different types LEFT has no way of knowing that you of alignment. The only problem with this is that the computer intend the value of the variable to represent an alignment, a nd it will not raise any objection if the value that is assigned to the variable is not one of the thr ee valid alignment values. With the enumerated type, on the other hand, the only values that c an be assigned to a variable of type Alignment are the constant values that are listed in the definition of th e enumerated type. Any attempt to assign an invalid value to the variable is a syn tax error which the computer s one of the major advantages of will detect when the program is compiled. This extra safety i enumerated types. ∗ ∗ ∗ ants is that it’s easy to Curiously enough, one of the major reasons to use named const change the value of a named constant. Of course, the value can ’t change while the program ge the value in the source code is running. But between runs of the program, it’s easy to chan and recompile the program. Consider the interest rate examp le. It’s quite possible that the value of the interest rate is used many times throughout the p rogram. Suppose that the bank changes the interest rate and the program has to be modified. I f the literal number 0.05 were ack down each place where used throughout the program, the programmer would have to tr the interest rate is used in the program and change the rate to the new value. (This is made even harder by the fact that the number 0.05 might occur in the program with other meanings besides the interest rate, as well as by the fact that someone might have, say, used 0.025 to represent half the interest rate.) On the other hand, if the n amed constant INTEREST RATE is n only the single line where the declared and used consistently throughout the program, the constant is initialized needs to be changed. As an extended example, I will give a new version of the RandomMosaicWalk program from the previous section. This version uses named constants to r epresent the number of rows in the mosaic, the number of columns, and the size of each little square. The three constants are declared as final static member variables with the lines: final static int ROWS = 20; // Number of rows in mosaic. final static int COLUMNS = 30; // Number of columns in mosaic. final static int SQUARE SIZE = 15; // Size of each square in mosaic. The rest of the program is carefully modified to use the named c onstants. For example, in the new version of the program, the Mosaic window is opened wi th the statement SIZE, SQUARE SIZE);, COLUMNS, SQUARE

193 CHAPTER 4. SUBROUTINES 179 nstant needs to be used. If Sometimes, it’s not easy to find all the places where a named co you don’t use the named constant consistently, you’ve more o r less defeated the purpose. It’s ues for any named constant, to always a good idea to run a program using several different val test that it works properly in all cases. RandomMosaicWalk2 , with all modifications from the Here is the complete new program, previous version shown in italic. I’ve left out some of the co mments to save space. public class RandomMosaicWalk2 { final static int ROWS = 20; // Number of rows in mosaic. final static int COLUMNS = 30; // Number of columns in mosaic. final static int SQUARE SIZE = 15; // Size of each square in mosaic. static int currentRow; // Row currently containing the dist urbance. static int currentColumn; // Column currently containing t he disturbance. public static void main(String[] args) { ROWS, COLUMNS, SQUARE SIZE, SQUARE ; SIZE ) fillWithRandomColors(); currentRow = ROWS / 2 ; // start at center of window ; currentColumn = COLUMNS / 2 while (Mosaic.isOpen()) { changeToRandomColor(currentRow, currentColumn); randomMove(); Mosaic.delay(1); } } // end main static void fillWithRandomColors() { for ( int row=0; row < ROWS; row++ ) { for ( int column=0; column COLUMNS; column++ ) { < changeToRandomColor(row, column); } } } // end fillWithRandomColors static void changeToRandomColor(int rowNum, int colNum) { s in range int red = (int)(256*Math.random()); // Choose random level een, int green = (int)(256*Math.random()); // 0 to 255 for red, gr int blue = (int)(256*Math.random()); // and blue color comp onents. Mosaic.setColor(rowNum,colNum,red,green,blue); } // end changeToRandomColor static void randomMove() { int directionNum; // Randomly set to 0, 1, 2, or 3 to choose dir ection. directionNum = (int)(4*Math.random()); switch (directionNum) { case 0: // move up currentRow--; if (currentRow < 0) currentRow = ROWS - 1; break; case 1: // move right currentColumn++; if ( currentColumn > = COLUMNS ) currentColumn = 0;

194 CHAPTER 4. SUBROUTINES 180 break; case 2: // move down currentRow++; > ) if ( currentRow = ROWS currentRow = 0; break; case 3: // move left currentColumn--; if (currentColumn < 0) currentColumn = COLUMNS - 1 ; break; } } // end randomMove } // end class RandomMosaicWalk2 4.7.3 Naming and Scope Rules d for that variable. The variable When a variable declaration is executed, memory is allocate e to refer to that memory name can be used in at least some part of the program source cod or to the data that is stored in the memory. The portion of the p rogram source code where scope the variable is valid is called the of the variable. Similarly, we can refer to the scope of subroutine names and formal parameter names. For static member subroutines, scope is straightforward. T he scope of a static subroutine is the entire source code of the class in which it is defined. Th at is, it is possible to call the subroutine from any point in the class, including at a point i n the source code before the point where the definition of the subroutine appears. It is even pos sible to call a subroutine from sion,” a fairly advanced topic that within itself. This is an example of something called “recur Chapter 9 . If the subroutine is not private , it can also be accessed from we will return to in outside the class where it is defined, using its full name. a class, the situation is similar, For a variable that is declared as a static member variable in but with one complication. It is legal to have a local variabl e or a formal parameter that has the same name as a member variable. In that case, within the sc ope of the local variable or parameter, the member variable is hidden . Consider, for example, a class named Game that has the form: public class Game { static int count; // member variable static void playGame() { int count; // local variable . . // Some statements to define playGame() . } . . // More variables and subroutines. . } // end Game

195 CHAPTER 4. SUBROUTINES 181 playGame() subroutine, the name “ ” In the statements that make up the body of the count class, “ ” refers to the member variable Game refers to the local variable. In the rest of the count ). However, the member vari- (unless hidden by other local variables or parameters named count count Game.count . Usually, the full name able named can also be referred to by the full name is only used outside the class where count is defined. However, there is no rule against using Game.count , can be used inside the playGame() subroutine it inside the class. The full name, . So, the full scope rule is that the to refer to the member variable instead of the local variable n which it is defined, but where the scope of a static member variable includes the entire class i le or formal parameter name, the simple name of the member variable is hidden by a local variab m 〈 className 〉 . 〈 variableName member variable must be referred to by its full name of the for . 〉 (Scope rules for non-static members are similar to those for static members, except that, as we shall see, non-static members cannot be used in static subro utines.) The scope of a formal parameter of a subroutine is the block th at makes up the body of the subroutine. The scope of a local variable extends from the de claration statement that defines the variable to the end of the block in which the declaration o ccurs. As noted above, it is possible to declare a loop control variable of a for for statement, as in “ for (int loop in the ”. The scope of such a declaration is considered as a special c i=0; i < 10; i++) ase: It is valid only within the for statement and does not extend to the remainder of the block tha t for statement. contains the It is not legal to redefine the name of a formal parameter or loc al variable within its scope, even in a nested block. For example, this is not allowed: void badSub(int y) { int x; while (y > 0) { int x; // ERROR: x is already defined. . . . } } x while loop would hide In many languages, this would be legal; the declaration of in the the original declaration. It is not legal in Java; however, o nce the block in which a variable is declared ends, its name does become available for reuse in Ja va. For example: void goodSub(int y) { while (y > 10) { int x; . . . // The scope of x ends here. } while (y > 0) { int x; // OK: Previous declaration of x has expired. . . . } }

196 CHAPTER 4. SUBROUTINES 182 utine names. This can’t You might wonder whether local variable names can hide subro e that variables and subroutines happen, for a reason that might be surprising. There is no rul have to have different names. The computer can always tell whe ther a name refers to a variable wed by a left parenthesis. It’s or to a subroutine, because a subroutine name is always follo count and a subroutine called count in the same class. perfectly legal to have a variable called (This is one reason why I often write subroutine names with pa rentheses, as when I talk about the main() routine. It’s a good idea to think of the parentheses as part o f the name.) Even more is true: It’s legal to reuse class names to name variable s and subroutines. The syntax rules of Java guarantee that the computer can always tell whe n a name is being used as a class name. A class name is a type, and so it can be used to declare var iables and formal parameters and to specify the return type of a function. This means that y ou could legally have a class called Insanity in which you declare a function static Insanity Insanity( Insanity Insanity ) { ... } The first Insanity is the return type of the function. The second is the function name, the third is the type of the formal parameter, and the fourth is th e name of the formal parameter. However, please remember that not everything that is possib le is a good idea!

197 Exercises 183 Exercises for Chapter 4 1. (solution) To “capitalize” a string means to change the first letter of ea ch word in the string to upper ized version of “Now is the time case (if it is not already upper case). For example, a capital to act!” is “Now Is The Time To Act!”. Write a subroutine named printCapitalized that will print a capitalized version of a string to standard output. The string to be printed main() routine that should be a parameter to the subroutine. Test your subroutin e with a gets a line of input from the user and applies the subroutine t o it. Note that a letter is the first letter of a word if it is not immed iately preceded in the string by another letter. Recall from Exercise 3.4 that ther e is a standard boolean -valued Character.isLetter(char) function that can be used to test whether its parameter is a letter. There is another standard -valued function, Character.toUpperCase(char) , char assed to it as a parameter. That that returns a capitalized version of the single character p rsion. If the parameter is not a is, if the parameter is a letter, it returns the upper-case ve letter, it just returns a copy of the parameter. The hexadecimal digits are the ordinary, base-10 digits ’0’ through ’9’ plus the letters ’A’ 2. (solution) through ’F’. In the hexadecimal system, these digits repres ent the values 0 through 15, respectively. Write a function named hexValue that uses a switch statement to find the hexadecimal value of a given character. The character is a pa rameter to the function, and its hexadecimal value is the return value of the function. Yo u should count lower case letters ’a’ through ’f’ as having the same value as the corres ponding upper case letters. eturn -1 If the parameter is not one of the legal hexadecimal digits, r as the value of the function. uch as 34A7, ff8, 174204, or A hexadecimal integer is a sequence of hexadecimal digits, s str is a string containing a hexadecimal integer, then the corre sponding base-10 FADE. If integer can be computed as follows: value = 0; for ( i = 0; i < str.length(); i++ ) value = value*16 + hexValue( str.charAt(i) ); Of course, this is not valid if str contains any characters that are not hexadecimal digits. aracters in the string are Write a program that reads a string from the user. If all the ch hexadecimal digits, print out the corresponding base-10 va lue. If not, print out an error message. 3. Write a function that simulates rolling a pair of dice until t he total on the dice comes up (solution) rameter to the function. to be a given number. The number that you are rolling for is a pa The number of times you have to roll the dice is the return valu e of the function. The parameter should be one of the possible totals: 2, 3, . . . , 12. The function should throw an IllegalArgumentException if this is not the case. Use your function in a program that computes and prints the number of rolls it takes to get snake e yes. (Snake eyes means that the total showing on the dice is 2.) (solution) This exercise builds on Exercise 4.3. Every time you roll the dice repeatedly, trying to 4. get a given total, the number of rolls it takes can be different . The question naturally arises, what’s the average number of rolls to get a given tota l? Write a function that performs the experiment of rolling to get a given total 10000 times. The desired total is

198 Exercises 184 the return value. Each a parameter to the subroutine. The average number of rolls is individual experiment should be done by calling the functio n you wrote for Exercise 4.3. r each of the possible totals Now, write a main program that will call your function once fo (2, 3, ..., 12). It should make a table of the results, somethi ng like: Total On Dice Average Number of Rolls ------------- ----------------------- 2 35.8382 3 18.0607 . . . . 5. The sample program Section 4.6 shows a “disturbance” (solution) from that wanders around a grid of colored squares. When the distu rbance visits a square, the color of that square is changed. Here’s an idea for a varia tion on that program. In the new version, all the squares start out with the default co lor, black. Every time the disturbance visits a square, a small amount is added to the gr een component of the color ct, as the path followed by the of that square. The result will be a visually interesting effe disturbance gradually turns a brighter and brighter green. Write a subroutine that will add 25 to the green component of o ne of the squares in the mosaic. (But don’t let the green component go over 255, since that’s the largest legal value for a color component.) The row and column numbers of the squa re should be given as he current green component parameters to the subroutine. Recall that you can discover t r and column c with the function call Mosaic.getGreen(r,c) . Use of the square in row your subroutine as a substitute for the changeToRandomColor() subroutine in the program . (This is the improved version of the program from Section 4.7 that uses named constants for the number of rows, number of co lumns, and square size.) quare size to 5. Set the number of rows and the number of columns to 80. Set the s ce and a gray border By default, the rectangles in the mosaic have a “3D” appearan that makes them look nicer in the random walk program. But for this program, you want to turn off that effect. To do so, call Mosaic.setUse3DEffect(false) in the main program. to compile and run and Don’t forget that you will need your program, since they define non-standard classes that ar e required by the program. 6. For this exercise, you will do something even more interesti ng with the Mosaic class that (solution) was discussed in Section 4.6 . (Again, don’t forget that you will need and to compile and run your program.) The program that you write for this exercise should start by fi lling a mosaic with random colors. Then repeat the following until the user clos es the mosaic window: Se- lect one of the rectangles in the mosaic at random. Then selec t one of the neighboring rectangles—above it, below it, to the left of it, or to the rig ht of it. Copy the color of the originally selected rectangle to the selected neighbor, so that the two rectangles now have the same color. As this process is repeated over and over, it becomes more and more likely that neigh- boring squares will have the same color. The result is to buil d up larger color patches. On the other hand, once the last square of a given color disappea rs, there is no way for that color to ever reappear. (Extinction is forever!) If you let t he program run long enough, eventually the entire mosaic will be one uniform color.

199 Exercises 185 (solution) Write a program that administers a basic addition quiz to the 7. user. There should be ch as 17 + 42 , where the ten questions. Each question is a simple addition problem su g). The program should numbers in the problem are chosen at random (and are not too bi ask the user all ten questions and get the user’s answers. Aft er asking all the questions, the user should print each question again, with the user’s answe r. If the user got the answer right, the program should say so; if not, the program should g ive the correct answer. At the end, tell the user their score on the quiz, where each corr ect answer counts for ten points. The program should use three subroutines, one to create the q uiz, one to administer the quiz, and one to grade the quiz. It can use three arrays, wi th three global variables of type int[ ] , to refer to the arrays. The first array holds the first number f rom every question, the second holds the second number from every ques tions, and the third holds the user’s answers.

200 Quiz 186 Quiz on Chapter 4 (answers) n what is meant by the 1. A “black box” has an interface and an implementation. Explai and . interface terms implementation contract . What is meant by the contract of a subroutine? 2. A subroutine is said to have a When you want to use a subroutine, why is it important to under stand its contract? The contract has both “syntactic” and “semantic” aspects. What is the syntactic aspect? What is the semantic aspect? 3. Briefly explain how subroutines can be useful in the top-down design of programs. Discuss the concept of 4. What are parameters for? What is the difference parameters. between and actual parameters ? formal parameters Give two different reasons for using named constants (declar final modifier). 5. ed with the What is an API? Give an example. 6. 7. ars to standard output. (A Write a subroutine named “stars” that will output a line of st star is the character “*”.) The number of stars should be give n as a parameter to the subroutine. Use a for loop. For example, the command “stars(20)” would output ******************** 8. Write a routine that uses the subroutine that you wrote for Question 7 to output main() ond line, and so on, as shown 10 lines of stars with 1 star in the first line, 2 stars in the sec below. * ** *** **** ***** ****** ******* ******** ********* ********** 9. Write a function named countChars that has a String and a char as parameters. The function should count the number of times the character occu rs in the string, and it should return the result as the value of the function. 10. Write a subroutine with three parameters of type int. The subroutine should determine which of its parameters is smallest. The value of the smalles t parameter should be returned as the value of the subroutine. 11. Write a function that finds the average of the first N elements of an array of type double . The array and N are parameters to the subroutine. 12. Explain the purpose of the following function, and explain h ow it works:

201 Quiz 187 static int[] stripZeros( int[] list ) { int count = 0; for (int i = 0; i < list.length; i++) { if ( list[i] != 0 ) count++; } int[] newList; newList = new int[count]; int j = 0; for (int i = 0; i < list.length; i++) { if ( list[i] != 0 ) { newList[j] = list[i]; j++; } } return newList; }

202 Chapter 5 Programming in the Large II: Objects and Classes W a (in hereas a subroutine represents a single task, an object can encapsulate both dat s or “behaviors” related to that the form of instance variables) and a number of different task data (in the form of instance methods). Therefore objects pr ovide another, more sophisticated ty of large programs. type of structure that can be used to help manage the complexi The first four sections of this chapter introduce the basic th ings you need to know to work with objects and to define simple classes. The remaining sect ions cover more advanced topics; you might not understand them fully the first time through. In particular, Section 5.5 covers the tance and polymorphism. However, most central ideas of object-oriented programming: inheri ed form, by creating independent in this textbook, we will generally use these ideas in a limit gning entire hierarchies of classes classes and building on existing classes rather than by desi from scratch. 5.1 Objects, Instance Methods, and Instance Variables O bject-oriented programming (OOP) represents an attempt to make programs more closely model the way people think about and deal with the wor ld. In the older styles of programming, a programmer who is faced with some problem mus t identify a computing task ramming then consists of that needs to be performed in order to solve the problem. Prog task. But at the heart of object- finding a sequence of instructions that will accomplish that oriented programming, instead of tasks we find objects—enti ties that have behaviors, that hold mming consists of designing a set information, and that can interact with one another. Progra bjects in the program can of objects that somehow model the problem at hand. Software o represent real or abstract entities in the problem domain. T his is supposed to make the design of the program more natural and hence easier to get right and e asier to understand. To some extent, OOP is just a change in point of view. We can thi nk of an object in standard programming terms as nothing more than a set of variables tog ether with some subroutines for manipulating those variables. In fact, it is possible to use object-oriented techniques in any programming language. However, there is a big difference bet ween a language that makes OOP possible and one that actively supports it. An object-orien ted programming language such as Java includes a number of features that make it very different from a standard language. In order to make effective use of those features, you have to “ori ent” your thinking correctly. As I have mentioned before, in the context of object-oriente d programming, subroutines are 189

203 CHAPTER 5. OBJECTS AND CLASSES 190 methods . Now that we are starting to use objects, I will be using the te often referred to as rm “method” more often than “subroutine.” 5.1.1 Objects, Classes, and Instances Objects are closely related to classes. We have already been working with classes for several chapters, and we have seen that a class can contain variables and methods (that is, subroutines). If an object is also a collection of variables and methods, ho w do they differ from classes? And why does it require a different type of thinking to understand and use them effectively? In the Section 3.9 , it didn’t seem to , one section where we worked with objects rather than classes make much difference: We just left the word “ static ” out of the subroutine definitions! that the non-static portions of I have said that classes “describe” objects, or more exactly hat this means. The more usual classes describe objects. But it’s probably not very clear w belong to terminology is to say that objects classes, but this might not be much clearer. (There is a real shortage of English words to properly distinguish a ll the concepts involved. An object certainly doesn’t “belong” to a class in the same way that a me mber variable “belongs” to a class.) From the point of view of programming, it is more exac t to say that classes are used for constructing objects. The to create objects. A class is a kind of factory—or blueprint— iables and methods the objects will non-static parts of the class specify, or describe, what var contain. This is part of the explanation of how objects differ from classes: Objects are created and destroyed as the program runs, and there can be many objec ts with the same structure, if they are created using the same class. Consider a simple class whose job is to group together a few st atic member variables. For example, the following class could be used to store informat ion about the person who is using the program: class UserData { static String name; static int age; } In a program that uses this class, there is only one copy of eac h of the variables and UserData.age . When the class is loaded into the computer, there is a sectio n of memory devoted to the class, and that section of memory includes spa ce for the values of the variables name and age. We can picture the class in memory as looking like this: class UserD a a na  a  An important point is that the static member variables are pa rt of the representation of the class in memory. Their full names, and UserData.age , use the name of the class, since they are part of the class. When we use class UserData to represent the user of the program, there can only be one user, since we only have memory space to store data about one user. Note that the class, UserData , and the variables it contains exist as long as the program runs. (That is essentially what it means to be “st atic.”) Now, consider a similar class that includes some non-static variables:

204 CHAPTER 5. OBJECTS AND CLASSES 191 class PlayerData { static int playerCount; String name; int age; } PlayerData class. Here, the static variable I’ve also included a static variable in the is stored as part of the representation of the class in memory . It’s full name playerCount , and there is only one of it, which exists as long as the progra is PlayerData.playerCount m n are non-static. There is no such runs. However, the other two variables in the class definitio or PlayerData.age variable as , since non-static variables do not become part of the class itself. But the PlayerData class can be used to create objects. There can be ts own variables called name and many objects created using the class, and each one will have i . This is what it means for the non-static parts of the class to age be a template for objects: Every object gets its own copy of the non-static part of the cl ass. We can visualize the situation in the computer’s memory after several object have been crea ted like this: class   3 playerCount: ) constructor ( PlayerData instanceof instanceof PlayerData name: age: name: age: instanceof PlayerData name: age: playerCount Note that the static variable is part of the class, and there is only one copy. name and an age . An object that is created from On the other hand, every object contains a instance a class is called an of that class, and as the picture shows every object “knows” which class was used to create it. I’ve shown class PlayerData as containing something called a “constructor;” the constructor is a subroutine that create s objects. Now there can be many “players” because we can make new object s to represent new players on demand. A program might use the PlayerData class to store information about multiple players in a game. Each player has a name and an age. When a play er joins the game, a new PlayerData object can be created to represent that player. If a player le aves the game, the PlayerData object that represents that player can be destroyed. A syste m of objects in the program is being used to dynamically model what is happening in the game. You can’t do this with static variables! “Dynamic” is the opposite of “st atic.” ∗ ∗ ∗ An object that is created using a class is said to be an instance of that class. We will sometimes say that the object belongs to the class. The variables that the object contains are

205 CHAPTER 5. OBJECTS AND CLASSES 192 instance variables . The methods (that is, subroutines) that the object contain called s are . For example, if the PlayerData called instance methods class, as defined above, is used to class, and and age PlayerData create an object, then that object is an instance of the name are instance variables in the object. My examples here don’t include any methods, but methods work similarly to variables. Static methods are part of the class; non-static, or instanc e, methods become part of objects created from the class. It’s not literally true that each obj ect contains its own copy of the actual compiled code for an instance method. But logically an insta nce method is part of the object, and I will continue to say that the object “contains” the inst ance method. source code Note that you should distinguish between the class itself for the class, and the (in memory). The source code determines both the class and th e objects that are created from fy the things that are part of the that class. The “static” definitions in the source code speci atic definitions in the source code class itself (in the computer’s memory), whereas the non-st specify things that will become part of every instance objec t that is created from the class. By the way, static member variables and static member subrou tines in a class are sometimes class variables and class methods called , since they belong to the class itself, rather than to instances of that class. ss are very different things and As you can see, the static and the non-static portions of a cla serve very different purposes. Many classes contain only sta tic members, or only non-static, xture of the two. and we will see only a few examples of classes that contain a mi 5.1.2 Fundamentals of Objects So far, I’ve been talking mostly in generalities, and I haven ’t given you much of an idea about what you have to put in a program if you want to work with object s. Let’s look at a specific example to see how it works. Consider this extremely simplifi ed version of a class, Student ng a course: which could be used to store information about students taki public class Student { public String name; // Student’s name. public double test1, test2, test3; // Grades on three tests. public double getAverage() { // compute average test grade return (test1 + test2 + test3) / 3; } } // end of class Student static , so the class exists only for None of the members of this class are declared to be creating objects. This class definition says that any object that is an instance of the Student name , test1 class will include instance variables named test2 , and test3 , and it will include an , instance method named getAverage() . The names and tests in different objects will generally have different values. When called for a particular student, getAverage() will the method compute an average using that student’s test grades. Different students can have different averages. (Again, this is what it means to say that an instanc e method belongs to an individual object, not to the class.) In Java, a class is a type , similar to the built-in types such as int and boolean . So, a class name can be used to specify the type of a variable in a declarat ion statement, or the type of a formal parameter, or the return type of a function. For exam ple, a program could define a variable named std of type Student with the statement

206 CHAPTER 5. OBJECTS AND CLASSES 193 Student std; However, declaring a variable does not create an object! This is an important point, which is related to this Very Important Fact: In Java, no variable can ever hold an object. A variable can only hold a reference to an object. in the computer’s memory. In You should think of objects as floating around independently fact, there is a special portion of memory called the heap where objects live. Instead of holding an object itself, a variable holds the information necessar y to find the object in memory. This or pointer information is called a reference to the object. In effect, a reference to an object ed. When you use a variable of is the address of the memory location where the object is stor object type, the computer uses the reference in the variable to find the actual object. In a program, objects are created using an operator called new , which creates an object and returns a reference to that object. (In fact, the new operator calls a special subroutine called std is a variable of type Student , a “constructor” in the class.) For example, assuming that declared as above, the assignment statement std = new Student(); Student , and it would store a would create a new object which is an instance of the class . The value of the variable is a reference, or pointer, reference to that object in the variable std s not quite true, then, to say that to the object. The object itself is somewhere in the heap. It i the object is the “value of the variable std ” (though sometimes it is hard to avoid using this not at all true to say that the object is “stored in the variable terminology). It is certainly .” The proper terminology is that “the variable std refers to or points to the object,” std and I will try to stick to that terminology as much as possible . If I ever say something like “std an object,” you should read it as meaning “std is a variable th at refers to an object.” is std refers to an object that is an instance of class Student . So, suppose that the variable That object contains instance variables name , test1 , test2 , and test3 . These instance vari- ables can be referred to as std.test1 , std.test2 , and std.test3 . This follows the , B is A , then the full name of B usual naming convention that when A.B . For example, is part of a program might include the lines es are:"); System.out.println("Hello, " + + ". Your test grad System.out.println(std.test1); System.out.println(std.test2); System.out.println(std.test3); This would output the name and test grades from the object to w hich std refers. Simi- larly, std can be used to call the getAverage() instance method in the object by saying std.getAverage() . To print out the student’s average, you could say: ); System.out.println( "Your average is " + std.getAverage() any place where a variable of type String is legal. More generally, you could use You can use it in expressions. You can assign a value to it. You can even use it to call subroutines from the String class. For example, is the number of characters in the student’s name. It is possible for a variable like , whose type is given by a class, to refer to no object at std all. We say in this case that std holds a null pointer or null reference . The null pointer is written in Java as “ null ”. You can store a null reference in the variable std by saying

207 CHAPTER 5. OBJECTS AND CLASSES 194 std = null; null not is an actual value that is stored in the variable, not a pointe r to something else. It is is e variable correct to say that the variable “points to null”; in fact, th null. For example, you can test whether the value of std is null by testing if (std == null) . . . If the value of a variable is , then it is, of course, illegal to refer to instance variable s null or instance methods through that variable—since there is no object, and hence no instance variables to refer to! For example, if the value of the variab le std is null , then it would be illegal to refer to std.test1 . If your program attempts to use a null pointer illegally in t his way, the result is an error called a null pointer exception . When this happens while the NullPointerException program is running, an exception of type is thrown. Let’s look at a sequence of statements that work with objects : Student std, std1, // Declare four variables of std2, std3; // type Student. std = new Student(); // Create a new object belonging // to the class Student, and // store a reference to that // object in the variable std. std1 = new Student(); // Create a second Student object // and store a reference to // it in the variable std1. std2 = std1; // Copy the reference value in std1 // into the variable std2. std3 = null; // Store a null reference in the // variable std3. = "John Smith"; // Set values of some instance varia bles. = "Mary Jones"; // (Other instance variables have default // initial values of zero.) After the computer executes these statements, the situatio n in the computer’s memory looks like this:

208 CHAPTER 5. OBJECTS AND CLASSES 195 std: std1: std2: std3: null Student instanceof instanceof Student name: name: test1: test1: 0 0 test2: test2: 0 0 test3: test3: 0 0 getAverage() getAverage() instanceof String instanceof String "John Smith" "Mary Jones" ject, the value of that variable is In this picture, when a variable contains a reference to an ob t the are objects! The shown as an arrow pointing to the object. Note, by the way, tha Strings std3 , with a value of null , doesn’t point anywhere. The arrows from std1 and std2 variable both point to the same object. This illustrates a Very Import ant Point: When one object variable is assigned to another, only a reference is copied. The object referred to is not copied. When the assignment “ std2 = std1 std2 ;” was executed, no new object was created. Instead, was set to refer to the very same object that std1 refers to. This is to be expected, since the assignment statement just copies the value that is stored in std1 into std2 , and that value is a pointer, not an object. But this has some consequences th at might be surprising. For and are two different names for the same variable, namely example, std1 std2 refer to. After the string "Mary the instance variable in the object that both and Jones" , it is also true that the value of is is assigned to the variable "Mary Jones" . There is a potential for a lot of confusion here, but you can h elp protect yourself from it if you keep telling yourself, “The object is not in the variable. The variable just holds a pointer to the object.” You can test objects for equality and inequality using the op erators == and != , but here again, the semantics are different from what you are used to. When you make a test if (std1 == std2) ”, you are testing whether the values stored in std1 “ std2 are the and same. But the values that you are comparing are references to objects; they are not objects. So, you are testing whether std1 and std2 refer to the same object, that is, whether they point to the same location in memory. This is fine, if it’s what you wa nt to do. But sometimes, what you want to check is whether the instance variables in th e objects have the same values. To do that, you would need to ask whether “ std1.test1 == std2.test1 && std1.test2 == std2.test2 && std1.test3 == std2.test3 && s( ”.

209 CHAPTER 5. OBJECTS AND CLASSES 196 Strings are objects, and I’ve shown the strings I’ve remarked previously that "Mary Jones" as objects in the above illustration. (Strings are special o "John Smith" bjects, treated and by Java in a special way, and I haven’t attempted to show the ac tual internal structure of the String objects.) Since strings are objects, a variable of type String can only hold a reference to a operator to test strings for equality string, not the string itself. This explains why using the == is a variable of type String , and that it refers to greeting is not a good idea. Suppose that the string "Hello" . Then would the test greeting == "Hello" be true? Well, maybe, maybe greeting and the String not. The variable "Hello" each refer to a string that contains literal the characters H-e-l-l-o. But the strings could still be diff erent objects, that just happen to greeting == "Hello" contain the same characters; in that case, would be false. The function greeting.equals("Hello") tests whether greeting and "Hello" contain the same characters, pression greeting == "Hello" which is almost certainly the question you want to ask. The ex tests whether greeting "Hello" contain the same characters stored in the same mem- and ory location String variable such as greeting can also contain the special value . (Of course, a null , and it would make sense to use the == operator to test whether “ greeting == null ”.) ∗ ∗ ∗ The fact that variables hold references to objects, not obje cts themselves, has a couple of ogically, if you just keep in mind other consequences that you should be aware of. They follow l the basic fact that the object is not stored in the variable. T he object is somewhere else; the variable points to it. o be final Suppose that a variable that refers to an object is declared t . This means that the value stored in the variable can never be changed, once th e variable has been initialized. The value stored in the variable is a reference to the object. So the variable will continue to refer to the same object as long as the variable exists. Howev er, this does not prevent the data in the object final , not the object. It’s perfectly legal to say from changing. The variable is final Student stu = new Student(); = "John Doe"; // Change data in the object; // The value stored in stu is not changed! // It still refers to the same object. Next, suppose that obj is a variable that refers to an object. Let’s consider what ha ppens when obj is passed as an actual parameter to a subroutine. The value of obj is assigned to a formal parameter in the subroutine, and the subroutine is e xecuted. The subroutine has no obj power to change the value stored in the variable, . It only has a copy of that value. However, the value is a reference to an object. Since the subroutine ha s a reference to the object, it can in the object. After the subroutine ends, change the data stored still points to the same obj object, but the data stored in the object might have changed. Suppose x is a variable of type int and stu is a variable of type Student . Compare: void dontChange(int z) { void change(Student s) { = "Fred"; z = 42; } } The lines: The lines: x = 17; = "Jane"; dontChange(x); change(stu); System.out.println(x); System.out.println(; output the value 17. output the value "Fred".

210 CHAPTER 5. OBJECTS AND CLASSES 197 The value of x is not The value of stu is not changed by the subroutine, changed, but is changed . which is equivalent to This is equivalent to s = stu; z = x; = "Fred"; z = 42; 5.1.3 Getters and Setters When writing new classes, it’s a good idea to pay attention to the issue of access control. Recall public makes it accessible from anywhere, including from that making a member of a class other classes. On the other hand, a private member can only be used in the class where it is defined. In the opinion of many programmers, almost all member variab les should be declared private . This gives you complete control over what can be done with th e variable. Even if the variable itself is private, you can allow other classe s to find out what its value is by pro- viding a accessor method that returns the value of the variable. For example, if your public class contains a member variable, title , of type String , you can provide a method private public String getTitle() { return title; } title . By convention, the name of an accessor method for a variable that returns the value of get” in front of the name. So, for is obtained by capitalizing the name of variable and adding “ title , we get an accessor method named “get” + “Title”, or getTitle() . Because the variable of this naming convention, accessor methods are more often r eferred to as getter methods . A getter method provides “read access” to a variable. (Someti mes for variables, “is” is boolean boolean done might used in place of “get”. For example, a getter for a member variable named be called isDone() .) private variable. That is, you might You might also want to allow “write access” to a ue for the variable. This is done want to make it possible for other classes to specify a new val with a setter method . (If you don’t like simple, Anglo-Saxon words, you can use th e fancier term mutator method .) The name of a setter method should consist of “set” followe d by a capitalized copy of the variable’s name, and it should have a parameter with the same type as the variable. A setter method for the variable could be written title public void setTitle( String newTitle ) { title = newTitle; } It is actually very common to provide both a getter and a sette r method for a private member variable. Since this allows other classes both to see and to change the value of the variable, you might wonder why not just make the variable public ? The reason is that getters and setters are not restricted to simply reading and writing the variable’s value. In fact, they can take any action at all. For example, a getter method might keep track of the number of times that the variable has been accessed: public String getTitle() { titleAccessCount++; // Increment member variable titleAc cessCount. return title; }

211 CHAPTER 5. OBJECTS AND CLASSES 198 signed to the variable is legal: and a setter method might check that the value that is being as public void setTitle( String newTitle ) { if ( newTitle == null ) // Don’t allow null strings as titles! stead. title = "(Untitled)"; // Use an appropriate default value in else title = newTitle; } Even if you can’t think of any extra chores to do in a getter or s etter method, you might change your mind in the future when you redesign and improve your cla ss. If you’ve used a getter and setter from the beginning, you can make the modification to yo ur class without affecting any of member variable is not part of the public interface the classes that use your class. The private getter and setter methods are, and you are free to change thei of your class; only the public r haven’t used get our class. If you implementations without changing the public interface of y ho uses your class and tell them, and set from the beginning, you’ll have to contact everyone w “Sorry people, you’ll have to track down every use that you’v e made of this variable and change your code to use my new get and set methods instead.” he naming convention A couple of final notes: Some advanced aspects of Java rely on t e convention rigorously. And for getter and setter methods, so it’s a good idea to follow th though I’ve been talking about using getter and setter metho ds for a variable, you can define or setter method defines a get and set methods even if there is no variable. A getter and/ property of the class, that might or might not correspond to a variable . For example, if a class public void instance method with signature setValue(double) , then the class has includes a a “property” named of type double , and it has this property whether or not the class value has a member variable named value . 5.1.4 Arrays and Objects As I noted in Subsection 3.8.1 , arrays are objects. Like Strings they are special objects, with their own unique syntax. An array type such as int[ ] or String[ ] is actually a class, and arrays are created using a special version of the new operator. As in the case for other object variables, ence to an array object. The array an array variable can never hold an actual array—only a refer ariable to hold the value null , which object itself exists in the heap. It is possible for an array v means there is no actual array. list is a variable of type int[ ] . If the value of list is For example, suppose that , null then any attempt to access or an array element list[i] would be an error and list.length NullPointerException . If newlist is another variable of type would cause an exception of type int[ ] , then the assignment statement newlist = list; only copies the reference value in into newlist . If list is null , the result is that newlist list will also be null . If list points to an array, the assignment statement does not make a copy of the array. It just sets to refer to the same array as list . For example, the output newlist of the following code segment list = new int[3]; list[1] = 17; newlist = list; // newlist points to the same array as list! newlist[1] = 42; System.out.println( list[1] );

212 CHAPTER 5. OBJECTS AND CLASSES 199 list[1] and are just different names for the same would be 42, not 17, since newlist[1] stand that arrays are objects and element in the array. All this is very natural, once you under array variables hold pointers to arrays. meter to a subroutine. The This fact also comes into play when an array is passed as a para value that is copied into the subroutine is a pointer to the ar ray. The array is not copied. Since the subroutine has a reference to the original array, any cha nges that it makes to elements of the array are being made to the original and will persist afte r the subroutine returns. ∗ ∗ ∗ Arrays are objects. They can also hold objects. The base type of an array can be a class. We have already seen this when we used arrays of type String[ ] , but any class can be used as Student is the class defined earlier in this section. Then the base type. For example, suppose Student[ ] we can have arrays of type Student[ ] , each element of the array . For an array of type Student y is a variable of type . To store information about 30 students, we could use an arra Student[] classlist; // Declare a variable of type Student[ ]. classlist = new Student[30]; // The variable now points to an array. classlist[0] The array has 30 elements, classlist[1] , . . . classlist[29] . When the array , is created, it is filled with the default initial value, which for an object type is null . So, although we have 30 array elements of type Student , we don’t yet have any actual Student objects! All we have is 30 nulls. If we want student objects, we have to crea te them: Student[] classlist; classlist = new Student[30]; for ( int i = 0; i < 30; i++ ) { classlist[i] = new Student(); } Once we have done this, each classlist[i] points to an object of type Student . If we want classlist[3].name . The average to talk about the name of student number 3, we can use i for student number classlist[i].getAverage() . You can do can be computed by calling anything with that you could do with any other variable of type Student . classlist[i] 5.2 Constructors and Object Initialization O bject types in Java are very different from the primitive types. Simply declarin g a variable whose type is given as a class does not automatically create a n object of that class. Objects constructed . For the computer, the process of constructing an object mea ns, must be explicitly first, finding some unused memory in the heap that can be used to hold the object and, second, filling in the object’s instance variables. As a programmer, you don’t care where in memory the object is stored, but you will usually want to exercise so me control over what initial values are stored in a new object’s instance variables. In many case s, you will also want to do more complicated initialization or bookkeeping every time an ob ject is created. 5.2.1 Initializing Instance Variables An instance variable can be assigned an initial value in its d eclaration, just like any other variable. For example, consider a class named PairOfDice . An object of this class will represent a pair of dice. It will contain two instance variables to repr esent the numbers showing on the dice and an instance method for rolling the dice:

213 CHAPTER 5. OBJECTS AND CLASSES 200 public class PairOfDice { public int die1 = 3; // Number showing on the first die. public int die2 = 4; // Number showing on the second die. public void roll() { // Roll the dice by setting each of the dice to be // a random number between 1 and 6. die1 = (int)(Math.random()*6) + 1; die2 = (int)(Math.random()*6) + 1; } } // end class PairOfDice and die2 The instance variables die1 are initialized to the values 3 and 4 respectively. These PairOfDice object is constructed. It’s important to initializations are executed whenever a understand when and how this happens. There can be many PairOfDice objects. Each time one nments “ is created, it gets its own instance variables, and the assig ” and “ die2 = 4 ” die1 = 3 are executed to fill in the values of those variables. To make t his clearer, consider a variation PairOfDice of the class: public class PairOfDice { public int die1 = (int)(Math.random()*6) + 1; public int die2 = (int)(Math.random()*6) + 1; public void roll() { die1 = (int)(Math.random()*6) + 1; die2 = (int)(Math.random()*6) + 1; } } // end class PairOfDice Here, every time a new PairOfDice is created, the dice are initialized to random values, as if a new pair of dice were being thrown onto the gaming table. Sinc e the initialization is executed for each new object, a set of random initial values will be com puted for each new pair of dice. Different pairs of dice can have different initial values. For initialization of member static e is only one copy of a variable, variables, of course, the situation is quite different. Ther static and initialization of that variable is executed just once, w hen the class is first loaded. If you don’t provide any initial value for an instance variab le, a default initial value is pro- ( vided automatically. Instance variables of numerical type , double , etc.) are automatically int initialized to zero if you provide no other values; boolean variables are initialized to false ; and char variables, to the Unicode character with code number zero. A n instance variable can also be a variable of object type. For such variables, the default null . (In particular, initial value is since Strings are objects, the default initial value for String variables is null .) 5.2.2 Constructors Objects are created with the operator, new . For example, a program that wants to use a PairOfDice object could say: PairOfDice dice; // Declare a variable of type PairOfDice. dice = new PairOfDice(); // Construct a new object and store a // reference to it in the variable.

214 CHAPTER 5. OBJECTS AND CLASSES 201 new PairOfDice() ” is an expression that allocates memory for the object, In this example, “ initializes the object’s instance variables, and then retu rns a reference to the object. This reference is the value of the expression, and that value is st ored by the assignment statement in the variable, dice , so that after the assignment statement is executed, dice refers to the newly created object. Part of this expression, “ PairOfDice() ”, looks like a subroutine call, and that utine called a constructor . This is no accident. It is, in fact, a call to a special type of subro might puzzle you, since there is no such subroutine in the cla ss definition. However, every class has at least one constructor. If the programmer doesn’t writ e a constructor definition in a class, then the system will provide a for that class. This default constructor default constructor ize instance variables. If you want does nothing beyond the basics: allocate memory and initial lude one or more constructors more than that to happen when an object is created, you can inc in the class definition. The definition of a constructor looks much like the definition of any other subroutine, with e (not even three exceptions. A constructor does not have any return typ ). The name void of the constructor must be the same as the name of the class in w hich it is defined. And the only modifiers that can be used on a constructor definition are the access modifiers public , private , and protected . (In particular, a constructor can’t be declared static .) However, a constructor does have a subroutine body of the usu al form, a block of statements. a constructor can have a list There are no restrictions on what statements can be used. And of formal parameters. In fact, the ability to include parame ters is one of the main reasons for ed in the construction of the using constructors. The parameters can provide data to be us object. For example, a constructor for the class could provide the values that are PairOfDice initially showing on the dice. Here is what the class would lo ok like in that case: public class PairOfDice { public int die1; // Number showing on the first die. public int die2; // Number showing on the second die. public PairOfDice(int val1, int val2) { // Constructor. Creates a pair of dice that // are initially showing the values val1 and val2. die1 = val1; // Assign specified values die2 = val2; // to the instance variables. } public void roll() { // Roll the dice by setting each of the dice to be // a random number between 1 and 6. die1 = (int)(Math.random()*6) + 1; die2 = (int)(Math.random()*6) + 1; } } // end class PairOfDice The constructor is declared as “ public PairOfDice(int val1, int val2) ... ”, with no return type and with the same name as the name of the class. Thi s is how the Java com- piler recognizes a constructor. The constructor has two par ameters, and values for these parameters must be provided when the constructor is called. For example, the expression “ new PairOfDice(3,4) ” would create a PairOfDice object in which the values of the instance variables die1 and die2 are initially 3 and 4. Of course, in a program, the value retur ned by the constructor should be used in some way, as in

215 CHAPTER 5. OBJECTS AND CLASSES 202 PairOfDice dice; // Declare a variable of type PairOfDice. dice = new PairOfDice(1,1); // Let dice refer to a new PairOfD ice // object that initially shows 1, 1. PairOfDice class, we can no longer create an Now that we’ve added a constructor to the object by saying “ new PairOfDice() ”! The system provides a default constructor for a class r. In this version of only , if the class definition does not already include a constructo PairOfDice o actual parameters. However, there is only one constructor in the class, and it requires tw this is not a big problem, since we can add a second constructo r to the class, one that has ctors as you want, as long as no parameters. In fact, you can have as many different constru ifferent numbers or types of formal their signatures are different, that is, as long as they have d PairOfDice parameters. In the class, we might have a constructor with no parameters which produces a pair of dice showing random numbers: public class PairOfDice { public int die1; // Number showing on the first die. public int die2; // Number showing on the second die. public PairOfDice() { // Constructor. Rolls the dice, so that they initially // show some random values. roll(); // Call the roll() method to roll the dice. } public PairOfDice(int val1, int val2) { // Constructor. Creates a pair of dice that // are initially showing the values val1 and val2. die1 = val1; // Assign specified values die2 = val2; // to the instance variables. } public void roll() { // Roll the dice by setting each of the dice to be // a random number between 1 and 6. die1 = (int)(Math.random()*6) + 1; die2 = (int)(Math.random()*6) + 1; } } // end class PairOfDice PairOfDice object either with “ new PairOfDice() ” Now we have the option of constructing a new PairOfDice(x,y) ”, where x and y are int -valued expressions. or with “ This class, once it is written, can be used in any program that needs to work with one or more pairs of dice. None of those programs will ever have to use the obscure incantation “ (int)(Math.random()*6)+1 ”, because it’s done inside the PairOfDice class. And the pro- grammer, having once gotten the dice-rolling thing straigh t will never have to worry about it again. Here, for example, is a main program that uses the PairOfDice class to count how many times two pairs of dice are rolled before the two pairs come up showing the same value. This illustrates once again that you can create several instance s of the same class: public class RollTwoPairs { public static void main(String[] args) { PairOfDice firstDice; // Refers to the first pair of dice.

216 CHAPTER 5. OBJECTS AND CLASSES 203 firstDice = new PairOfDice(); PairOfDice secondDice; // Refers to the second pair of dice. secondDice = new PairOfDice(); int countRolls; // Counts how many times the two pairs of // dice have been rolled. int total1; // Total showing on first pair of dice. int total2; // Total showing on second pair of dice. countRolls = 0; do { // Roll the two pairs of dice until totals are the same. firstDice.roll(); // Roll the first pair of dice. total1 = firstDice.die1 + firstDice.die2; // Get total. System.out.println("First pair comes up " + total1); secondDice.roll(); // Roll the second pair of dice. total2 = secondDice.die1 + secondDice.die2; // Get total. System.out.println("Second pair comes up " + total2); countRolls++; // Count this roll. System.out.println(); // Blank line. } while (total1 != total2); System.out.println("It took " + countRolls + " rolls until the totals were the same."); } // end main() } // end class RollTwoPairs ∗ ∗ ∗ Constructors are subroutines, but they are subroutines of a special type. They are certainly not instance methods, since they don’t belong to objects. Si nce they are responsible for creating objects, they exist before any objects have been created. Th static member ey are more like subroutines, but they are not and cannot be declared to be static . In fact, according to the Java language specification, they are technically not membe rs of the class at all! In particular, constructors are not referred to as “methods.” Unlike other subroutines, a constructor can only be called u new operator, in an sing the expression that has the form new 〈 〉 ( 〈 parameter-list 〉 ) class-name where the 〈 parameter-list 〉 is possibly empty. I call this an expression because it compu tes and returns a value, namely a reference to the object that is cons tructed. Most often, you will store the returned reference in a variable, but it is also legal to u se a constructor call in other ways, for example as a parameter in a subroutine call or as part of a m ore complex expression. Of course, if you don’t save the reference in a variable, you won ’t have any way of referring to the object that was just created. A constructor call is more complicated than an ordinary subr outine or function call. It is helpful to understand the exact steps that the computer goes through to execute a constructor call:

217 CHAPTER 5. OBJECTS AND CLASSES 204 First, the computer gets a block of unused memory in the heap, large enough to hold an 1. object of the specified type. It initializes the instance variables of the object. If the d eclaration of an instance variable 2. specifies an initial value, then that value is computed and st ored in the instance variable. Otherwise, the default initial value is used. 3. The actual parameters in the constructor, if any, are evalua ted, and the values are assigned to the formal parameters of the constructor. 4. The statements in the body of the constructor, if any, are exe cuted. A reference to the object is returned as the value of the const ructor call. 5. nstructed object. The end result of this is that you have a reference to a newly co ∗ ∗ ∗ For another example, let’s rewrite the class that was used in Section 1. I’ll add a Student constructor, and I’ll also take the opportunity to make the i nstance variable, name , private. public class Student { private String name; // Student’s name. public double test1, test2, test3; // Grades on three tests. Student(String theName) { // Constructor for Student objects; // provides a name for the Student. // The name can’t be null. if ( theName == null ) throw new IllegalArgumentException("name can’t be null") ; name = theName; } public String getName() { // Getter method for reading the value of the private // instance variable, name. return name; } public double getAverage() { // Compute average test grade. return (test1 + test2 + test3) / 3; } } // end of class Student An object of type Student contains information about some particular student. The co n- structor in this class has a parameter of type String , which specifies the name of that student. Objects of type Student can be created with statements such as: std = new Student("John Smith"); std1 = new Student("Mary Jones"); In the original version of this class, the value of name had to be assigned by a program after it created the object of type Student . There was no guarantee that the programmer would always remember to set the name properly. In the new version of the class, there is no way to cr eate a Student object except by calling the constructor, and that construc tor automatically sets the name . Furthermore, the constructor makes it impossible to have a student object whose name is

218 CHAPTER 5. OBJECTS AND CLASSES 205 . The programmer’s life is made easier, and whole hordes of fr ustrating bugs are squashed null before they even have a chance to be born. private Another type of guarantee is provided by the modifier. Since the instance variable, private , there is no way for any part of the program outside the Student class to get at name , is directly. The program sets the value of name , indirectly, when it calls the constructor. the name I’ve provided a getter function, getName() , that can be used from outside the class to find out name of the student. But I haven’t provided any setter method or ot the her way to change the name. Once a student object is created, it keeps the same name as long as it exists. iable to be “ final ” Note that it would be legal, and good style, to declare the var name in this class. An instance variable can be final provided it is either assigned a value in its declaration or is assigned a value in every constructor in th e class. It is illegal to assign a value to a final instance variable, except inside a constructor. ∗ ∗ ∗ Let’s take this example a little farther to illustrate one mo re aspect of classes: What happens when you mix static and non-static in the same class? In that c ase, it’s legal for an instance method in the class to use static member variables or call sta tic member subroutines. An object knows what class it belongs to, and it can refer to static memb ers of that class. But there it ively, all the objects share one only one copy of the static member, in the class itself. Effect copy of the static member. As an example, consider a version of the Student class to which I’ve added an ID for each static member called student and a . Although there is an ID variable in each nextUniqueID student object, there is only one nextUniqueID variable. public class Student { private String name; // Student’s name. public double test1, test2, test3; // Grades on three tests. private int ID; // Unique ID number for this student. private static int nextUniqueID = 0; // keep track of next available unique ID number Student(String theName) { // Constructor for Student objects; provides a name for the S tudent, // and assigns the student a unique ID number. name = theName; nextUniqueID++; ID = nextUniqueID; } public String getName() { // Getter method for reading the value of the private // instance variable, name. return name; } public int getID() { // Getter method for reading the value of ID. return ID; } public double getAverage() { // Compute average test grade.

219 CHAPTER 5. OBJECTS AND CLASSES 206 return (test1 + test2 + test3) / 3; } } // end of class Student is a variable, the initialization “ nextUniqueID = 0 ” is done Since static nextUniqueID only once, when the class is first loaded. Whenever a Student object is constructed and the constructor says “ nextUniqueID++; ”, it’s always the same static member variable that is being Student object is created, nextUniqueID becomes 1. When incremented. When the very first the second object is created, nextUniqueID becomes 2. After the third object, it becomes 3. nextUniqueID in the ID And so on. The constructor stores the new value of variable of the object that is being created. Of course, is an instance variable, so every object has its own ID ID automatically get a individual variable. The class is constructed so that each student will ID variable. Furthermore, the ID variable is private , so there is no way different value for its for this variable to be tampered with after the object has bee n created. You are guaranteed, ct will have its own permanent, just by the way the class is designed, that every student obje unique identification number. Which is kind of cool if you thi nk about it. (Unfortunately, if you think about it a bit more, it turns out that the guarantee isn’t quite absolute. The guarantee is valid in programs that use a singl e thread. But, as a preview of the difficulties of parallel programming, I’ll note that in multi -threaded programs, where several things can be going on at the same time, things can get a bit str ange. In a multi-threaded program, it is possible that two threads are creating Student objects at exactly the same time, ber. We’ll come back to this and it becomes possible for both objects to get the same ID num in Subsection 12.1.3 , where you will learn how to fix the problem.) 5.2.3 Garbage Collection So far, this section has been about creating objects. What ab out destroying them? In Java, the destruction of objects takes place automatically. An object exists in the heap, and it can be accessed only throu gh variables that hold f there are no variables that references to the object. What should be done with an object i wo statements (though in reality, refer to it? Such things can happen. Consider the following t !): you’d never do anything like this in consecutive statements Student std = new Student("John Smith"); std = null; Student object is stored in the variable std . But In the first line, a reference to a newly created in the next line, the value of std is changed, and the reference to the Student object is gone. In fact, there are now no references whatsoever to that object, in any variable. So there is no way ot exist. In fact, the memory for the program ever to use the object again! It might as well n occupied by the object should be reclaimed to be used for anot her purpose. garbage collection to reclaim memory occupied by objects Java uses a procedure called that are no longer accessible to a program. It is the responsi bility of the system, not the programmer, to keep track of which objects are “garbage.” In the above example, it was very easy to see that the object had become garbage. Usually, it’s much harder. If an o bject Student has been used for a while, there might be several references t o the object stored in several variables. The object doesn’t become garbage until all thos e references have been dropped. In many other programming languages, it’s the programmer’s responsibility to delete the garbage. Unfortunately, keeping track of memory usage is ve ry error-prone, and many serious

220 CHAPTER 5. OBJECTS AND CLASSES 207 cidently delete an object even program bugs are caused by such errors. A programmer might ac dangling pointer error , and though there are still references to that object. This is cal led a t that is no longer there. Another it leads to problems when the program tries to access an objec type of error is a , where a programmer neglects to delete objects that are no memory leak longer in use. This can lead to filling memory with objects tha t are completely inaccessible, and the program might run out of memory even though, in fact, l arge amounts of memory are being wasted. Because Java uses garbage collection, such errors are simpl y impossible. Garbage collection is an old idea and has been used in some programming languages since the 1960s. You might wonder why all languages don’t use garbage collection. In th e past, it was considered too slow and wasteful. However, research into garbage collection te chniques combined with the incredible speed of modern computers have combined to make garbage coll ection feasible. Programmers should rejoice. 5.3 Programming with Objects T in which object-oriented concepts can be applied to the proc ess here are several ways of designing and writing programs. The broadest of these is object-oriented analysis and design which applies an object-oriented methodology to the earlie st stages of program devel- ed. Here, the idea is to identify opment, during which the overall design of a program is creat n another level, object-oriented things in the problem domain that can be modeled as objects. O programming encourages programmers to produce generalized software components that can be used in a wide variety of programming projects. Of course, for the most part, you will experience “generaliz ed software components” by using the standard classes that come along with Java. We begi n this section by looking at some built-in classes that are used for creating objects. At the e nd of the section, we will get back to generalities. 5.3.1 Some Built-in Classes ally on the design and implementa- Although the focus of object-oriented programming is gener igners of Java have already provided tion of new classes, it’s important not to forget that the des a large number of reusable classes. Some of these classes are meant to be extended to produce new classes, while others can be used directly to create usef ul objects. A true mastery of Java requires familiarity with a large number of built-in classe s—something that takes a lot of time and experience to develop. Let’s take a moment to look at a few built-in classes that you might find useful. A string can be built up from smaller pieces using the + operator, but this is not always effi- cient. If str is a String and ch is a character, then executing the command “ str = str + ch; ” involves creating a whole new string that is a copy of , with the value of ch appended onto str the end. Copying the string takes some time. Building up a lon g string letter by letter would require a surprising amount of processing. The class StringBuilder makes it possible to be ef- ficient about building up a long string from a number of smalle r pieces. To do this, you must make an object belonging to the class. For example: StringBuilder StringBuilder builder = new StringBuilder(); (This statement both declares the variable builder and initializes it to refer to a newly created StringBuilder object. Combining declaration with initialization was cov ered in Subsection 4.7.1

221 CHAPTER 5. OBJECTS AND CLASSES 208 and works for objects just as it does for primitive types.) Like a StringBuilder contains a sequence of characters. However, it is possible String , a without continually making copies to add new characters onto the end of a StringBuilder builder is the variable of the data that it already contains. If is a value of any type and x x , converted into a string builder.append(x) defined above, then the command will add representation, onto the end of the data that was already in t he builder. This can be done more efficiently than copying the data every time something is appe nded. A long string can be built using a sequence of StringBuilder commands. When the string is complete, up in a append() will return a copy of the string in the builder as an ordinary builder.toString() the function value of type . The StringBuilder class is in the standard package java.lang , so you can String use its simple name without importing it. java.util A number of useful classes are collected in the package . For example, this jects. We will study such collection package contains classes for working with collections of ob classes extensively in java.util.Date Chapter 10 , is used to . Another class in this package, object is constructed without parameters, the result repre represent times. When a Date sents mation is: the current date and time, so an easy way to display this infor System.out.println( new Date() ); java.util , in order to use the Date Of course, since it is in the package class in your program, you must make it available by importing it with one of the statements import java.util.Date; import java.util.*; ” at the beginning of your program. “ ” or “ Subsection 4.5.3 .) import for a discussion of packages and (See I will also mention the class java.util.Random . An object belonging to this class is a source of random numbers (or, more precisely pseudorandom numbers ). The standard function Math.random() uses one of these objects behind the scenes to generate its ra ndom numbers. Random can generate random integers, as well as random real numbers An object of type . If is created with the command: randGen Random randGen = new Random(); and if is a positive integer, then randGen.nextInt(N) generates a random integer in the range N 0 to N-1 . For example, this makes it a little easier to roll a pair of di ce. Instead of say- from die1 = (int)(6*Math.random())+1; ing “ die1 = randGen.nextInt(6)+1; ”. ”, one can say “ java.util.Random object, you Random (Since you also have to import the class and create the Random might not agree that it is actually easier.) An object of type can also be used to generate so-called Gaussian distributed random real numbers. Many of Java’s standard classes are used in GUI programming. You will encounter a number of them in the Chapter 6 . Here, I will mention only the class Color , from the package java.awt , so that I can use it in the next example. A Color object represents a color that can be used for drawing. In Section 3.9 Color.RED . These constants , you encountered color constants such as Color are final, static member variables in the Color . It class, and their values are objects of type is also possible to create new color objects. Class Color has several constructors. One of them, which is called as new Color(r,g,b) , takes three integer parameters to specify the red, green, and blue components of the color. The parameters must be in th e range 0 to 255. Another constructor, new Color(r,g,b,t) , adds a fourth integer parameter, which must also be in the range 0 to 255. The fourth parameter determines how transpar ent or opaque the color is. When you draw with a transparent color, the background shows thro ugh the color to some extent. A larger value of the parameter t gives a color that is less transparent and more opaque. (If you know hexadecimal color codes, there is a constructor for you. It takes one parameter of

222 CHAPTER 5. OBJECTS AND CLASSES 209 int that encodes all the color components. For example, creates a type new Color(0x8B5413) brown color.) Color se. Mainly, there A object has only a few instance methods that you are likely to u are functions like getRed() to get the individual color components of the color. There ar e no is an immutable “setter” methods to change the color components. In fact, a Color object, final and cannot be changed after the object is meaning that all of its instance variables are created. Strings are another example of immutable objects, and we will make so me of our own later in this section. The main point of all this, again, is that many problems have a lready been solved, and the solutions are available in Java’s standard classes. If you a re faced with a task that looks like a Java reference to see whether it should be fairly common, it might be worth looking through someone has already written a class that you can use. 5.3.2 The class “Object” oriented programming is the We have already seen that one of the major features of object- ability to create subclasses of a class. The subclass inheri ts all the properties or behaviors of the class, but can modify and add to what it inherits. In Section 5.5 , you’ll learn how to create subclasses. What you don’t know yet is that class in Java (with just one exception) is every a subclass of some other class. If you create a class and don’t explicitly make it a subclass of some other class, then it automatically becomes a subclass o f the special class named Object . ( Object is the one class that is not a subclass of any other class.) Class Object defines several instance methods that are inherited by every other class. These methods can be used with any object whatsoever. I will mentio n just one of them here. You will encounter more of them later in the book. The instance method Object returns a value of type String that is in class toString() already used this method implicitly, supposed to be a string representation of the object. You’ve any time you’ve printed out an object or concatenated an obje ct onto a string. When you use tomatically converted to type an object in a context that requires a string, the object is au by calling its String method. toString() toString that is defined in The version of just returns the name of the class that Object the object belongs to, concatenated with a code number calle d the hash code of the object; this is not very useful. When you create a class, you can write a new toString() method for it, which will replace the inherited version. For example, w e might add the following method PairOfDice to any of the classes from the previous section: /** * Return a String representation of a pair of dice, where die1 * and die2 are instance variables containing the numbers tha t are * showing on the two dice. */ public String toString() { if (die1 == die2) return "double " + die1; else return die1 + " and " + die2; } If dice refers to a PairOfDice object, then dice.toString() will return strings such as “3 and 6”, “5 and 1”, and “double 2”, depending on the numbers s howing on the dice. This

223 CHAPTER 5. OBJECTS AND CLASSES 210 dice to type in a statement such as method would be used automatically to convert String System.out.println( "The dice came up " + dice ); he dice came up double 2”. so this statement might output, “The dice came up 5 and 1” or “T toString() method in the next section. You’ll see another example of a 5.3.3 Writing and Using a Class e same animation framework As an example, we will write an animation program, based on th Subsection 3.9.3 . The animation shows a number of semi-transparent disk that was used in m colors and locations. When a that grow in size as the animation plays. The disks have rando disk gets too big, or sometimes just at random, the disk disap pears and is replaced with a new am: disk at a random location. Here is a screenshot from the progr A disk in this program can be represented as an object. A disk h as properties—color, location, and size—that can be instance variables in the object. As for instance methods, we need to think about what we might want to do with a disk. An obvious candidat e is that we need to be able to draw it, so we can include an instance method draw(g) g is a graphics context that will , where e constructors. A constructor be used to do the drawing. The class can also include one or mor initializes the object. It’s not always clear what data shou ld be provided as parameters to the constructors. In this case, as an example, the constructor’ s parameters specify the location and size for the circle, but the constructor makes up a color usin g random values for the red, green, and blue components. Here’s the complete class: import java.awt.Color; // import some standard GUI classes import java.awt.Graphics; /** olored disk, * A simple class that holds the size, color, and location of a c * with a method for drawing the filled circle in a graphics con text. The * circle is drawn as a filled oval, with a black outline. */ public class CircleInfo { public int radius; // The radius of the circle. public int x,y; // The location of the center of the circle. public Color color; // The color of the circle. /** * Create a CircleInfo with a given location and radius and wit h a

224 CHAPTER 5. OBJECTS AND CLASSES 211 * randomly selected, semi-transparent color. * @param centerX The x coordinate of the center. * @param centerY The y coordinate of the center. * @param rad The radius of the circle. */ public CircleInfo( int centerX, int centerY, int rad ) { x = centerX; y = centerY; radius = rad; int red = (int)(255*Math.random()); int green = (int)(255*Math.random()); int blue = (int)(255*Math.random()); color = new Color(red,green,blue, 100); } /** * Draw the disk in graphics context g, with a black outline. */ public void draw( Graphics g ) { g.setColor( color ); g.fillOval( x - radius, y - radius, 2*radius, 2*radius ); g.setColor( Color.BLACK ); g.drawOval( x - radius, y - radius, 2*radius, 2*radius ); } } It would probably be better style to write getters and setter s for the instance variables, but to keep things simple, I made them public. GrowingCircleAnimation . The program uses The main program for my animation is a class CircleInfo . To make that manageable, the 100 disks, each one represented by an object of type program uses an array of objects. The array variable is a memb er variable in the class: private CircleInfo[] circleData; // holds the data for all 1 00 circles Note that it is not static . GUI programming generally uses objects rather than static variables and methods. Basically, this is because we can imagine havin g several GrowingCircleAnimations h animation would be repre- going on at the same time, each with its own array of disks. Eac circleData instance variable. sented by an object, and each object will need to have its own circleData If ons would show were static, there would only be one array and all the animati exactly the same thing. The array must be created and filled with data. The array is cre ated using new CircleInfo[100] , and then 100 objects of type CircleInfo are created to fill the array. The new objects are created with random locations and sizes. In the program, this is done before drawing the first frame of the animation. Here is the co de, where width and height are the size of the drawing area: circleData = new CircleInfo[100]; // create the array for (int i = 0; i < circleData.length; i++) { // create the obje cts circleData[i] = new CircleInfo( (int)(width*Math.random()), (int)(height*Math.random()), (int)(100*Math.random()) ); }

225 CHAPTER 5. OBJECTS AND CLASSES 212 is drawn using the code In each frame, the radius of the disk is increased and the disk circleData[i].radius++; circleData[i].draw(g); w, is an ele- circleData[i] These statements look complicated, so let’s unpack them. No ment of the array circleData . That means that it is a variable of type CircleInfo . This , which contains a public instance variable named variable refers to an object of type CircleInfo circleData[i].radius is the full name for that variable. Since it . This means that radius is a variable of type int , we can use the ++ operator to increment its value. So the effect of circleData[i].radius++ of code is to increase the radius of the circle by one. The second line is similar, but in that statement, is an instance method in the CircleInfo circleData[i].draw circleData[i].draw(g) g . object. The statement calls that instance method with parameter The source code example contains the full source code for the CircleInfo program, if you are interested. Since the program uses class , you will also need a copy of in order to compile and run the program. 5.3.4 Object-oriented Analysis and Design Every programmer builds up a stock of techniques and experti se expressed as snippets of code that can be reused in new programs using the tried-and-true m ethod of cut-and-paste: The old code is physically copied into the new program and then edite d to customize it as necessary. The problem is that the editing is error-prone and time-cons uming, and the whole enterprise is cular piece of code from last year’s dependent on the programmer’s ability to pull out that parti project that looks like it might be made to fit. (On the level of a corporation that wants to just keeping track of all the old save money by not reinventing the wheel for each new project, wheels becomes a major task.) eused without editing. A well- Well-designed classes are software components that can be r designed class is not carefully crafted to do a particular jo b in a particular program. Instead, it is crafted to model some particular type of object or a sing le coherent concept. Since objects and concepts can recur in many problems, a well-designed cla ss is likely to be reusable without modification in a variety of projects. Furthermore, in an object-oriented programming language, it is possible to make subclasses of an existing class. This makes classes even more reusable. If a class needs to be customized, a subclass can be created, and additions or modifications can be made in the subclass without making any changes to the original class. This can be done eve n if the programmer doesn’t have access to the source code of the class and doesn’t know an y details of its internal, hidden implementation. ∗ ∗ ∗ The PairOfDice class in the previous section is already an example of a gener alized software component, although one that could certainly be improved. T he class represents a single, coherent concept, “a pair of dice.” The instance variables h old the data relevant to the state of the dice, that is, the number showing on each of the dice. Th e instance method represents the behavior of a pair of dice, that is, the ability to be rolle d. This class would be reusable in many different programming projects. On the other hand, the Student class from the previous section is not very reusable. It seems to be crafted to represent students in a particular cou rse where the grade will be based on three tests. If there are more tests or quizzes or papers, i t’s useless. If there are two people in the class who have the same name, we are in trouble (one reas on why numerical student ID’s

226 CHAPTER 5. OBJECTS AND CLASSES 213 op a general-purpose student class are often used). Admittedly, it’s much more difficult to devel Student class is good mostly as than a general-purpose pair-of-dice class. But this partic ular an example in a programming textbook. ∗ ∗ ∗ A large programming project goes through a number of stages, specification starting with of the problem and of the problem to be solved, followed by of a program analysis design coding , in which the program’s design is expressed in some actual to solve it. Then comes testing and debugging programming language. This is followed by of the program. After that comes a long period of , which means fixing any new problems that are found maintenance ements. Together, these stages in the program and modifying it to adapt it to changing requir software life cycle . (In the real world, the ideal of consecutive stages form what is called the is seldom if ever achieved. During the analysis stage, it mig ht turn out that the specifications ing requires at least a brief return are incomplete or inconsistent. A problem found during test t even require a new design. to the coding stage. If the problem is serious enough, it migh Maintenance usually involves redoing some of the work from p revious stages. . . .) Large, complex programming projects are only likely to succ eed if a careful, systematic approach is adopted during all stages of the software life cy cle. The systematic approach to programming, using accepted principles of good design, is c alled software engineering . The software engineer tries to efficiently construct programs th at verifiably meet their specifications of “methodologies” that can and that are easy to modify if necessary. There is a wide range t of these methodologies seem to be applied to help in the systematic design of programs. (Mos involve drawing little boxes to represent program componen ts, with labeled arrows to represent relationships among the boxes.) We have been discussing object orientation in programming l anguages, which is relevant to the coding stage of program development. But there are also o bject-oriented methodologies for analysis and design. The question in this stage of the softwa re life cycle is, How can one discover or invent the overall structure of a program? As an example of a rather simple object-oriented approach to analysis and design, consider this advice: Writ e down a description of the problem. Underline all the nouns in that description. The nouns shoul d be considered as candidates for becoming classes or objects in the program design. Similarl y, underline all the verbs. These are candidates for methods. This is your starting point. Fur ther analysis might uncover the need for more classes and methods, and it might reveal that su bclassing can be used to take advantage of similarities among classes. This is perhaps a bit simple-minded, but the idea is clear and the general approach can be effective: Analyze the problem to discover the concepts that are involved, and create classes to represent those concepts. The design should arise from the p roblem itself, and you should end up with a program whose structure reflects the structure of th e problem in a natural way. 5.4 Programming Example: Card, Hand, Deck In this section, we look at some specific examples of object-o riented design in a domain that is simple enough that we have a chance of coming up with someth ing reasonably reusable. Consider card games that are played with a standard deck of pl aying cards (a so-called “poker” deck, since it is used in the game of poker).

227 CHAPTER 5. OBJECTS AND CLASSES 214 5.4.1 Designing the classes In a typical card game, each player gets a hand of cards. The de ck is shuffled and cards are dealt one at a time from the deck and added to the players’ hand s. In some games, cards can be removed from a hand, and new cards can be added. The game is w on or lost depending on the value (ace, 2, . . . , king) and suit (spades, diamonds, c lubs, hearts) of the cards that a player receives. If we look for nouns in this description, th ere are several candidates for objects: game, player, hand, card, deck, value, and suit. Of these, th e value and the suit of a card are Card object. In a e variables in a simple values, and they might just be represented as instanc complete program, the other five nouns might be represented b y classes. But let’s work on the card , hand , and deck . ones that are most obviously reusable: at we can If we look for verbs in the description of a card game, we see th a deck and shuffle a card from a deck. This gives use us two candidates for instan Deck class: deal ce methods in a shuffle() and dealCard() . Cards can be added to and removed from hands. This gives two Hand candidates for instance methods in a addCard() and removeCard() . Cards are class: relatively passive things, but we at least need to be able to d etermine their suits and values. We will discover more instance methods as we go along. First, we’ll design the deck class in detail. When a deck of ca rds is first created, it contains 52 cards in some standard order. The Deck class will need a constructor to create a new deck. The constructor needs no parameters because any new deck is t he same as any other. There will shuffle() that will rearrange the 52 cards into a random order. be an instance method called instance method will get the next card from the deck. This wil l be a function The dealCard() Card , since the caller needs to know what card is being dealt. It ha s no with a return type of ’t provide any information to parameters—when you deal the next card from the deck, you don happen if there are no more the deck; you just get the next card, whatever it is. What will dealCard() method is called? It should probably be considered an cards in the deck when its error to try to deal a card from an empty deck, so the deck can th row an exception in that case. But this raises another question: How will the rest of the pro gram know whether the deck is empty? Of course, the program could keep track of how many car ds it has used. But the deck itself should know how many cards it has left, so the program s hould just be able to ask the deck object. We can make this possible by specifying another instance method, , cardsLeft() eads to a full specification of all that returns the number of cards remaining in the deck. This l the subroutines in the class: Deck Constructor and instance methods in class Deck: /** * Constructor. Create an unshuffled deck of cards. */ public Deck() /** * Put all the used cards back into the deck, * and shuffle it into a random order. */ public void shuffle() /** * As cards are dealt from the deck, the number of * cards left decreases. This function returns the * number of cards that are still left in the deck. */

228 CHAPTER 5. OBJECTS AND CLASSES 215 public int cardsLeft() /** * Deals one card from the deck and returns it. * @throws IllegalStateException if no more cards are left. */ public Card dealCard() the Deck class. Of course, it doesn’t tell us use This is everything you need to know in order to how to write the class. This has been an exercise in design, no t in coding. You can look at the , if you want. It should not be a surprise that the class includ es an array source code, Cards as an instance variable, but there are a few things you might n ot understand at this of ack box, without understanding point. Of course, you can use the class in your programs as a bl the implementation. We can do a similar analysis for the class. When a hand object is first created, it Hand has no cards in it. An addCard() instance method will add a card to the hand. This method Card needs a parameter of type removeCard() to specify which card is being added. For the method, a parameter is needed to specify which card to remove . But should we specify the card itself (“Remove the ace of spades”), or should we specif y the card by its position in the hand (“Remove the third card in the hand”)? Actually, we don’ t have to decide, since we can allow for both options. We’ll have two removeCard() instance methods, one with a parameter of type Card ype int specifying specifying the card to be removed and one with a parameter of t ve two methods in a class the position of the card in the hand. (Remember that you can ha pes of parameters.) Since a with the same name, provided they have different numbers or ty to be able to ask a hand object hand can contain a variable number of cards, it’s convenient getCardCount() how many cards it contains. So, we need an instance method that returns the number of cards in the hand. When I play cards, I like to arr ange the cards in my hand so that cards of the same value are next to each other. Since this is a generally useful thing to be able to do, we can provide instance methods for sorting the ca rds in the hand. Here is a full specification for a reusable Hand class: Constructor and instance methods in class Hand: /** * Constructor. Create a Hand object that is initially empty. */ public Hand() /** * Discard all cards from the hand, making the hand empty. */ public void clear() /** * Add the card c to the hand. c should be non-null. * @throws NullPointerException if c is null. */ public void addCard(Card c) /** * If the specified card is in the hand, it is removed. */ public void removeCard(Card c)

229 CHAPTER 5. OBJECTS AND CLASSES 216 /** * Remove the card in the specified position from the * hand. Cards are numbered counting from zero. * @throws IllegalArgumentException if the specified * position does not exist in the hand. */ public void removeCard(int position) /** * Return the number of cards in the hand. */ public int getCardCount() /** * Get the card from the hand in given position, where * positions are numbered starting from 0. * @throws IllegalArgumentException if the specified * position does not exist in the hand. */ public Card getCard(int position) /** * Sorts the cards in the hand so that cards of the same * suit are grouped together, and within a suit the cards * are sorted by value. */ public void sortBySuit() /** * Sorts the cards in the hand so that cards are sorted into * order of increasing value. Cards with the same value * are sorted by suit. Note that aces are considered * to have the lowest value. */ public void sortByValue() Again, there are a few things in the implementation of the cla ss that you won’t understand at this point, but that doesn’t stop you from using the class in y our projects. The source code can be found in the file 5.4.2 The Card Class We will look at the design and implementation of a Card class in full detail. The class will have a constructor that specifies the value and suit of the car d that is being created. There are four suits, which can be represented by the integers 0, 1, 2, and 3. It would be tough to remember which number represents which suit, so I’ve defin ed named constants in the Card class to represent the four possibilities. For example, Card.SPADES is a constant that represents the suit, “spades”. (These constants are declared to be . It might public final static ints be better to use an enumerated type, but I will stick here to in teger-valued constants.) The possible values of a card are the numbers 1, 2, . . . , 13, with 1 s tanding for an ace, 11 for a jack, 12 for a queen, and 13 for a king. Again, I’ve defined some named constants to represent the values of aces and face cards. (When you read the Card class, you’ll see that I’ve also added support for Jokers.)

230 CHAPTER 5. OBJECTS AND CLASSES 217 Card object can be constructed knowing the value and the suit of th A e card. For example, we can call the constructor with statements such as: f spades. card1 = new Card( Card.ACE, Card.SPADES ); // Construct ace o onds. card2 = new Card( 10, Card.DIAMONDS ); // Construct 10 of diam card3 = new Card( v, s ); // This is OK, as long as v and s // are integer expressions. object needs instance variables to represent its value and s uit. I’ve made these A Card e provided getter methods private so that they cannot be changed from outside the class, and I’v getSuit() and getValue() so that it will be possible to discover the suit and value from outside the class. The instance variables are initialized in the con structor, and are never changed after that. In fact, I’ve declared the instance variables and value to be final , since they are suit never changed after they are initialized. An instance varia final provided ble can be declared itialized in every constructor in the it is either given an initial value in its declaration or is in final , a Card is an immutable object. class. Since all its instance variables are Finally, I’ve added a few convenience methods to the class to make it easier to print out cards in a human-readable form. For example, I want to be able to print out the suit of a card as the word “Diamonds”, rather than as the meaningless c ode number 2, which is used in the class to represent diamonds. Since this is something t hat I’ll probably have to do in many programs, it makes sense to include support for it in the class. So, I’ve provided instance methods getSuitAsString() getValueAsString() to return string representations of the and thod to return a suit and value of a card. Finally, I’ve defined the instance me toString() string with both the value and suit, such as “Queen of Hearts” . Recall that this method will Card needs to be converted into a String , such as when the be used automatically whenever a + operator. Thus, the statement card is concatenated onto a string with the System.out.println( "Your card is the " + card ); is equivalent to System.out.println( "Your card is the " + card.toString() ) ; If the card is the queen of hearts, either of these will print o ut “Your card is the Queen of Hearts”. Here is the complete Card class. It is general enough to be highly reusable, so the work that went into designing, writing, and testing it pays off handsom ely in the long run. /** * An object of type Card represents a playing card from a * standard Poker deck, including Jokers. The card has a suit, which eart, * can be spades, hearts, diamonds, clubs, or joker. A spade, h * diamond, or club has one of the 13 values: ace, 2, 3, 4, 5, 6, 7, * 8, 9, 10, jack, queen, or king. Note that "ace" is considered to be * the smallest value. A joker can also have an associated valu e; * this value can be anything and can be used to keep track of sev eral * different jokers. */ public class Card { public final static int SPADES = 0; // Codes for the 4 suits, pl us Joker. public final static int HEARTS = 1; public final static int DIAMONDS = 2; public final static int CLUBS = 3;

231 CHAPTER 5. OBJECTS AND CLASSES 218 public final static int JOKER = 4; public final static int ACE = 1; // Codes for the non-numeric c ards. public final static int JACK = 11; // Cards 2 through 10 have th eir public final static int QUEEN = 12; // numerical values for th eir codes. public final static int KING = 13; /** * This card’s suit, one of the constants SPADES, HEARTS, DIAM ONDS, * CLUBS, or JOKER. The suit cannot be changed after the card is * constructed. */ private final int suit; /** * The card’s value. For a normal card, this is one of the values * 1 through 13, with 1 representing ACE. For a JOKER, the value * can be anything. The value cannot be changed after the card * is constructed. */ private final int value; /** * Creates a Joker, with 1 as the associated value. (Note that * "new Card()" is equivalent to "new Card(1,Card.JOKER)".) */ public Card() { suit = JOKER; value = 1; } /** * Creates a card with a specified suit and value. * @param theValue the value of the new card. For a regular card (non-joker), ng an Ace. * the value must be in the range 1 through 13, with 1 representi , and Card.KING. * You can use the constants Card.ACE, Card.JACK, Card.QUEEN * For a Joker, the value can be anything. * @param theSuit the suit of the new card. This must be one of th e values * Card.SPADES, Card.HEARTS, Card.DIAMONDS, Card.CLUBS, o r Card.JOKER. * @throws IllegalArgumentException if the parameter value s are not in the * permissible ranges */ public Card(int theValue, int theSuit) { if (theSuit != SPADES && theSuit != HEARTS && theSuit != DIAMO NDS && theSuit != CLUBS && theSuit != JOKER) d suit"); throw new IllegalArgumentException("Illegal playing car if (theSuit != JOKER && (theValue < 1 || theValue > 13)) throw new IllegalArgumentException("Illegal playing car d value"); value = theValue; suit = theSuit; } /** * Returns the suit of this card. * @returns the suit, which is one of the constants Card.SPADE S, * Card.HEARTS, Card.DIAMONDS, Card.CLUBS, or Card.JOKER

232 CHAPTER 5. OBJECTS AND CLASSES 219 */ public int getSuit() { return suit; } /** * Returns the value of this card. * @return the value, which is one of the numbers 1 through 13, i nclusive for * a regular card, and which can be any value for a Joker. */ public int getValue() { return value; } /** * Returns a String representation of the card’s suit. * @return one of the strings "Spades", "Hearts", "Diamonds" , "Clubs" * or "Joker". */ public String getSuitAsString() { switch ( suit ) { case SPADES: return "Spades"; case HEARTS: return "Hearts"; case DIAMONDS: return "Diamonds"; case CLUBS: return "Clubs"; default: return "Joker"; } } /** * Returns a String representation of the card’s value. * @return for a regular card, one of the strings "Ace", "2", * "3", ..., "10", "Jack", "Queen", or "King". For a Joker, the * string is always numerical. */ public String getValueAsString() { if (suit == JOKER) return "" + value; else { switch ( value ) { case 1: return "Ace"; case 2: return "2"; case 3: return "3"; case 4: return "4"; case 5: return "5"; case 6: return "6"; case 7: return "7"; case 8: return "8"; case 9: return "9"; case 10: return "10"; case 11: return "Jack"; case 12: return "Queen"; default: return "King"; } }

233 CHAPTER 5. OBJECTS AND CLASSES 220 } /** * Returns a string representation of this card, including bo th * its suit and its value (except that for a Joker with value 1, * the return value is just "Joker"). Sample return values * are: "Queen of Hearts", "10 of Diamonds", "Ace of Spades", * "Joker", "Joker #2" */ public String toString() { if (suit == JOKER) { if (value == 1) return "Joker"; else return "Joker #" + value; } else return getValueAsString() + " of " + getSuitAsString(); } } // end class Card 5.4.3 Example: A Simple Card Game at uses the Card and Deck classes. I will finish this section by presenting a complete program th ighLow. A deck of cards is The program lets the user play a very simple card game called H shuffled, and one card is dealt from the deck and shown to the use r. The user predicts whether the next card from the deck will be higher or lower than the cur rent card. If the user predicts correctly, then the next card from the deck becomes the curre nt card, and the user makes another prediction. This continues until the user makes an i ncorrect prediction. The number of correct predictions is the user’s score. My program has a static method that plays one game of HighLow. This method has a e main() routine lets the user play return value that represents the user’s score in the game. Th erage score. several games of HighLow. At the end, it reports the user’s av I won’t go through the development of the algorithms used in t his program, but I encourage you to read it carefully and make sure that you understand how it works. Note in particular that the subroutine that plays one game of HighLow returns th e user’s score in the game as its return value. This gets the score back to the main program, wh ere it is needed. Here is the program: /** * This program lets the user play HighLow, a simple card game * that is described in the output statements at the beginning of * the main() routine. After the user plays several games, * the user’s average score is reported. */ public class HighLow { public static void main(String[] args) { System.out.println("This program lets you play the simple card game,"); System.out.println("HighLow. A card is dealt from a deck of cards.");

234 CHAPTER 5. OBJECTS AND CLASSES 221 ard will be"); System.out.println("You have to predict whether the next c System.out.println("higher or lower. Your score in the gam e is the"); ke before"); System.out.println("number of correct predictions you ma System.out.println("you guess wrong."); System.out.println(); int gamesPlayed = 0; // Number of games user has played. int sumOfScores = 0; // The sum of all the scores from // all the games played. double averageScore; // Average score, computed by dividin g // sumOfScores by gamesPlayed. boolean playAgain; // Record user’s response when user is // asked whether he wants to play // another game. do { int scoreThisGame; // Score for one game. scoreThisGame = play(); // Play the game and get the score. sumOfScores += scoreThisGame; gamesPlayed++; System.out.print("Play again? "); playAgain = TextIO.getlnBoolean(); } while (playAgain); averageScore = ((double)sumOfScores) / gamesPlayed; System.out.println(); System.out.println("You played " + gamesPlayed + " games." ); rageScore); System.out.printf("Your average score was %1.3f.\n", ave } // end main() /** * Lets the user play one game of HighLow, and returns the * user’s score in that game. The score is the number of * correct guesses that the user makes. */ private static int play() { Deck deck = new Deck(); // Get a new deck of cards, and // store a reference to it in // the variable, deck. Card currentCard; // The current card, which the user sees. Card nextCard; // The next card in the deck. The user tries // to predict whether this is higher or lower // than the current card. int correctGuesses ; // The number of correct predictions th e // user has made. At the end of the game, // this will be the user’s score. char guess; // The user’s guess. ’H’ if the user predicts that // the next card will be higher, ’L’ if the user // predicts that it will be lower. deck.shuffle(); // Shuffle the deck into a random order befo re

235 CHAPTER 5. OBJECTS AND CLASSES 222 // starting the game. correctGuesses = 0; currentCard = deck.dealCard(); System.out.println("The first card is the " + currentCard) ; while (true) { // Loop ends when user’s prediction is wrong. /* Get the user’s prediction, ’H’ or ’L’ (or ’h’ or ’l’). */ System.out.print("Will the next card be higher (H) or lower (L)? "); do { guess = TextIO.getlnChar(); guess = Character.toUpperCase(guess); if (guess != ’H’ && guess != ’L’) System.out.print("Please respond with H or L: "); } while (guess != ’H’ && guess != ’L’); /* Get the next card and show it to the user. */ nextCard = deck.dealCard(); System.out.println("The next card is " + nextCard); /* Check the user’s prediction. */ if (nextCard.getValue() == currentCard.getValue()) { System.out.println("The value is the same as the previous c ard."); System.out.println("You lose on ties. Sorry!"); break; // End the game. } else if (nextCard.getValue() > currentCard.getValue()) { if (guess == ’H’) { System.out.println("Your prediction was correct."); correctGuesses++; } else { System.out.println("Your prediction was incorrect."); break; // End the game. } } else { // nextCard is lower if (guess == ’L’) { System.out.println("Your prediction was correct."); correctGuesses++; } else { System.out.println("Your prediction was incorrect."); break; // End the game. } } /* To set up for the next iteration of the loop, the nextCard becomes the currentCard, since the currentCard has to be the card that the user sees, and the nextCard will be set to the next card in the deck after the user makes his prediction. */ currentCard = nextCard;

236 CHAPTER 5. OBJECTS AND CLASSES 223 System.out.println(); System.out.println("The card is " + currentCard); } // end of while loop System.out.println(); System.out.println("The game is over."); System.out.println("You made " + correctGuesses + " correct predictions."); System.out.println(); return correctGuesses; } // end play() } // end class HighLow 5.5 Inheritance, Polymorphism, and Abstract Classes which share the same structure and behaviors. A class represents a set of objects The class determines the structure of objects by specifying variables that are contained in each instance of the class, and it determines behavior by providi ng the instance methods that express , something like this can be done the behavior of the objects. This is a powerful idea. However t-oriented programming—the in most programming languages. The central new idea in objec ming—is to allow classes to express idea that really distinguishes it from traditional program some , but not all, of their structure and behavior. the similarities among objects that share inheritance and polymorphism Such similarities can be expressed using . 5.5.1 Extending Existing Classes The topics covered in later subsections of this section are r elatively advanced aspects of object- oriented programming. Any programmer should know what is me ant by subclass, inheritance, and polymorphism. However, it will probably be a while befor e you actually do anything with inheritance except for extending classes that already exis t. In the first part of this section, we look at how that is done. In day-to-day programming, especially for programmers who are just beginning to work here is an existing class that can be with objects, subclassing is used mainly in one situation: T mon than designing groups of adapted with a few changes or additions. This is much more com classes and subclasses from scratch. The existing class can be extended to make a subclass. The syntax for this is public class subclass-name 〉 extends 〈 existing-class-name 〉 { 〈 . . // Changes and additions. . } As an example, suppose you want to write a program that plays t he card game, Blackjack. Section 5.4 . However, a hand in the , Hand , and Deck classes developed in You can use the Card game of Blackjack is a little different from a hand of cards in g eneral, since it must be possible to compute the “value” of a Blackjack hand according to the ru les of the game. The rules are as follows: The value of a hand is obtained by adding up the val ues of the cards in the hand.

237 CHAPTER 5. OBJECTS AND CLASSES 224 cal value. The value of a Jack, The value of a numeric card such as a three or a ten is its numeri Queen, or King is 10. The value of an Ace can be either 1 or 11. An Ace should be counted 21. Note that this means that as 11 unless doing so would put the total value of the hand over the second, third, or fourth Ace in the hand will always be cou nted as 1. class by adding a method that One way to handle this is to extend the existing Hand computes the Blackjack value of the hand. Here’s the definiti on of such a class: public class BlackjackHand extends Hand { /** * Computes and returns the value of this hand in the game * of Blackjack. */ public int getBlackjackValue() { int val; // The value computed for the hand. boolean ace; // This will be set to true if the // hand contains an ace. int cards; // Number of cards in the hand. val = 0; ace = false; cards = getCardCount(); // (method defined in class Hand.) for ( int i = 0; i < cards; i++ ) { // Add the value of the i-th card in the hand. Card card; // The i-th card; int cardVal; // The blackjack value of the i-th card. card = getCard(i); cardVal = card.getValue(); // The normal value, 1 to 13. if (cardVal > 10) { cardVal = 10; // For a Jack, Queen, or King. } if (cardVal == 1) { ace = true; // There is at least one ace. } val = val + cardVal; } // Now, val is the value of the hand, counting any ace as 1. // If there is an ace, and if changing its value from 1 to // 11 would leave the score less than or equal to 21, // then do so by adding the extra 10 points to val. if ( ace == true && val + 10 <= 21 ) val = val + 10; return val; } // end getBlackjackValue() } // end class BlackjackHand Since BlackjackHand is a subclass of Hand , an object of type BlackjackHand contains all the instance variables and instance methods defined in , plus the new in- Hand stance method named getBlackjackValue() . For example, if bjh is a variable of type BlackjackHand , then the following are all legal: bjh.getCardCount() , bjh.removeCard(0) ,

238 CHAPTER 5. OBJECTS AND CLASSES 225 bjh.getBlackjackValue() . The first two methods are defined in , but are inherited and Hand . by BlackjackHand BlackjackHand , and they can Hand Variables and methods from the class are inherited by just as if they were actually defined in that class— BlackjackHand be used in the definition of , which prevents access even by subclasses. The except for any that are declared to be private ” in the above definition of cards = getCardCount(); calls statement “ getBlackjackValue() , which was defined in getCardCount() . the instance method Hand Extending existing classes is an easy way to build on previou s work. We’ll see that many standard classes have been written specifically to be used as the basis for making subclasses. ∗ ∗ ∗ public and are used to control access to members of a Access modifiers such as private , that comes into the picture when subclasses protected class. There is one more access modifier, protected is applied as an access modifier to a method or are taken into consideration. When member variable in a class, that member can be used in subclas ses—direct or indirect—of the asses. (There is an exception: class in which it is defined, but it cannot be used in non-subcl protected A the class that member can also be accessed by any class in the same package as odifier makes a member accessible contains the protected member. Recall that using no access m to classes in the same package, and nowhere else. Using the modifier is strictly more protected liberal than using no modifier at all: It allows access from cl asses in the same package and from subclasses that are not in the same package.) When you declare a method or member variable to be protected , you are saying that it is part of the implementation of the class, rather than part o f the public interface of the class. art of the implementation. However, you are allowing subclasses to use and modify that p class that has instance variables die1 and die2 PairOfDice For example, consider a to e those variables private to represent the numbers appearing on the two dice. We could mak ass, while still allowing read access make it impossible to change their values from outside the cl t through getter methods. However, if we think it possible tha will be used to create PairOfDice to change the numbers on the dice. subclasses, we might want to make it possible for subclasses For example, a GraphicalDice subclass that draws the dice might want to change the numbers at other times besides when the dice are rolled. In that case, we could make die1 and die2 protected , which would allow the subclass to change their values witho ut making them public to the rest of the world. (An even better idea would be to define protected setter methods for at the value that is being assigned the variables. A setter method could, for example, ensure th to the variable is in the legal range 1 through 6.) 5.5.2 Inheritance and Class Hierarchy inheritance refers to the fact that one class can inherit part or all of its The term structure and behavior from another class. The class that does the inhe riting is said to be a subclass of the class from which it inherits. If class B is a subclass of cl ass A, we also say that class A is a superclass derived class and base class are used instead of class B. (Sometimes the terms of subclass and superclass; this is the common terminology i n C++.) A subclass can add to the structure and behavior that it inherits. It can also replace or modify inherited behavior (though not inherited structure). The relationship between subcla ss and superclass is sometimes shown by a diagram in which the subclass is shown below, and connect ed to, its superclass, as shown on the left below:

239 CHAPTER 5. OBJECTS AND CLASSES 226 class A class A (superclass) class C class B class D  c  (subclass) class E In Java, to create a class named “B” as a subclass of a class nam ed “A”, you would write class B extends A { . . // additions to, and modifications of, . // stuff inherited from class A . } erclass. The subclasses, which Several classes can be declared as subclasses of the same sup might be referred to as “sibling classes,” share some struct ures and behaviors—namely, the ones they inherit from their common superclass. The superclass e xpresses these shared structures and behaviors. In the diagram shown on the right above, class es B, C, and D are sibling classes. Inheritance can also extend over several “generations” of c lasses. This is shown in the diagram, s of class A. In this case, class E where class E is a subclass of class D which is itself a subclas a direct subclass. This whole set is considered to be a subclass of class A, even though it is not of classes forms a small class hierarchy . 5.5.3 Example: Vehicles Let’s look at an example. Suppose that a program has to deal wi th motor vehicles, including cars, trucks, and motorcycles. (This might be a program used by a Department of Motor Vehicles to keep track of registrations.) The program could use a class named Vehicle to represent all types of vehicles. Since cars, trucks, and mot orcycles are types of vehicles, they would be represented by subclasses of the Vehicle class, as shown in this class hierarchy diagram: V e   e T  C M   e  Vehicle The registrationNumber and owner and class would include instance variables such as instance methods such as transferOwnership() . These are variables and methods common to all vehicles. The three subclasses of Vehicle — Car , Truck , and Motorcycle —could then be used to hold variables and methods specific to particular typ es of vehicles. The class Car numberOfDoors might add an instance variable Truck class might have numberOfAxles , , the and the Motorcycle class could have a boolean variable hasSidecar . (Well, it could in theory at least, even if it might give a chuckle to the people at the De partment of Motor Vehicles.) The declarations of these classes in a Java program would loo k, in outline, like this (although they are likely to be defined in separate files and declared as public classes):

240 CHAPTER 5. OBJECTS AND CLASSES 227 class Vehicle { int registrationNumber; Person owner; // (Assuming that a Person class has been defin ed!) void transferOwnership(Person newOwner) { . . . } . . . } class Car extends Vehicle { int numberOfDoors; . . . } class Truck extends Vehicle { int numberOfAxles; . . . } class Motorcycle extends Vehicle { boolean hasSidecar; . . . } Suppose that is a variable of type Car that has been declared and initialized with the myCar statement Car myCar = new Car(); Given this declaration, a program could refer to , since numberOfDoors myCar.numberOfDoors Car . But since class Car is an instance variable in the class Vehicle , a car also extends class has all the structure and behavior of a vehicle. This means th at myCar.registrationNumber , myCar.owner , and myCar.transferOwnership() also exist. Now, in the real world, cars, trucks, and motorcycles are in f act vehicles. The same is true Car Truck or Motorcycle is automatically an object in a program. That is, an object of type or of type Vehicle too. This brings us to the following Important Fact: A variable that can hold a reference to an object of class A can also hold a reference to an object belonging to any subclass of A. The practical effect of this in our example is that an object of type Car can be assigned to a variable of type Vehicle . That is, it would be legal to say Vehicle myVehicle = myCar; or even Vehicle myVehicle = new Car(); myVehicle holds a reference to a Vehicle object After either of these statements, the variable that happens to be an instance of the subclass, Car . The object “remembers” that it is in fact a Car , and not just a Vehicle . Information about the actual class of an object is stored as part of that object. It is even possible to test whether a given obj ect belongs to a given class, using the instanceof operator. The test: if (myVehicle instanceof Car) ...

241 CHAPTER 5. OBJECTS AND CLASSES 228 myVehicle is in fact a car. determines whether the object referred to by On the other hand, the assignment statement myCar = myVehicle; would be illegal because could potentially refer to other types of vehicles that are myVehicle Subsection 2.5.6 : The computer not cars. This is similar to a problem we saw previously in value to a variable of type short , because not every int will not allow you to assign an int is a . Similarly, it will not allow you to assign a value of type to a variable of type Car short Vehicle and shorts , the solution here is to use because not every vehicle is a car. As in the case of ints type-casting. If, for some reason, you happen to know that does in fact refer to a myVehicle Car (Car)myVehicle to tell the computer to treat myVehicle as if , you can use the type cast Car it were actually of type . So, you could say myCar = (Car)myVehicle; and you could even refer to ((Car)myVehicle).numberOfDoors . (The parentheses are . ” has higher precedence than the type-cast, so necessary because of precedence. The “ (Car)myVehicle.numberOfDoors (Car)(myVehicle.numberOfDoors) , an at- would be read as tempt to type-cast the int myVehicle.numberOfDoors into a Vehicle , which is impossible.) As an example of how this could be used in a program, suppose th at you want to print out relevant data about the Vehicle myVehicle . If it’s a Car , you will want to print referred to by numberOfDoors myVehicle.numberOfDoors , since there is no out the car’s , but you can’t say in the Vehicle class. But you could say: numberOfDoors System.out.println("Vehicle Data:"); System.out.println("Registration number: " + myVehicle.registrationNumber); if (myVehicle instanceof Car) { System.out.println("Type of vehicle: Car"); Car c; c = (Car)myVehicle; // Type-cast to get access to numberOfDo ors! System.out.println("Number of doors: " + c.numberOfDoors ); } else if (myVehicle instanceof Truck) { System.out.println("Type of vehicle: Truck"); Truck t; t = (Truck)myVehicle; // Type-cast to get access to numberOf Axles! ); System.out.println("Number of axles: " + t.numberOfAxles } else if (myVehicle instanceof Motorcycle) { System.out.println("Type of vehicle: Motorcycle"); Motorcycle m; m = (Motorcycle)myVehicle; // Type-cast to get access to has Sidecar! System.out.println("Has a sidecar: " + m.hasSidecar); } Note that for object types, when the computer executes a prog ram, it checks whether type-casts are valid. So, for example, if myVehicle refers to an object of type Truck , then the type cast (Car)myVehicle would be an error. When this happens, an exception of type ClassCastException is thrown. This check is done at run time, not compile time, be cause the actual type of the object referred to by myVehicle is not known when the program is compiled.

242 CHAPTER 5. OBJECTS AND CLASSES 229 5.5.4 Polymorphism As another example, consider a program that deals with shape s drawn on the screen. Let’s say that the shapes include rectangles, ovals, and roundrects o f various colors. (A “roundrect” is just a rectangle with rounded corners.) Ovals RoundRects Rectangles Three classes, Oval , and RoundRect , could be used to represent the three types of Rectangle , Shape shapes. These three classes would have a common superclass, , to represent features that all three shapes have in common. The class could include instance variables to represent Shape instance methods for changing the the color, position, and size of a shape, and it could include , might involve changing the value values of those properties. Changing the color, for example ew color: of an instance variable, and then redrawing the shape in its n class Shape { Color color; // (must be imported from package java.awt) void setColor(Color newColor) { // Method to change the color of the shape. color = newColor; // change value of instance variable redraw(); // redraw shape, which will appear in new color } void redraw() { // method for drawing the shape ? ? ? // what commands should go here? } . . . // more instance variables and methods } // end of class Shape Now, you might see a problem here with the method redraw() . The problem is that each different type of shape is drawn differently. The method can be called for any type setColor() of shape. How does the computer know which shape to draw when i t executes the redraw() ? Informally, we can answer the question like this: The comput er executes redraw() by asking the shape to redraw . Every shape object knows what it has to do to redraw itself. itself In practice, this means that each of the specific shape classe s has its own redraw() method: class Rectangle extends Shape { void redraw() { . . . // commands for drawing a rectangle } . . . // possibly, more methods and variables } class Oval extends Shape { void redraw() {

243 CHAPTER 5. OBJECTS AND CLASSES 230 . . . // commands for drawing an oval } . . . // possibly, more methods and variables } class RoundRect extends Shape { void redraw() { . . . // commands for drawing a rounded rectangle } . . . // possibly, more methods and variables } Suppose that someShape Shape . Then it could refer to an object is a variable of type , Oval , or RoundRect . As a program executes, and the value of of any of the types Rectangle changes, it could even refer to objects of different types at d ifferent times! Whenever someShape the statement someShape.redraw(); one appropriate for the type of is executed, the redraw method that is actually called is the someShape at the object to which actually refers. There may be no way of telling, from looking text of the program, what shape this statement will draw, sin ce it depends on the value that someShape happens to have when the program is executed. Even more is tru e. Suppose the ue of someShape statement is in a loop and gets executed many times. If the val changes as the loop is executed, it is possible that the very same statement someShape.redraw(); ” will call “ different methods and draw different shapes as it is executed o ver and over. We say that the redraw() method is polymorphic . A method is polymorphic if the action performed by the method depends on the actual type of the object to which the me thod is applied. Polymorphism is one of the major distinguishing features of object-orien ted programming. This can be seen that is an a variable most vividly, perhaps, if we have an array of shapes. Suppose shapelist of type Shape[ ] , and that the array has already been created and filled with da ta. Some of the Rectangles , some might be Ovals , and some might be elements in the array might be . RoundRects We can draw all the shapes in the array by saying for (int i = 0; i < shapelist.length; i++ ) { Shape shape = shapelist[i]; shape.redraw(); } shape.redraw() will sometimes draw As the computer goes through this loop, the statement a rectangle, sometimes an oval, and sometimes a roundrect, d epending on the type of object to which array element number i refers. Perhaps this becomes more understandable if we change our te rminology a bit: In object- oriented programming, calling a method is often referred to as sending a message to an object. The object responds to the message by executing the appropri ate method. The statement “ someShape.redraw(); ” is a message to the object referred to by someShape . Since that object knows what type of object it is, it knows how it should r espond to the message. From this point of view, the computer always executes “ someShape.redraw(); ” in the same way: by sending a message. The response to the message depends, natu rally, on who receives it. From this point of view, objects are active entities that send and receive messages, and polymorphism is a natural, even necessary, part of this view. Polymorphis m just means that different objects can respond to the same message in different ways.

244 CHAPTER 5. OBJECTS AND CLASSES 231 t lets code that you write do One of the most beautiful things about polymorphism is that i things that you didn’t even conceive of, at the time you wrote it. Suppose that I decide to add with. A beveled rectangle has beveled rectangles to the types of shapes my program can deal a triangle cut off each corner: BeveledRects To implement beveled rectangles, I can write a new subclass, BeveledRect , of class Shape method. Automatically, code that I wrote previously—such a s and give it its own redraw() —can now suddenly start drawing beveled rectangles, even someShape.redraw() the statement though the beveled rectangle class didn’t exist when I wrote the statement! ∗ ∗ ∗ In the statement “ ”, the redraw message is sent to the object someShape.redraw(); . Look back at the method in the Shape someShape class for changing the color of a shape: void setColor(Color newColor) { color = newColor; // change value of instance variable redraw(); // redraw shape, which will appear in new color } message is sent here, but which object is it sent to? Well, the setColor method is A redraw at the redraw message is sent to itself a message that was sent to some object. The answer is th same object that setColor message. If that object is a rectangle, , the one that received the then it contains a redraw() method for drawing rectangles, and that is the one that is exe cuted. If the object is an oval, then it is the redraw() method from the Oval class. This is what you should expect, but it means that the “ redraw(); ” statement in the setColor() method does not necessarily call the method in the Shape class! The redraw() method that is redraw() Shape executed could be in any subclass of . This is just another case of polymorphism. 5.5.5 Abstract Classes Rectangle , Oval , or RoundRect Whenever a redraw() method in object has to draw itself, it is the the appropriate class that is executed. This leaves open the question, What does the redraw() method in the Shape class do? How should it be defined? The answer may be surprising: We should leave it blank! The fa ct is that the class Shape represents the abstract idea of a shape, and there is no way to draw such a thing. Only particular, concrete shapes like rectangles and ovals can b e drawn. So, why should there even be a redraw() method in the Shape class? Well, it has to be there, or it would be illegal to call it in the setColor() method of the Shape class, and it would be illegal to write “ ;”. The compiler would complain that someShape is a variable of type someShape.redraw() class. and there’s no redraw() method in the Shape Shape

245 CHAPTER 5. OBJECTS AND CLASSES 232 redraw() in the class itself will never actually be called. Nevertheless the version of Shape construct an actual object of In fact, if you think about it, there can never be any reason to type ! You can have variables of type Shape , but the objects they refer to will always Shape . We say that Shape belong to one of the subclasses of abstract class . An abstract Shape is an a basis for making subclasses. An class is one that is not used to construct objects, but only as abstract class exists only to express the common properties of all its subclasses. A cla ss that concrete . You can create objects belonging to a concrete class, is not abstract is said to be an abstract class can only refer but not to an abstract class. A variable whose type is given by t class. to objects that belong to concrete subclasses of the abstrac method in class Shape is an redraw() , since Similarly, we say that the abstract method to do—any actual redrawing is it is never meant to be called. In fact, there is nothing for it redraw() methods in the subclasses of done by . The redraw() method in Shape has Shape to be there. But it is there only to tell the computer that all Shapes understand the redraw message. As an abstract method, it exists merely to specify t he common interface of all the actual, concrete versions of redraw() in the subclasses. There is no reason for the abstract redraw() in class to contain any code at all. Shape and its redraw() uter, Shape method are semantically abstract. You can also tell the comp “ ” to their definitions. syntactically, that they are abstract by adding the modifier abstract For an abstract method, the block of code that gives the imple mentation of an ordinary method ovided for the abstract method is replaced by a semicolon. An implementation must then be pr in any concrete subclass of the abstract class. Here’s what t he class would look like as Shape an abstract class: public abstract class Shape { Color color; // color of shape. void setColor(Color newColor) { // method to change the color of the shape color = newColor; // change value of instance variable redraw(); // redraw shape, which will appear in new color } abstract void redraw(); // abstract method---must be defined in // concrete subclasses . . . // more instance variables and methods } // end of class Shape Once you have declared the class to be , it becomes illegal to try to create actual abstract Shape objects of type . , and the computer will report a syntax error if you try to do so Note, by the way, that the Vehicle class discussed above would probably also be an abstract class. There is no way to own a vehicle as such—the actual vehi cle has to be a car or a truck or a motorcycle, or some other “concrete” type of vehicle. ∗ ∗ ∗ Recall from Subsection 5.3.2 that a class that is not explicitly declared to be a subclass o f some other class is automatically made a subclass of the stan dard class Object . That is, a class declaration with no “ extends ” part such as public class myClass { . . .

246 CHAPTER 5. OBJECTS AND CLASSES 233 is exactly equivalent to public class myClass extends Object { . . . is at the top of a huge class hierarchy that includes every This means that class Object is an abstract class, in fact the most abstract class of all. Object other class. (Semantically, Curiously, however, it is not declared to be syntactically, which means that you can abstract create objects of type Object . However, there is not much that you can do with them.) Object , a variable of type Object can refer to any object Since every class is a subclass of Object[ ] whatsoever, of any type. Similarly, an array of type can hold objects of any type. ∗ ∗ ∗ uses an abstract Shape class and an array of The sample source code file Shape[ ] type n though you to hold a list of shapes. You might want to look at this file, eve won’t be able to understand all of it at this time. Even the defi nitions of the shape classes are somewhat different from those that I have described in this se ction. (For example, the draw() method has a parameter of type Graphics . This parameter is required because drawing in Java requires a graphics context.) I’ll return to similar exampl es in later chapters when you know while to look at the definition more about GUI programming. However, it would still be worth Shape class and its subclasses in the source code. You might also ch eck how an array is of the rogram: used to hold the list of shapes. Here is a screenshot from the p ShapeDraw program, you can click one of the buttons along the bottom to If you run the add a shape to the picture. The new shape will appear in the upp er left corner of the drawing area. The color of the shape is given by the “pop-up menu” in th e lower right. Once a shape is on the screen, you can drag it around with the mouse. A shape will maintain the same front-to-back order with respect to other shapes on the scre en, even while you are dragging it. However, you can move a shape out in front of all the other shap es if you hold down the shift key as you click on it. In the program, the only time when the actual class of a shape i s used is when that shape is added to the screen. Once the shape has been created, it is man ipulated entirely as an abstract shape. The routine that implements dragging, for example, w orks with variables of type Shape and makes no reference to any of its subclasses. As the shape i s being dragged, the dragging routine just calls the shape’s draw method each time the shap e has to be drawn, so it doesn’t have to know how to draw the shape or even what type of shape it i s. The object is responsible

247 CHAPTER 5. OBJECTS AND CLASSES 234 program, I would define a for drawing itself. If I wanted to add a new type of shape to the , add another button, and program the button to add the correc t type of new subclass of Shape d be necessary. shape to the screen. No other changes in the programming woul 5.6 this and super lthough the basic ideas of object-oriented programming are reasonably simple and c lear, A they are subtle, and they take time to get used to. And unfortu nately, beyond the basic ideas there are a lot of details. The rest of this chapter covers mor e of those annoying details. Remember that you don’t need to master everything in this cha pter the first time through. In this section, we’ll look at two variables, this and super , that are automatically defined in any instance method. 5.6.1 The Special Variable this amount or What does it mean when you use a simple identifier such as to refer to a process() variable or method? The answer depends on scope rules that te ll where and how each declared efinition of a method, a simple variable and method can be accessed in a program. Inside the d f there is one “in scope,” that is, variable name might refer to a local variable or parameter, i one whose declaration is in effect at the point in the source co de where the reference occurs. If not, it must refer to a member variable of the class in which th e reference occurs. Similarly, a simple method name must refer to a method in the same class. static member of a class has a simple name that can only be used inside A the class definition; for use outside the class, it has a full name of the 〈 class-name 〉 form 〈 simple-name 〉 . . For example, “ Math.PI ” is a static member variable with simple name “ PI ” in the class “ Math ”. It’s always legal to use the full name of a static member, even within the class where it’s defined. atic member variable is hidden Sometimes it’s even necessary, as when the simple name of a st by a local variable or parameter of the same name. Instance variables and instance methods also have simple na mes. The simple name of such an instance member can be used in instance methods in the clas s where the instance member is defined (but not in static methods). Instance members also have full names—but remember that an instance variable or instance method is actually con tained in an object rather than in a class, and each object has its own version. A full name of an i nstance member starts with a reference to the object that contains the instance member. std is a variable For example, if that refers to an object of type , then std.test1 could be a full name for an instance Student test1 that is contained in that object. variable named But when we are working inside a class and use a simple name to r efer to an instance variable like test1 , where is the object that contains the variable? The solutio n to this riddle is simple: Suppose that a reference to “ test1 ” occurs in the definition of some instance method. ar object of type Student . When The actual method that gets executed is part of some particul test1 ” refers to the test1 variable in that method gets executed, the occurrence of the name “ that same object . (This is why simple names of instance members cannot be used in static methods—when a static method is executed, it is not part of an object, and hence there are no instance members in sight!) This leaves open the question of full names for instance memb ers inside the same class where they are defined. We need a way to refer to “the object tha t contains this method.” Java defines a special variable named this for just this purpose. The variable this can be used in

248 CHAPTER 5. OBJECTS AND CLASSES 235 at contains the method. This the source code of an instance method to refer to the object th ,” is to refer to “this object,” the one right here that this ve ry method intent of the name, “ this is an instance variable in the same object as the method, then this.var ” is a var “ is in. If full name for that variable. If otherMethod() is an instance method in the same object, then utes an this.otherMethod() could be used to call that method. Whenever the computer exec to refer to the object that contains the this instance method, it automatically sets the variable method. (Some object oriented languages use the name “self” instead of “this.” Here, an object is seen as an entity that receives messages and responds by performi ng some action. From the point of view of that entity, an instance variable such as refers to the entity’s own name , something that is part of the entity itself. Calling an insta self.redraw() nce method such as is like saying “message to self: redraw!”) One common use of is in constructors. For example: this public class Student { private String name; // Name of the student. public Student(String name) { // Constructor. Create a student with specified name. = name; } . . // More variables and methods. . } In the constructor, the instance variable called name is hidden by a formal parameter that is also called “name.” However, the instance variable can still be r eferred to by its full name, which is . In the assignment statement “ = name ”, the value of the formal parameter, name . This is considered to be , is assigned to the instance variable, or formal parameters that are acceptable style: There is no need to dream up cute new names f ame name for the parameter as for just used to initialize instance variables. You can use the s the instance variable. There are other uses for this . Sometimes, when you are writing an instance method, you ne, as an actual parameter. In need to pass the object that contains the method to a subrouti that case, you can use this ut as the actual parameter. For example, if you wanted to print o System.out.println(this); a string representation of the object, you could say “ ”. Or you could assign the value of this to another variable in an assignment statement. You can stor e it in an array. In fact, you can do anything with this that you could do with any other variable, except change its value. (Consider it to be a variable.) final 5.6.2 The Special Variable super Java also defines another special variable, named “ super ”, for use in the definitions of instance methods. The variable super is for use in a subclass. Like this , super refers to the object that contains the method. But it’s forgetful. It forgets tha t the object belongs to the class you are writing, and it remembers only that it belongs to the supe rclass of that class. The point is that the class can contain additions and modifications to the superclass. super doesn’t know about any of those additions and modifications; it can only be used to refer to methods and variables in the superclass.

249 CHAPTER 5. OBJECTS AND CLASSES 236 ance method named Let’s say that the class that you are writing contains an inst super.doSomething() . Now, super doSomething() . Consider the subroutine call statement method in the subclass. It only knows doSomething() doesn’t know anything about the d named doSomething() from about things in the superclass, so it tries to execute a metho method was an addition rather than a the superclass. If there is none—if the doSomething() modification—you’ll get a syntax error. super exists is so you can get access to things in the superclass tha t are hidden The reason by things in the subclass. For example, super.var always refers to an instance variable named in the superclass. This can be useful for the following reaso n: If a class contains an instance var erclass, then an object of that variable with the same name as an instance variable in its sup : one defined as part of the class class will actually contain two variables with the same name replace itself and one defined as part of the superclass. The variable in the subclass does not it. The variable from the hides the variable of the same name in the superclass; it merely super . superclass can still be accessed, using When a subclass contains an instance method that has the same signature as a method in its superclass, the method from the superclass is hidden in t he same way. We say that the method in the subclass the method from the superclass. Again, however, super can overrides be used to access the method from the superclass. super is to override a method with a new method that extends the The major use of behavior of the inherited method, instead of replacing that behavior entirely. The new method can use super itional code to to call the method from the superclass, and then it can add add e a class that includes provide additional behavior. As an example, suppose you hav PairOfDice a roll() method. Suppose that you want a subclass, GraphicalDice , to represent a pair of roll() method in the dice drawn on the computer screen. The class should do GraphicalDice everything that the roll() method in the PairOfDice class does. We can express this with a call to super.roll() , which calls the method in the superclass. But in addition to that, the roll() method for a GraphicalDice object has to redraw the dice to show the new values. The GraphicalDice class might look something like this: public class GraphicalDice extends PairOfDice { public void roll() { // Roll the dice, and redraw them. super.roll(); // Call the roll method from PairOfDice. redraw(); // Call a method to draw the dice. } . . // More stuff, including definition of redraw(). . } Note that this allows you to extend the behavior of the roll() method even if you don’t know how the method is implemented in the superclass! 5.6.3 super and this As Constructors Constructors are not inherited. That is, if you extend an exi sting class to make a subclass, the constructors in the superclass do not become part of the subclass. If you want constructors in the subclass, you have to define new ones from scratch. If you d on’t define any constructors in the subclass, then the computer will make up a default cons tructor, with no parameters, for you.

250 CHAPTER 5. OBJECTS AND CLASSES 237 class that does a lot of necessary This could be a problem, if there is a constructor in the super work. It looks like you might have to repeat all that work in th e subclass! This could be a nd don’t even know how it problem if you don’t have the source code to the superclass, a real the constructor in the superclass is implemented. It might look like an impossible problem, if member variables that you don’t even have access to in the sub class! uses private Obviously, there has to be some fix for this, and there is. It in volves the special variable, super . As the very first statement in a constructor, you can use super to call a constructor from the superclass. The notation for this is a bit ugly and mi sleading, and it can only be used in this one particular circumstance: It looks like you are ca super as a subroutine (even lling though is not a subroutine and you can’t call constructors the same w ay you call other super PairOfDice subroutines anyway). As an example, assume that the class has a constructor that takes two integers as parameters. Consider a subclass: public class GraphicalDice extends PairOfDice { public GraphicalDice() { // Constructor for this class. super(3,4); // Call the constructor from the // PairOfDice class, with parameters 3, 4. initializeGraphics(); // Do some initialization specific // to the GraphicalDice class. } . . // More constructors, methods, variables... . } The statement “ ” calls the constructor from the superclass. This call must super(3,4); if you don’t explicitly call a be the first line of the constructor in the subclass. Note that t constructor from the superclass, constructor from the superclass in this way, then the defaul the one with no parameters, will be called automatically. (A nd if no such constructor exists in rror.) the superclass, the compiler will consider it to be a syntax e You can use the special variable in exactly the same way to call another constructor this in the same class. That is, the very first line of a constructor can look like a subroutine call with “this” as the name of the subroutine. The result is that t he body of another constructor in the same class is executed. This can be very useful since it can save you from repeating the same code in several different constructors. As an example, c onsider , which was used indirectly in Section 4.6 . A MosaicPanel represents a grid of colored rectangles. It has a constructor with many parameters: public MosaicPanel(int rows, int columns, int preferredBlockWidth, int preferredBlockHeight, Color borderColor, int borderWidth) This constructor provides a lot of options and does a lot of in itialization. I wanted to provide easier-to-use constructors with fewer options, but all the initialization still has to be done. The class also contains these constructors: public MosaicPanel() { this(42,42,16,16); } public MosaicPanel(int rows, int columns) {

251 CHAPTER 5. OBJECTS AND CLASSES 238 this(rows,columns,16,16); } public MosaicPanel(int rows, int columns, int preferredBlockWidth, int preferredBlockHeight) { kHeight, null, 0); this(rows, columns, preferredBlockWidth, preferredBloc } Each of these constructors exists just to call another const ructor, while providing constant calls the last constructor values for some of the parameters. For example, this(42,42,16,16) ix-parameter constructor. That main listed here, while that constructor in turn calls the main, s constructor is eventually called in all cases, so that all th e essential initialization gets done in every case. 5.7 Interfaces llow a class to extend two or Some object-oriented programming languages, such as C++, a multiple inheritance more superclasses. This is called . In the illustration below, for example, class E is shown as having both class A and class B as direct sup erclasses, while class F has three direct superclasses. class A class B class C class E class D class F inherit NOT $!% , & '(% )  & !!* +% !" # # ' - & . &/ Such multiple inheritance is not allowed in Java. The designers of Java wanted to keep the tiple inheritance were not worth the language reasonably simple, and felt that the benefits of mul ure that can be used to accomplish cost in increased complexity. However, Java does have a feat many of the same goals as multiple inheritance: interfaces . 5.7.1 Defining and Implementing Interfaces We’ve encountered the term “interface” before, in connecti on with black boxes in general and subroutines in particular. The interface of a subroutine co nsists of the name of the subroutine, its return type, and the number and types of its parameters. T his is the information you need to know if you want to call the subroutine. A subroutine also h as an implementation: the block of code which defines it and which is executed when the subrout ine is called. In Java, is a reserved word with an additional, technical meaning. An interface “ interface ” in this sense consists of a set of instance method interface s, without any as- sociated implementations. (Actually, a Java interface can contain other things as well, as we’ll see later.) A class can implement an interface by providing an implementation for each of the methods specified by the interface. Here is an example of a very simple Java interface :

252 CHAPTER 5. OBJECTS AND CLASSES 239 public interface Drawable { public void draw(Graphics g); } draw() This looks much like a class definition, except that the imple mentation of the method is omitted. A class that implements the interface Drawable must provide an implementation for this method. Of course, the class can also include other meth ods and variables. For example, public class Line implements Drawable { public void draw(Graphics g) { . . . // do something---presumably, draw a line } . . . // other methods and variables } Note that to implement an interface, a class must do more than simply provide an implemen- state that it implements the interface, tation for each method in the interface; it must also implements using the reserved word public class Line implements as in this example: “ ”. Any concrete class that implements the interface must define a draw() Drawable Drawable es a draw() method. We say that instance method. Any object created from such a class includ an implements an interface if it belongs to a class that implements the interface. For object example, any object of type Line implements the Drawable interface. While a class can extend only one other class, it can implement any number of interfaces. In fact, a class can both extend one other class and implement one or more interfaces. So, we can have things like class FilledCircle extends Circle implements Drawable, Fillable { . . . } The point of all this is that, although interfaces are not cla sses, they are something very similar. An interface is very much like an abstract class, th at is, a class that can never be used for constructing objects, but can be used as a basis for makin g subclasses. The subroutines in an interface are abstract methods, which must be implemen ted in any concrete class that implements the interface. You can compare the Drawable interface with the abstract class public abstract class AbstractDrawable { public abstract void draw(Graphics g); } The main difference is that a class that extends AbstractDrawable cannot extend any other class, while a class that implements can also extend some class, as well as implement other Drawable interfaces. Of course, an abstract class can contain non-ab stract methods as well as abstract methods. An interface is like a “pure” abstract class, which contains only abstract methods. Note that the methods declared in an interface must be public . In fact, since that is the only option, it is not necessary to specify the access modifie r in the declaration. In addition to method declarations, an interface can also in clude variable declarations. The variables must be "public static final" and effectively become public static final variables in every class that implements the interface. In fact, since the variables can only be public and static and final, specifying the modifiers is optional. For ex ample,

253 CHAPTER 5. OBJECTS AND CLASSES 240 public interface ConversionFactors { PER FOOT = 12; int INCHES int FEET YARD = 3; PER PER MILE = 1760; int YARDS } This is a convenient way to define named constants that can be u sed in several classes. A class that implements ConversionFactors can use the constants defined in the interface as if they were defined in the class. You are not likely to need to write your own interfaces until y ou get to the point of writing fairly complex programs. However, there are several interf aces that are used in important ways in Java’s standard packages. You’ll learn about some of thes e standard interfaces in the next . few chapters, and you will write classes that implement them 5.7.2 Interfaces as Types As with abstract classes, even though you can’t construct an object from an interface, you can xample, if is the interface declare a variable whose type is given by the interface. For e Drawable Line and FilledCircle are classes that implement Drawable , as above, then given above, and if you could say: Drawable figure; // Declare a variable of type Drawable. It c an // refer to any object that implements the // Drawable interface. figure = new Line(); // figure now refers to an object of class Line figure.draw(g); // calls draw() method from class Line figure = new FilledCircle(); // Now, figure refers to an obje ct // of class FilledCircle. figure.draw(g); // calls draw() method from class FilledCi rcle Drawable can refer to any object of any class that implements the A variable of type Drawable , above, is legal because figure.draw(g) is of type Drawable , interface. A statement like figure and Drawable object has a draw() method. So, whatever object figure refers to, that any object must have a draw() method. Note that a type is something that can be used to declare variables. A type can also be used to specify the type of a parameter in a subroutine, or the return type of a function. In Java, a type can be either a class, an interface, or one of the e ight built-in primitive types. These are the only possibilities. Of these, however, only cl asses can be used to construct new objects. An interface can also be the base type of an array. For example , we can use an array type Drawable[ ] to declare variables and create arrays. The elements of the a rray can refer to any objects that implement the interface: Drawable Drawable[] listOfFigures; listOfFigures = new Drawable[10]; listOfFigures[0] = new Line(); listOfFigures[1] = new FilledCircle(); listOfFigures[2] = new Line(); . . .

254 CHAPTER 5. OBJECTS AND CLASSES 241 draw() method, so that we can say things like Every element of the array will then have a listOfFigures[i].draw(g) . 5.7.3 Interfaces in Java 8 ns to interfaces. The one that The newest version of Java, Java 8, makes a few useful additio I will discuss here is default methods . Unlike the usual abstract methods in interfaces, a default method has an implementation. When a class implemen ts the interface, it does not though it can do so if it wants to have to provide an implementation for the default method—al provide a different implementation. Essentially, default m ethods are inherited from interfaces in much the same way that ordinary methods are inherited from classes. This moves Java true multiple inheritance, however, partway towards supporting multiple inheritance. It’s not since interfaces still cannot define instance variables. A default method in an interface must be marked with the modifi default . It can op- er public re auto- tionally be marked but, as for everything else in interfaces, default methods a public modifier can be omitted. Here is an example.: matically public and the public interface Readable { // represents a source of input nput public char readChar(); // read the next character from the i default public String readLine() { // read up to the next line feed StringBuilder line = new StringBuilder(); char ch = readChar(); while (ch != ’\n’) { line.append(ch); ch = readChar(); } return line.toString(); } } A concrete class that implements this interface must provid e an implementation for readChar() . readLine() from the interface, but can provide a new definition It will inherit a definition for readLine() calls the abstract method readChar() , whose if necessary. Note that the default definition will only be provided in the implementing class. T he reference to readChar() in the definition is polymorphic. The default implementation of readLine() is one that would make sense in almost any class that implements . Here’s a rather silly example of a class Readable that implements Readable , including a main() routine that tests the class. Can you figure out what it does? public class Stars implements Readable { public char readChar() { if (Math.random() > 0.02) return ’*’; else return ’\n’; } public static void main(String[] args) { Stars stars = new Stars(); for (int i = 0 ; i < 10; i++ ) {

255 CHAPTER 5. OBJECTS AND CLASSES 242 String line = stars.readLine(); System.out.println( line ); } } } Default methods provide Java with a capability similar to so mething called a “mixin” in other programming languages, namely the ability to mix func tionality from another source into a class. Since a class can implement several interfaces, it i s possible to mix in functionality from several different sources. 5.8 Nested Classes a pretty important thing. A class is a high-level building class seems like it should be A block of a program, representing a potentially complex idea and its associated data and behav- iors. I’ve always felt a bit silly writing tiny little classe s that exist only to group a few scraps of ul and even essential. Fortunately, in data together. However, such trivial classes are often usef ested inside another class. My Java, I can ease the embarrassment, because one class can be n mes part of a larger more respectable trivial little class doesn’t have to stand on its own. It beco ittle class specifically to support class. This is particularly useful when you want to create a l the work of a larger class. And, more seriously, there are oth er good reasons for nesting the definition of one class inside another class. nested class is any class whose definition is inside the definition of anoth In Java, a er class. (In fact, a class can even be nested inside a subroutine, whic h must, of course, itself be inside a class). Nested classes can be either named or anonymous . I will come back to the topic of anonymous classes later in this section. A named nested cl ass, like most other things that occur in classes, can be either static or non-static. 5.8.1 Static Nested Classes nition of any other class, except The definition of a static nested class looks just like the defi static as part of its declaration. that it is nested inside another class and it has the modifier A static nested class is part of the static structure of the co ntaining class. It can be used inside that class to create objects in the usual way. If it is used out side the containing class, its name must indicate its membership in the containing class. That i s, the full name of the static nested class consists of the name of the class in which it is nested, f ollowed by a period, followed by the name of the nested class. This is similar to other static c omponents of a class: A static nested class is part of the class itself in the same way that st atic member variables are parts of the class itself. For example, suppose a class named WireFrameModel represents a set of lines in three- dimensional space. (Such models are used to represent three -dimensional objects in graphics programs.) Suppose that the WireFrameModel class contains a static nested class, Line , that represents a single line. Then, outside of the class WireFrameModel , the Line class would be referred to as WireFrameModel.Line . Of course, this just follows the normal naming convention for static members of a class. The definition of the WireFrameModel class with its nested Line class would look, in outline, like this: public class WireFrameModel {

256 CHAPTER 5. OBJECTS AND CLASSES 243 . . . // other members of the WireFrameModel class static public class Line { // Represents a line from the point (x1,y1,z1) // to the point (x2,y2,z2) in 3-dimensional space. double x1, y1, z1; double x2, y2, z2; } // end class Line . . . // other members of the WireFrameModel class } // end WireFrameModel The full name of the nested class is WireFrameModel.Line . That name can be used, for example, class, a Line object would be created with the to declare variables. Inside the WireFrameModel ”. Outside the class, “ new WireFrameModel.Line() ” would be used. new Line() constructor “ A static nested class has full access to the static members of the containing class, even to the private members. Similarly, the containing class has full access to the members of the nested class, even if they are marked . This can be another motivation for declaring a nested private class, since it lets you give one class access to the private m embers of another class without Note also that a nested class can making those members generally available to other classes. class in which it is nested. itself be private, meaning that it can only be used inside the When you compile the above class definition, two class files wi ll be created. Even though Line is nested inside WireFrameModel , the compiled Line the definition of class is stored in a separate file. The name of the class file for Line will be WireFrameModel$Line.class . 5.8.2 Inner Classes Non-static nested classes are referred to as inner classes . Inner classes are not, in practice, very different from static nested classes, but a non-static n ested class is actually associated with an object rather than with the class in which its definiti on is nested. This can take some getting used to. Any non-static member of a class is not really part of the clas s itself (although its source code is contained in the class definition). This is true for in ner classes, just as it is for any other non-static part of a class. The non-static members of a class specify what will be contained in objects that are created from that class. The same is true—at least logically—for inner classes. s its own copy of the nested class It’s as if each object that belongs to the containing class ha d code for the nested class). This (although it does not literally contain a copy of the compile ables of the object, even to those copy has access to all the instance methods and instance vari that are declared private . The two copies of the inner class in two different objects diff er because the instance variables and methods they refer to are in different objects. In fact, the rule for deciding whether a nested class should be static or n on-static is simple: If the nested class needs to use any instance variable or instance method f rom the containing class, make the nested class non-static. Otherwise, it might as well be stat ic. In most cases, an inner class is used only within the class whe re it is defined. When that is true, using the inner class is really not much different fro m using any other class. You can create variables and declare objects using the simple name o f the inner class in the usual way. From outside the containing class, however, an inner class h as to be referred to using a name of the form 〈 variableName 〉 . 〈 NestedClassName 〉 , where 〈 variableName 〉 is a variable that refers to the object that contains the inner class. In order to creat e an object that belongs to an inner

257 CHAPTER 5. OBJECTS AND CLASSES 244 ning class. (When working inside class, you must first have an object that belongs to the contai ” is used implicitly.) the class, the object “ this you that inner classes are Looking at an example will help, and will hopefully convince really very natural. Consider a class that represents poker games. This class might include a nested class to represent the players of the game. The struct ure of the PokerGame class could be: public class PokerGame { // Represents a game of poker. class Player { // Represents one of the players in this game. . . . } // end class Player private Deck deck; // A deck of cards for playing the game. private int pot; // The amount of money that has been bet. . . . } // end class PokerGame game is a variable of type If , then, conceptually, game contains its own copy of PokerGame the class. In an instance method of a PokerGame object, a new Player object would Player new Player() Player object could be be created by saying “ ”, just as for any other class. (A PokerGame class with an expression such as “ Player() created outside the ”. Again, however, this is rare.) The Player object will have access to the deck and pot instance variables in the PokerGame object. Each PokerGame object has its own deck and pot and Players . Players of that poker game use the deck and pot for that game; p layers of another poker game he Player use the other game’s deck and pot. That’s the effect of making t class non-static. object represents a player of one Player This is the most natural way for players to behave. A particular poker game. If were an independent class or a static nested class, on the Player yer, independent of a particular other hand, it would represent the general idea of a poker pla poker game. 5.8.3 Anonymous Inner Classes nd then using that class in just a In some cases, you might find yourself writing an inner class a single line of your program. Is it worth creating such a class ? Indeed, it can be, but for cases like this you have the option of using an . An anonymous class is anonymous inner class created with a variation of the new operator that has the form new 〈 superclass-or-interface 〉 ( 〈 parameter-list 〉 ) { 〈 〉 methods-and-variables } This constructor defines a new class, without giving it a name , and it simultaneously creates an object that belongs to that class. This form of the new operator can be used in any statement where a regular “ new ” could be used. The intention of this expression is to create : “a new object 〈 belonging to a class that is the same as superclass-or-interface 〉 but with these 〈 methods-and- variables 〉 added.” The effect is to create a uniquely customized object, just at the point in

258 CHAPTER 5. OBJECTS AND CLASSES 245 an anonymous class on an the program where you need it. Note that it is possible to base interface, rather than a class. In this case, the anonymous c lass must implement the interface . If an interface is used as a base, by defining all the methods that are declared in the interface the parameter-list 〉 must be empty. Otherwise, it can contain parameters for a con structor in 〈 the 〉 . 〈 superclass hical user interfaces, and we Anonymous classes are often used for handling events in grap will encounter them several times in the chapters on GUI prog ramming. For now, we will look Drawable at one not-very-plausible example. Consider the interface, which is defined earlier in this section. Suppose that we want a object that draws a filled, red, 100-pixel square. Drawable class to create the object, we Rather than defining a new, separate class and then using that nt: can use an anonymous class to create the object in one stateme Drawable redSquare = new Drawable() { { void draw(Graphics g) g.setColor(Color.RED); g.fillRect(10,10,100,100); } }; Then redSquare refers to an object that implements Drawable and that draws a red square when its draw() method is called. By the way, the semicolon at the end of the st atement is not part of the class definition; it’s the semicolon that is requi red at the end of every declaration statement. Anonymous classes are often used for actual parameters. For example, consider the following in two different graphics contexts: simple method, which draws a Drawable void drawTwice( Graphics g1, Graphics g2, Drawable figure ) { figure.draw(g1); figure.draw(g2); } When calling this method, the third parameter can be created using an anonymous inner class. For example: drawTwice( firstG, secondG, new Drawable() { void draw(Graphics g) { g.drawOval(10,10,100,100); } } ); When a Java class is compiled, each anonymous nested class wi ll produce a separate class file. If the name of the main class is MainClass , for example, then the names of the MainClass$1.class , class files for the anonymous nested classes will be , MainClass$2.class MainClass$3.class , and so on. 5.8.4 Java 8 Lambda Expressions The syntax for anonymous classes is cumbersome. In many case s, an anonymous class imple- ments an interface that defines just one method. Java 8 introd uces a new syntax that can be used in place of the anonymous class in that circumstance: th e lambda expression. Here is what the previous subroutine call looks like using a lambda e xpression: drawTwice( firstG, secondG, g - > g.drawOval(10,10,100,100) )

259 CHAPTER 5. OBJECTS AND CLASSES 246 g -> g.drawOval(10,10,100,100) . Its meaning is, “the method The lambda expression is and executes the code .” The computer that has a parameter g.drawOval(10,10,100,100) g is of type knows that because it is expecting a Drawable as the actual parameter, g Graphics and the only method in the interface has a parameter of type Graphics . Lambda Drawable expressions can only be used in places where this kind of type inference can be made. The general syntax of a lambda expression is 〈 formal-parameter-list -> 〈 method-body 〉 〉 where the 〈 method body 〉 can be a single expression, a single subroutine call, or a blo ck of statements enclosed between { } . When the body is a single expression or function call, and rn value of the method that is the value of the expression is automatically used as the retu being defined. The parameter list in the lambda expression do es not have to specify the types of the parameters, although it can. Parentheses around the p arameter list are optional if there is exactly one parameter and no type is specified for the param eter; this is the form seen in the example above. For a method with no parameters, the paramete r list is just an empty set of parentheses. Here are a few more examples of lambda expressi ons: () -> System.out.println("Hello World") ; } g -> { g.setColor(Color.RED); g.drawRect(10,10,100,100) (a, b) -> a + b (int n) -> { while (n > 0) { System.out.println(n); n = n/2; } } // lambda expressions ends here As you can see, the syntax can still get pretty complicated. T here is quite a lot more to say about lambda expressions, but my intention here is only to br iefly introduce one of the most interesting new features in Java 8.

260 Exercises 247 Exercises for Chapter 5 Section 5.2 , the instance variables die1 and die2 (solution) 1. class in In all versions of the PairOfDice . They really should be , so that they would be protected public are declared to be private PairOfDice sion of the class from being changed from outside the class. Write another ver and in which the instance variables are private . Your class will need “getter” die1 die2 die1 methods that can be used to find out the values of die2 . (The idea is to protect and their values from being changed from outside the class, but s till to allow the values to be t least a toString() read.) Include other improvements in the class, including a method. s a pair of dice is rolled, Test your class with a short program that counts how many time before the total of the two dice is equal to two. A common programming task is computing statistics of a set of numbers. (A statistic is (solution) 2. a number that summarizes some property of a set of data.) Comm on statistics include the mean (also known as the average) and the standard deviati on (which tells how spread alled StatCalc out the data are from the mean). I have written a little class c that can be used to compute these statistics, as well as the sum of the ite ms in the dataset and the number of items in the dataset. You can read the source code fo r this class in the file . If calc is a variable of type StatCalc , then the following instance methods are available: • where item is a number, adds the item to the dataset. calc.enter(item) calc.getCount() • is a function that returns the number of items that have been added to the dataset. • calc.getSum() is a function that returns the sum of all the items that have be en added to the dataset. calc.getMean() is a function that returns the average of all the items. • • calc.getStandardDeviation() is a function that returns the standard deviation of the items. Typically, all the data are added one after the other by calli ng the enter() method over and over, as the data become available. After all the dat a have been entered, any of the other methods can be called to get statistical informa tion about the data. The methods getMean() and getStandardDeviation() should only be called if the number of items is greater than zero. , to add instance methods getMax() and Modify the current source code, . The getMin() method should return the largest of all the items that have be en getMax() added to the dataset, and getMin() should return the smallest. You will need to add two new instance variables to keep track of the largest and small est items that have been seen so far. ics for a set of non-zero Test your new class by using it in a program to compute statist numbers entered by the user. Start by creating an object of ty pe StatCalc : StatCalc calc; // Object to be used to process the data. calc = new StatCalc(); Read numbers from the user and add them to the dataset. Use 0 as a sentinel value (that is, stop reading numbers when the user enters 0). After all the user’s non-zero

261 Exercises 248 cs that are available from numbers have been entered, print out each of the six statisti calc . PairOfDice class from Exercise 5.1 and the class from 3. This problem uses the StatCalc (solution) Exercise 5.2. The program in Exercise 4.4 performs the experiment of count ing how many times a pair of dice is rolled before a given total comes up. It repeat s this experiment 10000 times and then reports the average number of rolls. It does this who le process for each possible total (2, 3, . . . , 12). e number of rolls, you Redo that exercise. But instead of just reporting the averag should also report the standard deviation and the maximum nu mber of rolls. Use a PairOfDice object to represent the dice. Use a StatCalc object to compute the statistics. (You’ll need a new StatCalc object for each possible total, 2, 3, . . . , 12. You can use a new pair of dice if you want, but it’s not required.) The BlackjackHand 4. class from Subsection 5.5.1 Hand class from Sec- (solution) is an extension of the . The instance methods in the class are discussed in that section. In addition tion 5.4 Hand to those methods, BlackjackHand includes an instance method, getBlackjackValue() , For this exercise, you will which returns the value of the hand for the game of Blackjack. Section 5.4 . Deck classes from Card also need the and A Blackjack hand typically contains from two to six cards. Wr ite a program to test the BlackjackHand class. You should create a BlackjackHand object and a Deck object. Pick a random number between 2 and 6. Deal that many cards from the d eck and add them to the hand. Print out all the cards in the hand, and then print ou t the value computed for getBlackjackValue() . Repeat this as long as the user wants to continue. the hand by In addition to , , , your program will depend on . , and (solution) 5. Write a program that lets the user play Blackjack. The game wi ll be a simplified version of Blackjack as it is played in a casino. The computer will act as the dealer. As in fined in the previous exercise, your program will need the classes de , , , and . (This is the longest and most complex program that has come up so far in the exercises.) You should first write a subroutine in which the user plays one game. The subroutine should return a boolean n value to indicate whether the user wins the game or not. Retur if the user wins, if the dealer wins. The program needs an object of class true false and two objects of type Deck , one for the dealer and one for the user. BlackjackHand The general object in Blackjack is to get a hand of cards whose value is as close to 21 as possible, without going over. The game goes like this. • First, two cards are dealt into each player’s hand. If the dea ler’s hand has a value of 21 at this point, then the dealer wins. Otherwise, if the user has 21, then the user wins. (This is called a “Blackjack”.) Note that the dealer wi ns on a tie, so if both players have Blackjack, then the dealer wins. • Now, if the game has not ended, the user gets a chance to add som e cards to her hand. In this phase, the user sees her own cards and sees one of the dealer’s two cards. (In a casino, the dealer deals himself one card face up and one card face down. All the user’s cards are dealt face up.) The user makes a decis ion whether to “Hit”,

262 Exercises 249 ch means to stop which means to add another card to her hand, or to “Stand”, whi taking cards. ver 21. In that case, the • If the user Hits, there is a possibility that the user will go o nues. The user gets to game is over and the user loses. If not, then the process conti decide again whether to Hit or Stand. a chance to draw cards. • If the user Stands, the game will end, but first the dealer gets s that as long as the The dealer only follows rules, without any choice. The rule i value of the dealer’s hand is less than or equal to 16, the deal er Hits (that is, takes another card). The user should see all the dealer’s cards at t his point. Now, the winner can be determined: If the dealer has gone over 21, the u ser wins. Otherwise, if the dealer’s total is greater than or equal to the user’s to tal, then the dealer wins. Otherwise, the user wins. Two notes on programming: At any point in the subroutine, as s oon as you know who return true ;” or “ return false ;” to end the subroutine the winner is, you can say “ nce of variables in your and return to the main program. To avoid having an overabunda subroutine, remember that a function call such as userHand.getBlackjackValue() can be used anywhere that a number could be used, including in an o utput statement or in the condition of an if statement. Write a main program that lets the user play several games of B lackjack. To make er make bets on the game. If things interesting, give the user 100 dollars, and let the us user wins, add an amount the user loses, subtract the bet from the user’s money. If the equal to the bet to the user’s money. End the program when the u ser wants to quit or when she runs out of money. Exercise 4.7 asked you to write a program that administers a 1 6. 0-question addition quiz. (solution) Rewrite that program so that it uses the following class to re present addition questions: public class AdditionQuestion { private int a, b; // The numbers in the problem. public AdditionQuestion() { // constructor a = (int)(Math.random() * 50 + 1); b = (int)(Math.random() * 50); } public String getQuestion() { return "What is " + a + " + " + b + " ?"; } public int getCorrectAnswer() { return a + b; } } 7. Rewrite the program from the previous exercise so that it adm inisters a quiz with several (solution) different kinds of questions. In the previous exercise, you u sed a class to represent addition questions. For this exercise, you will use the following interface , or an equivalent abstract class, to represent the more general idea of a question that h as an integer as its answer:

263 Exercises 250 public interface IntQuestion { public String getQuestion(); public int getCorrectAnswer(); } You can make the AdditionQuestion class implement the interface simply by adding “ ” to its definition. Write a similar class to represent subtra c- implements IntQuestion tion questions. When creating a subtraction problem, you sh ould make sure that the answer is not negative. For the new program, use an array of type IntQuestion[ ] to hold the quiz questions. Include some addition questions and some subtraction quest ions in the quiz. You can also add a couple non-math questions, including this one, create d as an anonymous class: IntQuestion bigQuestion = new IntQuestion() { public String getQuestion() { return "What is the answer to the ultimate question " + " of life, the universe, and everything?"; } public int getCorrectAnswer() { return 42; } };

264 Quiz 251 Quiz on Chapter 5 (answers) classes and objects . What are classes and what are 1. Object-oriented programming uses ts? objects? What is the relationship between classes and objec 2. and instance methods ? instance variables What are Explain carefully what means in Java, and why this special value is necessary. 3. null 4. What is a constructor? What is the purpose of a constructor in a class? Suppose that Kumquat is the name of a class and that fruit 5. Kumquat. is a variable of type What is the meaning of the statement “ ”? That is, what does fruit = new Kumquat(); a complete answer. The the computer do when it executes this statement? (Try to give computer does several things.) 6. What is meant by the terms instance variable and instance method ? Explain what is meant by the terms subclass 7. superclass. and 8. Modify the following class so that the two instance variable s are private and there is a getter method and a setter method for each instance variable : public class Player { String name; int score; } Explain why the class Player 9. that is defined in the previous question has an instance , even though no definition of this method appears in the toString() method named definition of the class. 10. Explain the term polymorphism. Java uses “garbage collection” for memory management. Expl ain what is meant here by 11. ection? garbage collection. What is the alternative to garbage coll What is an , and how can you recognize an abstract class in Java. 12. abstract class What is 13. ? this 14. For this problem, you should write a very simple but complete class. The class represents a counter that counts 0, 1, 2, 3, 4, . . . . The name of the class sh ould be Counter . It has one private has two instance instance variable representing the value of the counter. It increment() adds one to the counter value, and methods: returns the current getValue() counter value. Write a complete definition for the class, Counter . 15. This problem uses the Counter class from the previous question. The following program segment is meant to simulate tossing a coin 100 times. It shou ld use two Counter objects, headCount and tailCount , to count the number of heads and the number of tails. Fill in the blanks so that it will do so:

265 Quiz 252 Counter headCount, tailCount; tailCount = new Counter(); headCount = new Counter(); for ( int flip = 0; flip < 100; flip++ ) { if (Math.random() < 0.5) // There’s a 50/50 chance that this i s true. ; // Count a "head". else ; // Count a "tail". } System.out.println("There were " + + " heads."); System.out.println("There were " + + " tails.");

266 Chapter 6 Introduction to GUI Programming omputer users today expect to interact with their computers using a graphical user C interface (GUI). Java can be used to write GUI programs rangi ng from simple applets which run on a Web page to sophisticated stand-alone applications . GUI programs differ from traditional “straight-through” pr ograms that you have encoun- tered in the first few chapters of this book. One big difference is that GUI programs are g a key on the . That is, user actions such as clicking on a button or pressin event-driven keyboard generate events, and the program must respond to th ese events as they occur. earned in the first five chapters Event-driven programming builds on all the skills you have l ond to events. Inside those of this text. You need to be able to write the methods that resp l that was covered in methods, you are doing the kind of programming-in-the-smal Chapter 2 and Chapter 3 . And of course, objects are everywhere in GUI programming. E vents are objects. Colors and fonts are objects. GUI components such a s buttons and menus are objects. Events are handled by instance methods contained in objects . In Java, GUI programming is object-oriented programming. This chapter covers the basics of GUI programming. The discu ssion will continue in Chap- ter 13 with more details and with more advanced techniques. 6.1 The Basic GUI Application T that you have learned how to program would seem very alien he command-line programs to most computer users. The style of interaction where the us er and the computer take turns ays of computing, although it was typing strings of text seems like something out of the early d interfaces started to become only in the mid 1980s that home computers with graphical user available. Today, most people interact with their computer s exclusively through a GUI. A GUI program offers a much richer type of user interface, where the user uses a mouse and keyboard to interact with GUI components such as windows, menus, butt ons, check boxes, text input boxes, scroll bars, and so on. main() subroutine, but in general, that main routine just creates A GUI program still has a one or more GUI components and displays them on the computer s creen. Once the GUI components have been created, they follow their own programming—programming that tells them how to draw themselves on the screen and how to respond to events such as being clicked on by the user. A GUI program doesn’t have to be immensely complex. We can, fo r example, write a very simple GUI “Hello World” program that says “Hello” to the use r, but does it by opening a 253

267 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 254 window where the greeting is displayed: import javax.swing.JOptionPane; public class HelloWorldGUI1 { public static void main(String[] args) { JOptionPane.showMessageDialog( null, "Hello World!" ); } } When this program is run, a window appears on the screen that c ontains the message “Hello World!”. The window also contains an “OK” button for t he user to click after reading the message. When the user clicks this button, the window clo ses and the program ends. This , compiled, and run using the java program can be placed in a file named command on the command line just like any other Java program. Now, this program is already doing some pretty fancy stuff. It creates a window, it draws the contents of that window, and it handles the event that is g enerated when the user clicks the button. The reason the program was so easy to write is that all the work is done by , a method in the built-in class JOptionPane . (Note that the showMessageDialog() static javax.swing.JOptionPane to make it possible to refer to the source code “imports” the class class using its simple name. See JOptionPane Subsection 4.5.3 for information about importing classes from Java’s standard packages.) If you want to display a message to the user in a GUI program, th is is a good way to do it: Just use a standard class that already knows how to do the work ! And in fact, JOptionPane is regularly used for just this purpose (but as part of a larger p rogram, usually). Of course, if you e to learn. To give you an idea want to do anything serious in a GUI program, there is a lot mor GUI program that does the same of the types of things that are involved, we’ll look at a short things as the previous program—open a window containing a me ssage and an OK button, and respond to a click on the button by ending the program—but doe s it all by hand instead of by using the built-in class. Mind you, this is not a good way to write the program, JOptionPane but it will illustrate some important aspects of GUI program ming in Java. Here is the source code for the program. You are not expected t o understand it yet. I will explain how it works below, but it will take the rest of th e chapter before you will really understand completely. In this section, you will just get a b rief overview of GUI programming. import java.awt.*; import java.awt.event.*; import javax.swing.*; public class HelloWorldGUI2 { private static class HelloWorldDisplay extends JPanel { public void paintComponent(Graphics g) { super.paintComponent(g); g.drawString( "Hello World!", 20, 30 ); } } private static class ButtonHandler implements ActionList ener { public void actionPerformed(ActionEvent e) { System.exit(0); }

268 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 255 } public static void main(String[] args) { HelloWorldDisplay displayPanel = new HelloWorldDisplay( ); JButton okButton = new JButton("OK"); ButtonHandler listener = new ButtonHandler(); okButton.addActionListener(listener); JPanel content = new JPanel(); content.setLayout(new BorderLayout()); content.add(displayPanel, BorderLayout.CENTER); content.add(okButton, BorderLayout.SOUTH); JFrame window = new JFrame("GUI Test"); window.setContentPane(content); window.setSize(250,100); window.setLocation(100,100); window.setVisible(true); } } 6.1.1 JFrame and JPanel epresented by an object in In a Java GUI program, each GUI component in the interface is r s the the program. One of the most fundamental types of component i . Windows have window ized. They have “titles” that many behaviors. They can be opened and closed. They can be res rtant, they can contain other are displayed in the title bar above the window. And most impo GUI components such as buttons and menus. Java, of course, has a built-in class to represent windows. T here are actually several different e types of window, but the most common type is represented by th class (which is JFrame included in the package javax.swing ). A JFrame is an independent window that can, for example, act as the main window of an application. One of the m ost important things to understand is that a JFrame object comes with many of the behaviors of windows already ties shared by all windows, such programmed in. In particular, it comes with the basic proper JFrame comes with these behaviors, as a titlebar and the ability to be opened and closed. Since a you don’t have to program them yourself! This is, of course, o ne of the central ideas of object- JFrame doesn’t come with, of course, is oriented programming. What a , the stuff that content is contained in the window. If you don’t add any other content to a JFrame , it will just display a blank area—or, if you don’t set its size, it will be so tiny th at it will be hard to find on the screen. You can add content either by creating a JFrame object and then adding the content to it or by creating a subclass of and adding the content in the constructor of that JFrame subclass. The main program above declares a variable, window , of type JFrame and sets it to refer to a new window object with the statement: JFrame window = new JFrame("GUI Test"); The parameter (the string “GUI test”) in the constructor spe cifies the title that will be displayed in the titlebar of the window. This line creates the window ob ject, but the window itself is not yet visible on the screen. Before making the window visible, some of its properties are set with these statements:

269 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 256 window.setContentPane(content); window.setSize(250,100); window.setLocation(100,100); t itself was created earlier in the The first line here sets the content of the window. (The conten 0 pixels wide and 100 pixels main program.) The second line says that the window will be 25 high. The third line says that the upper left corner of the win dow will be 100 pixels over from ce all this has been set up, the the left edge of the screen and 100 pixels down from the top. On d: window is actually made visible on the screen with the comman window.setVisible(true); main() It might look as if the program ends at that point, and, in fact , the routine does end. whole does not end until the However, the window is still on the screen and the program as a user clicks the OK button. Once the window was opened, a new th read was created to manage the graphical user interface, and that thread continues to r un even after main() has finished. ∗ ∗ ∗ JFrame is called its content pane . (In addition to its The content that is displayed in a JFrame content pane, a alk can also have a menu bar, which is a separate thing that I will t JFrame about later.) A basic already has a blank content pane; you can either add things to that pane or you can replace the basic content pane entirel y. In my sample program, the line window.setContentPane(content) replaces the original blank content pane with a different component. (Remember that a “component” is just a v isual element of a graphical of type JPanel . user interface.) In this case, the new content is a component is another of the fundamental classes in Swing. The basic JPanel is, again, just JPanel JPanel : The first is to a blank rectangle. There are two ways to make a useful add other components to the panel; the second is to draw something in the panel. Both of these techniques are illustrated in the sample program. In fact, y ou will find two JPanels in the program: content displayPanel , which is , which is used to contain other components, and used as a drawing surface. Let’s look more closely at . This variable is of type HelloWorldDisplay , which displayPanel is a static nested class inside the HelloWorldGUI2 class. (Nested classes were introduced in .) This class defines just one instance method, paintComponent() Section 5.8 , which overrides a method of the same name in the JPanel class: private static class HelloWorldDisplay extends JPanel { public void paintComponent(Graphics g) { super.paintComponent(g); g.drawString( "Hello World!", 20, 30 ); } } The paintComponent() method is called by the system when a component needs to be pai nted on the screen. In the class, the paintComponent method simply fills the panel with the JPanel panel’s background color. The paintComponent() method in HelloWorldDisplay begins by call- ing super.paintComponent(g) . This calls the version of paintComponent() that is defined in the superclass, ; that is, it fills the panel with the background color. (See JPanel Subsection 5.6.2 for a discussion of the special variable super .) Then it calls g.drawString() to paint the string “Hello World!” onto the panel. The net result is that wheneve r a HelloWorldDisplay is shown on the screen, it displays the string “Hello World!”.

270 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 257 JPanels in this way, as drawing surfaces. Usually, when we do this, we We will often use will and we will write a paintComponent define a class that is a subclass of JPanel method in that can be defined either as JPanel f class to draw the desired content in the panel. The subclass o ases, I will tend to use a nested a separate class in its own file or as a nested class. In simple c class for the convenience. 6.1.2 Components and Layout is as a JPanel to hold other components. Java has many Another way of using a container ponents like windows, components classes that define GUI components. Except for top-level com added to a container before they can appear on the screen. In the sam ple program, the must be variable named refers to a JPanel that is used as a container. Two other components content are added to that container. This is done in the statements: content.add(displayPanel, BorderLayout.CENTER); content.add(okButton, BorderLayout.SOUTH); content refers to an object of type JPanel ; later in the program, this panel becomes the Here, o content is displayPanel content pane of the window. The first component that is added t ld!”. The second is which, as discussed above, displays the message, “Hello Wor which okButton w. The variable represents the button that the user clicks to close the windo is of okButton type JButton , the Java class that represents push buttons. The “BorderLayout” stuff in these statements has to do with ho w the two components are arranged in the container. When components are added to a con tainer, there has to be some way tainer. This is called “laying out” of deciding how those components are arranged inside the con ue for laying out components the components in the container, and the most common techniq is to use a layout manager . A layout manager is an object that implements some policy fo r how to arrange the components in a container; different types of layout manager implement e BorderLayout different policies. One type of layout manager is defined by th class. In the program, the statement content.setLayout(new BorderLayout()); creates a new BorderLayout object and tells the content panel to use the new object as its layout manager. Essentially, this line determines how components that are added to the content panel will be arranged inside the panel. We will cover layout manag ers in much more detail later, but for now all you need to know is that adding okButton in the BorderLayout.SOUTH position puts the button at the bottom of the panel, and putting displayPanel BorderLayout.CENTER in the on. position makes it fill any space that is not taken up by the butt This example shows a general technique for setting up a GUI: C reate a container and assign a layout manager to it, create components and add them to the c ontainer, and use the container as the content pane of a window. A container is itself a compon ent, so it is possible that some of the components that are added to the top-level container a re themselves containers, with their own layout managers and components. This makes it poss ible to build up complex user interfaces in a hierarchical fashion, with containers insi de containers inside containers. . . 6.1.3 Events and Listeners The structure of containers and components sets up the physi cal appearance of a GUI, but it doesn’t say anything about how the GUI behaves . That is, what can the user do to the GUI and how will it respond? GUIs are largely event-driven ; that is, the program waits

271 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 258 e other cause). When an event for events that are generated by the user’s actions (or by som . In order to program occurs, the program responds by executing an event-handling method the behavior of a GUI, you have to write event-handling metho ds to respond to the events that you are interested in. The most common technique for handling events in Java is to us e event listeners . A ng methods. When an event is listener is an object that includes one or more event-handli ener object is notified and it detected by another object, such as a button or menu, the list . An event is detected or generated responds by running the appropriate event-handling method by an object. Another object, the listener, has the responsi bility of responding to the event. The event itself is actually represented by a third object, w hich carries information about the sponsibilities makes it easier to type of event, when it occurred, and so on. This division of re organize large programs. licks button, User c object is ActionEvent button generates event sent to listener ButtonHandler instanceof OK actionPerformed() button, 1i 234 0 i represented by Event-handling object a 7 82:4 7789 ; J56 ActionListener of type responds to the event As an example, consider the OK button in the sample program. W hen the user clicks the button, an event is generated. This event is represented by a n object belonging to the class ActionEvent . The event that is generated is associated with the button; w e say that the button source onging to the class is the of the event. The listener object in this case is an object bel ButtonHandler , which is defined as a nested class inside HelloWorldGUI2 : ener { private static class ButtonHandler implements ActionList public void actionPerformed(ActionEvent e) { System.exit(0); } } This class implements the ActionListener interface—a requirement for listener objects that Section 5.7 .) The event-handling handle events from buttons. (Interfaces were introduced in method is named actionPerformed , as specified by the ActionListener interface. This method contains the code that is executed when the user clicks the bu tton; in this case, the code is System.exit() , which will terminate the program. simply a call to There is one more ingredient that is necessary to get the even t from the button to the register itself with the button as an event listener. listener object: The listener object must This is done with the statement: okButton.addActionListener(listener); This statement tells okButton that when the user clicks the button, the ActionEvent that is generated should be sent to . Without this statement, the button has no way of listener knowing that there is something that would like to listen for events from the button. This example shows a general technique for programming the b ehavior of a GUI: Write classes that include event-handling methods. Create objec ts that belong to these classes and register them as listeners with the objects that will actual ly detect or generate the events. When

272 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 259 u wrote in one of its event-handling an event occurs, the listener is notified, and the code that yo methods is executed. At first, this might seem like a very roun dabout and complicated way to nd that it is very flexible and get things done, but as you gain experience with it, you will fi that it goes together very well with object oriented program ming. This section has introduced some of the fundamentals of GUI p rogramming. We will spend the rest of the chapter exploring them in more detail. 6.1.4 Some Java GUI History The original GUI toolkit for Java was the AWT, the “Abstract W indowing Toolkit.” It provided arious operating systems. At a common interface to the GUI components already built into v the very beginning, it used a simpler event model that did not require listener objects, but that model was abandoned in favor of listeners very quickly in Jav a 1.1. ions was applets When Java was first introduced, one of the important applicat . An applet is a GUI program that can run on a web page in a web browser. Appl ets were covered in h less widely used and have been previous versions of this textbook, but they have become muc dropped from this seventh edition of the book. The Swing GUI toolkit was introduced in Java 1.2 as an improved alterna tive to the AWT, logical structure. Although Swing with a larger variety of sophisticated components and a more uses some aspects of the AWT, most of its components are writt en in Java rather than being based on operating system components. Swing has been the sta ndard toolkit for writing GUI programs in Java for over ten years, and it is the toolkit that I cover in this book. More recently, however, another GUI toolkit called JavaFX has been introduced. It uses many of the same core ideas as Swing, including components, l ayout, and events, but uses a different structure for its applications and a different set of classes. With Java 8, JavaFX . However, I do not cover JavaFX becomes the preferred approach to writing GUI applications g components, and Swing in this book. JavaFX is compatible with Swing and can use Swin will continue to be supported in Java. (Indeed, the AWT is sti ll supported!) And as I’ve said, JavaFX is built on the same core ideas as Swing. 6.2 Graphics and Painting verything you see on a computer screen E has to be drawn there, even the text. The Java API includes a range of classes and methods that are devo ted to drawing. In this section, I’ll look at some of the most basic of these. Some of this mater ial was already covered in preliminary form in Section 3.9 . The physical structure of a GUI is built of components. The te rm component refers to a visual element in a GUI, including buttons, menus, text-inp ut boxes, scroll bars, check boxes, belonging to subclasses of the and so on. In Java, GUI components are represented by objects class java.awt.Component level . Most components in the Swing GUI toolkit—although not top- components like JFrame—belong to subclasses of the class javax.swing.JComponent , which is itself a subclass of java.awt.Component . Every component is responsible for drawing itself. If you want to use a standard component, you only have to add it to your program. You don’t have to worry about painting it on the screen. That will happe n automatically, since it already knows how to draw itself. Sometimes, however, you do want to draw on a component. You wi ll have to do this whenever you want to display something that is not included a mong the standard, pre-defined

273 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 260 your own component class component classes. When you want to do this, you have to define and provide a method in that class for drawing the component. I will always use a subclass when I need a drawing surface of this kind, as I did for the of HelloWorldDisplay JPanel class in the example in the previous section. A JPanel, like any JComponent, draws its content in the method public void paintComponent(Graphics g) To create a drawing surface, you should define a subclass of JPanel and provide a custom paintComponent() method. Create an object belonging to this class and use it in your pro- screen, the system gram. When the time comes for your component to be drawn on the to do the drawing. That is, the code that you put into the will call its paintComponent() paintComponent() n the method will be executed whenever the panel needs to be drawn o screen; by writing this method, you determine the picture th at will be displayed in the panel. paintComponent() Note that you are not likely to call a method any more than you are likely to call a routine. The system calls the method. You write the method to say what will main() happen when the system calls it. Note that the method has a parameter of type Graphics . The Graphics paintComponent() d. You need this object to object will be provided by the system when it calls your metho d a . A do the actual drawing. To do any drawing at all in Java, you nee graphics context java.awt.Graphics . Instance methods graphics context is an object belonging to the class es. Any given Graphics object are provided in this class for drawing shapes, text, and imag can draw to only one location. In this chapter, that location will always be a GUI component belonging to some subclass of JPanel . The Graphics class is an abstract class, which means that it is impossible to create a graphics context directly, with a constructor. There are actually First of all, of course, when two ways to get a graphics context for drawing on a component: method of a component is called by the system, the parameter t o that the paintComponent() method is a graphics context for drawing on the component. Se cond, every component has an instance method called getGraphics() . This method is a function that returns a graphics its paintComponent() method. context that can be used for drawing on the component outside not The official line is that you should do this, and I will almost always avoid it. But I have getGraphics() in a few examples. (Note that if g found it convenient to use is a graphics context created with getGraphics() , it is good form to call g.dispose() when finished using it. This releases any operating system resources that might be held by g .) The paintComponent() JPanel class simply fills the panel with the panel’s method in the JPanel for use as a drawing surface, you will background color. When defining a subclass of e drawing other content onto usually want to fill the panel with the background color befor the panel (although it is not necessary to do this if the drawi ng commands in the method cover the background of the component completely). This is t raditionally done with a call to super.paintComponent(g) , so most paintComponent() methods that you write will have the form: public void paintComponent(g) { super.paintComponent(g); . . . // Draw the content of the component. } ∗ ∗ ∗ In general, a component should do all drawing operations in i ts paintComponent() method. What happens if, in the middle of some other method, you reali ze that the content of the

274 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 261 not call directly to make the component needs to be changed? You should paintComponent() nent needs to be redrawn, and change. Instead, you have to inform the system that the compo let the system do its job by calling . You do this by calling the component’s paintComponent() repaint() method. The method public void repaint(); class, and so can be used with any component. You should call is defined in the Component t is important to to inform the system that the component needs to be redrawn. I repaint() understand that the repaint() method returns immediately, without doing any painting its elf. The system will call the component’s method later , as soon as it gets a paintComponent() chance to do so, after processing other pending events if the re are any. It is even possible that repaint() paintComponent() , if the calls to many calls to will all be handled by one call to repaint() occur in a very short timespan. paintComponent() Note that the system can also call for other reasons. It is called when the component first appears on the screen. It will also be call ed if the size of the component changes, which can happen when the user resizes the window th at contains the component. This means that paintComponent() should be capable of redrawing the content of the component on demand. As you will see, however, some of our early example s will not be able to do this correctly. This means that, to work properly, the method must be smart enough paintComponent() ssible, a program should store to correctly redraw the component at any time. To make this po nt. These variables should contain data in its instance variables about the state of the compone all the information necessary to redraw the component compl etely. The paintComponent() o draw. When the program method should use the data in these variables to decide what t wants to change the content of the component, it should not si mply draw the new content. It should change the values of the relevant variables and cal l repaint() . When the system calls paintComponent() , that method will use the new values of the variables and will draw the component with the desired modifications. This might see m a roundabout way of doing things. Why not just draw the modifications directly? There a re at least two reasons. First of all drawing is done in one method. all, it really does turn out to be easier to get things right if Second, even if you could directly draw the modifications, yo u would still have to save enough paintComponent() to redraw the component information about the modifications to enable correctly on demand. You will see how all this works in practice as we work through e xamples in the rest of this chapter. For now, we will spend the rest of this section looki ng at how to get some actual drawing done. 6.2.1 Coordinates The screen of a computer is a grid of little squares called pixels . The color of each pixel can be set individually, and drawing on the screen just means setti ng the colors of individual pixels.

275 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 262 x < = > ? @A < x E y = 0 y B D > A A @ < sition in the rectangle A graphics context draws in a rectangle made up of pixels. A po is specified by a pair of integer coordinates, (x,y) . The upper left corner has coordinates . The x coordinate increases from left to right, and the (0,0) coordinate increases from top y to bottom. The illustration shows a 20-pixel by 12-pixel com ponent (with very large pixels). A wn by coloring individual pixels. small line, rectangle, and oval are shown as they would be dra g to the pixels but to the grid lines (Note that, properly speaking, the coordinates don’t belon between them.) For any component, you can find out the size of the rectangle th at it occupies by calling getWidth() and the instance methods , which return the number of pixels in the getHeight() horizontal and vertical directions, respectively. In gene ral, it’s not a good idea to assume that you know the size of a component, since the size is often set by a layout manager and can even change if the component is in a window and that window is r esized by the user. This means that it’s good form to check the size of a component befo re doing any drawing on that component. For example, you can use a paintComponent() method that looks like: public void paintComponent(Graphics g) { super.paintComponent(g); t. int width = getWidth(); // Find out the width of this componen int height = getHeight(); // Find out its height. . . . // Draw the content of the component. } Of course, your drawing commands will have to take the size in to account. That is, they will have to use coordinates that are calculated based on the actual height a nd width of (x,y) the component. (However, if you are sure that you know the siz e, using constants for the width and height can make the drawing easier.) 6.2.2 Colors You will probably want to use some color when you draw. Java is designed to work with the RGB color system . An RGB color is specified by three numbers that give the level of red, green, and blue, respectively, in the color. A color i n Java is an object of the class, java.awt.Color . You can construct a new color by specifying its red, blue, an d green compo- nents. For example, Color myColor = new Color(r,g,b); There are two constructors that you can call in this way. In th e one that I almost al- ways use, r , g , and b are integers in the range 0 to 255. In the other, they are num- bers of type float in the range 0.0F to 1.0F. (Recall that a literal of type float is written

276 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 263 double number.) Often, you can avoid constructing with an “F” to distinguish it from a class defines several named constants representing com- Color new colors altogether, since the Color.BLUE Color.BLACK Color.RED , Color.GREEN Color.WHITE , , Color.CYAN , , mon colors: , Color.YELLOW Color.MAGENTA Color.PINK , Color.ORANGE , Color.LIGHT GRAY , Color.GRAY , , , Color.DARK and GRAY . (There are older, alternative names for these constants th at use lower instead of case rather than upper case constants, such as , but the upper Color.RED case versions are preferred because they follow the convent ion that constant names should be upper case.) An alternative to RGB is the HSB color system . In the HSB system, a color is specified by , the brightness , and the hue . The hue is the basic color, saturation three numbers called the of the rainbow. The brightness is ranging from red through orange through all the other colors pretty much what it sounds like. A fully saturated color is a p ure color tone. Decreasing the lor. In Java, the hue, saturation saturation is like mixing white or gray paint into the pure co and brightness are always specified by values of type float in the range from 0.0F to 1.0F. The class has a member function named getHSBColor for creating HSB colors. To Color static h create the color with HSB values given by s , and b , you can say: , Color myColor = Color.getHSBColor(h,s,b); For example, to make a color with a random hue that is as bright and as saturated as possible, you could use: Color randomColor = Color.getHSBColor( (float)Math.rand om(), 1.0F, 1.0F ); Math.random() is of type , The type cast is necessary because the value returned by double requires values of type float Color.getHSBColor() and . (By the way, you might ask why RGB colors are created using a constructor while HSB colors a re created using a static member function. The problem is that we would need two different cons tructors, both of them with float . Unfortunately, this is impossible. You can have two constr uctors three parameters of type .) only if the number of parameters or the parameter types differ cribing the same set of The RGB system and the HSB system are just different ways of des e other. The best way to understand colors. It is possible to translate between one system and th the color systems is to experiment with them. (The sample pro gram lets you do that. You won’t understand the source code at this time, but you can run it to play with color selection or to find the RGB or HSB values for the col or that want.) ∗ ∗ ∗ One of the properties of a Graphics object is the current drawing color, which is used for all drawing of shapes and text. If g is a graphics context, you can change the current drawing color for g g.setColor(c) , where c is a Color . For example, if you want using the method g.setColor(Color.GREEN) before doing the drawing. to draw in green, you would just say The graphics context continues to use the color until you exp licitly change it with another setColor() command. If you want to know what the current drawing color is , you can call the function g.getColor() , which returns an object of type Color . This can be useful if you want to change to another drawing color temporarily and then rest ore the previous drawing color. Every component has an associated foreground color and background color . Generally, the component is filled with the background color before anyt hing else is drawn (although some components are “transparent,” meaning that the background color is ignored). When a new graphics context is created for a component, the current dra wing color is set to the foreground color. Note that the foreground color and background color a re properties of the component, not of a graphics context.

277 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 264 t by calling instance meth- The foreground and background colors of a component can be se and component.setBackground(color) , which are ods component.setForeground(color) class and therefore are available for use with any component Component . This defined in the can be useful even for standard components, if you want them t o use colors that are different from the defaults. 6.2.3 Fonts represents a particular size and style of text. The same char acter will appear different A font ame, a style, and a size. The in different fonts. In Java, a font is characterized by a font n available font names are system dependent, but you can alway s use the following four strings as font names: “Serif”, “SansSerif”, “Monospaced”, and “Dial og”. (A “serif” is a little decoration on a character, such as a short horizontal line at the bottom o f the letter i. “SansSerif” means “without serifs.” “Monospaced” means that all the characte rs in the font have the same width. The “Dialog” font is the one that is typically used in dialog b oxes.) defined in the Font The style of a font is specified using named constants that are class. You can specify the style as one of the four values: Font.PLAIN • , • Font.ITALIC , • , or Font.BOLD • Font.BOLD + Font.ITALIC . The size of a font is an integer. Size typically ranges from ab out 9 to 36, although larger sizes can also be used. The size of a font is usually about equa l to the height of the largest characters in the font, in pixels, but this is not an exact rul e. The size of the default font is 12. Java uses the class named java.awt.Font for representing fonts. You can construct a new font by specifying its font name, style, and size in a constru ctor: Font plainFont = new Font("Serif", Font.PLAIN, 12); Font bigBoldFont = new Font("SansSerif", Font.BOLD, 24); Every graphics context has a current font, which is used for d rawing text. You can change method. For example, if g setFont() the current font with the is a graphics context and bigBoldFont is a font, then the command g.setFont(bigBoldFont) will set the current font of to bigBoldFont . The new font will be used for any text that is drawn after the setFont() g command is given. You can find out the current font of g by calling the method g.getFont() , which returns an object of type Font . Every component also has an associated font. It can be set wit h the instance method component.setFont(font) , which is defined in the Component class. When a graphics context is created for drawing on a component, the graphic context’s current font is set equal to the font of the component. 6.2.4 Shapes The Graphics class includes a large number of instance methods for drawin g various shapes, such as lines, rectangles, and ovals. The shapes are specifie (x,y) coordinate system d using the described above. They are drawn in the current drawing color of the graphics context. The current drawing color is set to the foreground color of the co mponent when the graphics context is created, but it can be changed at any time using the setColor() method.

278 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 265 Subsection 3.9.1 . Here, I describe those Some drawing methods were already listed in nds, any drawing that is methods in more detail and add a few more. With all these comma e that all these methods are in done outside the boundaries of the component is ignored. Not Graphics Graphics . It is shown class, so they all must be called through an object of type the grammer. here as g , but of course the name of the graphics context is up to the pro str . — Draws the text given by the string g.drawString(String str, int x, int y) • x specifies The string is drawn using the current color and font of the gra phics context. y the x-coordinate of the left end of the string. is the y-coordinate of the baseline of the ters rest. Some parts of the string. The baseline is a horizontal line on which the charac characters, such as the tail on a y or g, extend below the basel ine. — Draws a line from the point • g.drawLine(int x1, int y1, int x2, int y2) (x2,y2) . The line is drawn as if with a pen that extends one pixel to to the point (x1,y1) (x,y) the right and one pixel down from the point where the pen is located. For example, if refers to an object of type Graphics , then the command g.drawLine(x,y,x,y) , which g gle pixel with upper left corresponds to putting the pen down at a point, colors the sin . Remember that coordinates really refer to the lines betwee n corner at the point (x,y) the pixels. • — Draws the outline of a rect- g.drawRect(int x, int y, int width, int height) angle. The upper left corner is at (x,y) , and the width and height of the rectangle are width equals height as specified. If width or the , then the rectangle is a square. If the height th the same pen is negative, then nothing is drawn. The rectangle is drawn wi drawLine() . This means that the actual width of the rectangle as drawn that is used for width+1 , and similarly for the height. There is an extra pixel along t he right edge is and the bottom edge. For example, if you want to draw a rectang le around the edges of the component, you can say “ g.drawRect(0, 0, getWidth()-1, getHeight()-1); ”. If you use “ g.drawRect(0, 0, getWidth(), getHeight()); ”, then the right and bottom outside the component and will not appear on the edges of the rectangle will be drawn screen. g.drawOval(int x, int y, int width, int height) — Draws the outline of an oval. • , y The oval is one that just fits inside the rectangle specified by width , and height . If x , equals width , the oval is a circle. height • am, int ydiam) — g.drawRoundRect(int x, int y, int width, int height, int xdi sic rectangle is specified by Draws the outline of a rectangle with rounded corners. The ba , y , x , and height , but the corners are rounded. The degree of rounding is given by width xdiam and ydiam . The corners are arcs of an ellipse with horizontal diameter xdiam and vertical diameter ydiam xdiam and ydiam is 16, but the value used . A typical value for should really depend on how big the rectangle is. • ised) — Draws g.draw3DRect(int x, int y, int width, int height, boolean ra the outline of a rectangle that is supposed to have a three-di mensional effect, as if it is raised from the screen or pushed into the screen. The basic rectangle is specified by x , y , width , and height . The raised parameter tells whether the rectangle seems to be raised from the screen or pushed into it. The 3D effect is achie ved by using brighter and darker versions of the drawing color for different edges of th e rectangle. The documen- tation recommends setting the drawing color equal to the bac kground color before using this method. The effect won’t work well for some colors. • g.drawArc(int x, int y, int width, int height, int startAngl e, int arcAngle)

279 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 266 cified by x y , width , and — Draws part of the oval that just fits inside the rectangle spe , arcAngle . The part drawn is an arc that extends height degrees from a starting angle at startAngle degrees. Angles are measured with 0 degrees at the 3 o’clock p osition (the positive direction of the horizontal axis). Positive angle s are measured counterclockwise t an arc of a circle, make from zero, and negative angles are measured clockwise. To ge width is equal to height . sure that • g.fillRect(int x, int y, int width, int height) — Draws a filled-in rectan- This fills in the interior of the rectangle that would be d rawn by gle. . The extra pixel along the bottom and right edges is drawRect(x,y,width,height) width and parameters give the exact width and height of the not included. The height ponent, you could say rectangle. For example, if you wanted to fill in the entire com “ ” g.fillRect(0, 0, getWidth(), getHeight()); • g.fillOval(int x, int y, int width, int height) — Draws a filled-in oval. g.fillRoundRect(int x, int y, int width, int height, int xdi • — am, int ydiam) Draws a filled-in rounded rectangle. g.fill3DRect(int x, int y, int width, int height, boolean ra ised) — Draws • a filled-in three-dimensional rectangle. g.fillArc(int x, int y, int width, int height, int startAngl e, int arcAngle) • — Draw a filled-in arc. This looks like a wedge of pie, whose cru st is the arc that would be drawn by the drawArc method. 6.2.5 Graphics2D All drawing in Java is done through an object of type . The Graphics class provides Graphics for selecting a drawing color. basic commands for such things as drawing shapes and text and hort of what’s needed in a These commands are adequate in many cases, but they fall far s serious computer graphics program. Java has another class, Graphics2D , that provides a larger Graphics2D is a sub-class of Graphics , so all the methods from the set of drawing operations. Graphics class are also available in a . Graphics2D paintComponent() method of a The gives you a graphics context of type JComponent Graphics that you can use for drawing on the component. In fact, the gra phics context actu- ally belongs to the sub-class Graphics2D , and can be type-cast to gain access to the advanced Graphics2D drawing methods: public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2; g2 = (Graphics2D)g; . . // Draw on the component using g2. . } I mention Graphics2D here for completeness. I will cover some important aspects o f Graph- ics2D in Section 13.2 , but a full treatment is more than we will have time for in this book. However, there are two simple applications that I would like to start using now, without ex- plaining how they work. If g2 is a variable of type Graphics2D , as in the paintComponent() method above, then the intimidating-looking command

280 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 267 ANTIALIASING, g2.setRenderingHint( RenderingHints.KEY ON ); RenderingHints.VALUE ANTIALIAS jagged appearance that can be seen turns on antialiasing in the graphics context. Aliasing is a when shapes are drawn using pixels. Antialiasing tries to re duce the jaggedness. It can make diagonal lines and the outlines of ovals look much nicer. It c an also improve the appearance of text. Another useful command is g2.setStroke( new BasicStroke(lineWidth) ); is an integer or a float. This command can be used to draw thicke r lines. where lineWidth pixels wide. This also affects the thickness lineWidth Lines drawn after the command will be of the outlined shapes drawn by methods such as g.drawRect and g.drawOval() . 6.2.6 An Example Let’s use some of the material covered in this section to writ JPanel for use as a e a subclass of drawing surface. All the drawing will be done in the method of the panel paintComponent() ack background. Each copy of class. The panel will draw multiple copies of a message on a bl , with different sizes and styles. the message is in a random color. Five different fonts are used The message can be specified in the constructor; if the defaul t constructor is used, the message is the string “Java!”. The panel works OK no matter what its si ze. nel’s paintComponent() There is one problem with the way this class works. When the pa ions for the messages. The informa- method is called, it chooses random colors, fonts, and locat tion about which colors, fonts, and locations are used is not stored anywhere. The next time paintComponent() is called, it will make different random choices and will draw a different picture. If you resize a window containing the panel, the pic ture will be continually redrawn as the size of the window is changed! To avoid that, you would sto re enough information about the picture in instance variables to enable the paintComponent() method to draw the same picture each time it is called. The source code for the panel class is shown below. I use an ins message tance variable called to hold the message that the panel will display. There are five instance variables of type Font that represent different sizes and styles of text. These vari ables are initialized in the constructor paintComponent() method. and are used in the paintComponent() The r method for the panel simply draws 25 copies of the message. Fo s each copy, it chooses one of the five fonts at random, and it use to select that g.setFont() font for drawing. It creates a random HSB color and uses g.setColor() to select that color for drawing. It then chooses random (x,y) coordinates for the location of the message. The x coordinate gives the horizontal position of the left end of t he string. The formula used for the coordinate is “ -50 + (int)(Math.random() * (width+40)) ”. This gives a random integer x -50 to width-10 . This makes it possible for the string to extend beyond the in the range from left edge or the right edge of the panel. Similarly, the formu la for y allows the string to extend beyond the top and bottom. Here is the complete source code for the RandomStringsPanel : import java.awt.*; import javax.swing.JPanel; /** * This panel displays 25 copies of a message. The color and * position of each message is selected at random. The font

281 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 268 * of each message is randomly chosen from among five possible * fonts. The messages are displayed on a black background. * Note: The style of drawing used here is poor, because every * time the paintComponent() method is called, new random val ues are * used. This means that a different picture will be drawn each time. */ public class RandomStringsPanel extends JPanel { private String message; // The message to be displayed. This can be set in // the constructor. If no value is provided in the // constructor, then the string "Java!" is used. private Font font1, font2, font3, font4, font5; // The five f onts. /** age "Java!". * Default constructor creates a panel that displays the mess */ public RandomStringsPanel() { ull. this(null); // Call the other constructor, with parameter n } /** * Constructor creates a panel to display 25 copies of a specif ied message. * @param messageString The message to be displayed. If this i s null, * then the default message "Java!" is displayed. */ public RandomStringsPanel(String messageString) { message = messageString; if (message == null) message = "Java!"; font1 = new Font("Serif", Font.BOLD, 14); ; font2 = new Font("SansSerif", Font.BOLD + Font.ITALIC, 24) font3 = new Font("Monospaced", Font.PLAIN, 30); font4 = new Font("Dialog", Font.PLAIN, 36); font5 = new Font("Serif", Font.ITALIC, 48); setBackground(Color.BLACK); } /** * The paintComponent method is responsible for drawing the c ontent of the panel. * It draws 25 copies of the message string, using a random colo r, font, and * position for each string. */ public void paintComponent(Graphics g) { super.paintComponent(g); // Call the paintComponent meth od from the // superclass, JPanel. This simply fills the // entire panel with the background color, black. Graphics2D g2 = (Graphics2D)g; // (To make the text smoother .) ANTIALIASING, g2.setRenderingHint( RenderingHints.KEY RenderingHints.VALUE ANTIALIAS ON ); int width = getWidth(); int height = getHeight();

282 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 269 for (int i = 0; i < 25; i++) { // Draw one string. First, set the font to be one of the five // available fonts, at random. int fontNum = (int)(5*Math.random()) + 1; switch (fontNum) { case 1: g.setFont(font1); break; case 2: g.setFont(font2); break; case 3: g.setFont(font3); break; case 4: g.setFont(font4); break; case 5: g.setFont(font5); break; } // end switch // Set the color to a bright, saturated color, with random hue . float hue = (float)Math.random(); g.setColor( Color.getHSBColor(hue, 1.0F, 1.0F) ); // Select the position of the string, at random. int x,y; x = -50 + (int)(Math.random()*(width+40)); y = (int)(Math.random()*(height+20)); // Draw the message. g.drawString(message,x,y); } // end for } // end paintComponent() } // end class RandomStringsPanel 6.2.7 Where is main()? Random- The source code for the RandomStringsPanel class can be found in the example file . You can compile that file, but you won’t be able to run the comp iled class. The problem is that the class doesn’t have a main() routine. Only a class that has a main() routine can be run as a program. JPanel is not something that can stand on its own. It has to Another problem is that a be placed into a container such as another panel or a window. I n general, to make a complete program, we need a main() routine that will create a window of type JFrame . It can then create

283 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 270 main() routine that does a panel and place the panel in the window. Here is a class with a this: import javax.swing.JFrame; public class RandomStrings { public static void main(String[] args) { JFrame window = new JFrame("Java!"); RandomStringsPanel content = new RandomStringsPanel(); window.setContentPane(content); window.setDefaultCloseOperation(JFrame.EXIT ON CLOSE); window.setLocation(120,70); window.setSize(350,250); window.setVisible(true); } } . You can compile and run the program, as This class is defined by the file RandomStringsPanel long as the class is also available. The main routine is not logically a part of the panel class. It is just one way of using a main() panel. However, it’s possible to include as part of the panel class, even if it doesn’t logically belong there. This makes it possible to run the pan el class as a program, and it has the advantage of keeping everything in one file. For an exampl e, you can look at Random- , which is identical to the original class except for the addi tion of a main() routine. Although it might not be great style, I will usually take a similar approach in future examples. I am not going to discuss the details of using JFrame here, but you can look ahead and find them in Subsection 6.7.3 . You won’t completely understand my main() routines until you read that section. 6.3 Mouse Events vents are central doesn’t E to programming for a graphical user interface. A GUI program have a main() routine that outlines what will happen when the program is ru n, in a step-by-step repared to respond to various process from beginning to end. Instead, the program must be p an order that the program doesn’t kinds of events that can happen at unpredictable times and in control. The most basic kinds of events are generated by the m ouse and keyboard. The user can press any key on the keyboard, move the mouse, or press a bu tton on the mouse. The user can do any of these things at any time, and the computer has to r espond appropriately. In Java, events are represented by objects. When an event occ urs, the system collects all the information relevant to the event and constructs an obje ct to contain that information. Different types of events are represented by objects belongi ng to different classes. For example, when the user presses one of the buttons on a mouse, an object b elonging to a class called MouseEvent is constructed. The object contains information such as the source of the event (that is, the component on which the user clicked), the (x,y) coordinates of the point in the component where the click occurred, the exact time of the cli ck, and which button on the mouse was pressed. When the user presses a key on the keyboard, a KeyEvent is created. After the event object is constructed, it can be passed as a parameter t o a designated method. By writing that method, the programmer says what should happen when the event occurs.

284 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 271 ts. There is a lot of processing As a Java programmer, you get a fairly high-level view of even that goes on between the time that the user presses a key or mov es the mouse and the time vent. Fortunately, you don’t that a subroutine in your program is called to respond to the e need to know much about that processing. But you should under stand this much: Even though you didn’t write it, there is a routine running somewhere tha t executes a loop of the form while the program is still running: Wait for the next event to occur Call a subroutine to handle the event . Every GUI program has an event loop. In Java, you This loop is called an event loop don’t have to write the loop. It’s part of “the system.” If you write a GUI program in some other language, you might have to provide a main routine that runs the event loop. In this section, we’ll look at handling mouse events in Java, and we’ll cover the framework for handling events in general. The next section will cover k eyboard-related events and timer events. Java also has other types of events, which are produc ed by GUI components. These will be introduced in . Section 6.5 6.3.1 Event Handling For an event to have any effect, a program must detect the event and react to it. In order to detect an event, the program must “listen” for it. Listening for events is something that is done by an object called an event listener . An event listener object must contain instance methods for handling the events for which it listens. For example, if an object is to serve as a listener for MouseEvent , then it must contain the following method (among several ot events of type hers): public void mousePressed(MouseEvent evt) { . . . } s notified that a mouse button The body of the method defines how the object responds when it i has been pressed. The parameter, evt , contains information about the event. This information can be used by the listener object to determine its response. The methods that are required in a mouse event listener are sp ecified in an interface named MouseListener . To be used as a listener for mouse events, an object must impl ement this MouseListener interfaces were covered in interface. Java . (To review briefly: Section 5.7 interface in Java is just a list of instance methods. A class can “implem ent” an in- An terface by doing two things: First, the class must be declare d to implement the interface, as class MouseHandler implements MouseListener ” or “ class MyPanel extends JPanel in “ ”; and second, the class must include a definition for each ins implements MouseListener tance interface can be used as the type for a variable or method specified in the interface. An object implements the MouseListener interface if it belongs formal parameter. We say that an to a class that implements the MouseListener interface. Note that it is not enough for the object to include the specified methods. It must also belong to a clas s that is specifically declared to implement the interface.) Many events in Java are associated with GUI components. For e xample, when the user presses a button on the mouse, the associated component is th e one that the user clicked on. Before a listener object can “hear” events associated with a given component, the listener object must be registered with the component. If a MouseListener object, mListener , needs to hear mouse events associated with a Component object, comp , the listener must be registered with the component by calling comp.addMouseListener(mListener);

285 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 272 addMouseListener() method is an instance method in class , and so can be The Component we will listen for events on a used with any GUI component object. In our first few examples, JPanel that is being used as a drawing surface. The event classes, such as MouseEvent , and the listener interfaces, such as MouseListener , are defined in the package java.awt.event . This means that if you want to work with events, you import java.awt.event.*; ” at the beginning of your source should either include the line “ code file or import the individual classes and interfaces. Admittedly, there is a large number of details to tend to when you want to use events. To summarize, you must Put the import specification “ import java.awt.event.*; 1. ” (or individual imports) at the beginning of your source code; Declare that some class implements the appropriate listene r interface, such as 2. MouseLis- ; tener 3. Provide definitions in that class for the methods specified by the interface; 4. Register an object that belongs to the listener class with th e component that will generate the events by calling a method such as in the component. addMouseListener() Any object can act as an event listener, provided that it impl ements the appropriate in- terface. A component can listen for the events that it itself generates. A panel can listen for events from components that are contained in the panel. A spe cial class can be created just for the purpose of defining a listening object. Many people co nsider it to be good form to use anonymous inner classes to define listening objects (see Subsection 5.8.3 ), and named nested classes can also be appropriate. You will see all of these pat terns in examples in this textbook. 6.3.2 MouseEvent and MouseListener The interface specifies these five instance methods: MouseListener public void mousePressed(MouseEvent evt); public void mouseReleased(MouseEvent evt); public void mouseClicked(MouseEvent evt); public void mouseEntered(MouseEvent evt); public void mouseExited(MouseEvent evt); mousePressed method is called as soon as the user presses down on one of the m ouse The mouseReleased buttons, and is called when the user releases a button. These are the two bject must define all five methods that are most commonly used, but any mouse listener o methods; you can leave the body of a method empty if you don’t w ant to define a response. The mouseClicked method is called if the user presses a mouse button and then re leases it, without moving the mouse. (When the user does this, all th ree routines— mousePressed , mouseReleased mouseClicked —will be called in that order.) In most cases, you should , and define mousePressed instead of mouseClicked . The mouseEntered and mouseExited methods are called when the mouse cursor enters or leaves the compone nt. For example, if you want the component to change appearance whenever the user moves the m ouse over the component, you could define these two methods. As a first example, we will look at a small addition to the RandomStringsPanel example from the previous section. In the new version, the panel will repa int itself when the user clicks on it. In order for this to happen, a mouse listener should listen fo r mouse events on the panel, and

286 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 273 mousePressed event, it should respond by calling the when the listener detects a repaint() method of the panel. ements the For the new version of the program, we need an object that impl MouseListener interface. One way to create the object is to define a separate class, such as: import java.awt.Component; import java.awt.event.*; /** * An object of type RepaintOnClick is a MouseListener that * will respond to a mousePressed event by calling the repaint () * method of the source of the event. That is, a RepaintOnClick * object can be added as a mouse listener to any Component; * when the user clicks that component, the component will be * repainted. */ public class RepaintOnClick implements MouseListener { public void mousePressed(MouseEvent evt) { Component source = (Component)evt.getSource(); source.repaint(); // Call repaint() on the Component that w as clicked. } public void mouseClicked(MouseEvent evt) { } public void mouseReleased(MouseEvent evt) { } public void mouseEntered(MouseEvent evt) { } public void mouseExited(MouseEvent evt) { } } This class does three of the four things that we need to do in or der to handle mouse events: First, java.awt.event.* for easy access to event-related classes. Second, it is decl ared it imports implements MouseListener ”. And third, it provides definitions for the five that the class “ methods that are specified in the MouseListener interface. (Note that four of the methods have empty bodies, since we don’t want to do anything in response t o those events.) We must do one more thing to set up the event handling for this e xample: We must register an event-handling object as a listener with the component th at will generate the events. In this case, the mouse events that we are interested in will be g enerated by an object of type . If is a variable that refers to the panel object, we can create a RandomStringsPanel panel mouse listener object and register it with the panel with the statements: RepaintOnClick listener = new RepaintOnClick(); // Create MouseListener object. panel.addMouseListener(listener); // Register MouseLis tener with the panel. main() This could be done, for example, in the routine where the panel is created. Once the listener ents on the panel. When has been registered in this way, it will be notified of mouse ev mousePressed a mousePressed() method in the listener will be called. The event occurs, the code in this method calls the repaint() method in the component that is the source of the event, that is, in the panel. The result is that the is repainted with its RandomStringsPanel strings in new random colors, fonts, and positions. Although we have written the RepaintOnClick class for use with our RandomStringsPanel example, the event-handling class contains no reference at all to the RandomStringsPanel class. How can this be? The mousePressed() method in class RepaintOnClick looks at the source of the event, and calls its repaint() method. If we have registered the RepaintOnClick object

287 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 274 RandomStringsPanel , then it is that panel that is repainted. But the listener as a listener on a object could be used with any type of component, and it would w ork in the same way. Similarly, the class contains no reference to the RepaintOnClick class— RandomStringsPanel in fact, RandomStringsPanel was written before we even knew anything about mouse events! ered with it as a mouse listener. The panel will send mouse events to any object that has regist It does not need to know anything about that object except tha t it is capable of receiving mouse events. nd an object that responds The relationship between an object that generates an event a gistering one object to listen for to that event is rather loose. The relationship is set up by re ntially be done from outside events from the other object. This is something that can pote ith no knowledge of the internal both objects. Each object can be developed independently, w operation of the other object. This is the essence of modular design : Build a complex system o understand ways. Then each out of modules that interact only in straightforward, easy t endently. Java’s event-handling module is a separate design problem that can be tackled indep framework is designed to offer strong support for modular des ign. To make this clearer, let’s look at a new version of , the program from Subsection 6.2.7 that uses RandomStringsPanel . The new version is ClickableRandom- . For convenience, I have added as a static nested class, although it RepaintOnClick would work just as well as a separate class: import java.awt.Component; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import javax.swing.JFrame; /** in * Displays a window that shows 25 copies of the string "Java!" * random colors, fonts, and positions. The content of the win dow * is an object of type RandomStringsPanel. When the user clic ks * the window, the content of the window is repainted, with the * strings in newly selected random colors, fonts, and positi ons. */ public class ClickableRandomStrings { public static void main(String[] args) { JFrame window = new JFrame("Click Me to Redraw!"); RandomStringsPanel content = new RandomStringsPanel(); content.addMouseListener( new RepaintOnClick() ); window.setContentPane(content); ON CLOSE); window.setDefaultCloseOperation(JFrame.EXIT window.setLocation(120,70); window.setSize(350,250); window.setVisible(true); } private static class RepaintOnClick implements MouseList ener { public void mousePressed(MouseEvent evt) { Component source = (Component)evt.getSource(); source.repaint(); } public void mouseClicked(MouseEvent evt) { } public void mouseReleased(MouseEvent evt) { }

288 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 275 public void mouseEntered(MouseEvent evt) { } public void mouseExited(MouseEvent evt) { } } } end class ClickableRandomStrings 6.3.3 MouseEvent Data n of the mouse cursor. This Often, when a mouse event occurs, you want to know the locatio information is available from the parameter to the event-handling method, which MouseEvent contains instance methods that return information about th evt is the parame- e event. If ter, then you can find out the coordinates of the mouse cursor b and y calling evt.getX() . These methods return integers which give the x and y coordinates where the evt.getY() mouse cursor was positioned at the time when the event occurr ed. The coordinates are ex- pressed in the coordinate system of the component that gener ated the event, where the top left corner of the component is (0,0). modifier keys The user can hold down certain while using the mouse. The possible modifier keys include: the Shift key, the Control key, the Alt key (cal led the Option key on the Mac), and the Meta key (called the Command or Apple key on the Mac). Y ou might want to respond to a mouse event differently when the user is holding down a mod ifier key. The boolean- evt.isShiftDown() , evt.isControlDown() valued instance methods evt.isAltDown() , and , evt.isMetaDown() can be called to test whether the modifier keys are pressed. You might also want to have different responses depending on w hether the user presses the left mouse button, the middle mouse button, or the right m ouse button. For events triggered by a mouse button, you can determine which button w as pressed or released by calling evt.getButton() , which returns one of the integer constants MouseEvent.BUTTON1 , MouseEvent.BUTTON2 , or for the left, middle, and right buttons. MouseEvent.BUTTON3 triggered by buttons, For events such as mouseEntered and mouseExited that are not returns MouseEvent.NOBUTTON . evt.getButton() Now, not every mouse has a middle button and a right button, an d Java deals with he right mouse button, then that fact in a somewhat peculiar way. If the user clicks with t evt.isMetaDown() a key. Sim- will return true, even if the user was not holding down the Met ilarly, if the user clicks with the middle mouse button, then evt.isAltDown() will return true, even if the user is not holding down the Alt/Option key. By usi ng these functions, you can design an interface that will work even on computers that lac k a middle or right mouse but- ton. Note that there is a subtle difference between these func tions and evt.getButton() : evt.getButton() really only applies to mousePressed, mouseReleased, and mo useClicked evt.isMetaDown() and events, while are useful in any mouse event. I will evt.isAltDown() often use them instead of evt.getButton() . As an example, consider a JPanel that does the following: Clicking on the panel with the left mouse button will place a red rectangle on the panel at th e point where the mouse was clicked. Clicking with the right mouse button will place a bl ue oval on the panel. Holding down the Shift key while clicking will clear the panel by remo ving all the shapes that have been placed. You can try the sample program . Here is what the panel looks like after some shapes have been added:

289 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 276 separate class to handle There are several ways to write this example. There could be a mouse events, as in the previous example. However, in this ca se, I decided to let the panel itself s long as it implements the respond to mouse events. Any object can be a mouse listener, a MouseListener interface, MouseListener interface. In this case, the panel class implements the so the object that represents the main panel of the program ca n be the mouse listener for the program. The constructor for the panel class contains the st atement addMouseListener(this); this.addMouseListener(this) . Now, the ordinary way to reg- which is equivalent to saying X.addMouseListener(Y) ister a mouse listener is to say Y is the listener and X is the where ent component that will generate the mouse events. In the statem , addMouseListener(this) both roles are played by this ; that is, “this object” (the panel) is generating mouse even ts and is also listening for those events. Although this might s eem a little strange, you should get used to seeing things like this. In a large program, however, it’s usually a better idea to write a separate class to do the listening in order to have a more orga nized division of responsibilities. uded a routine to The source code for the panel class is shown below. I have incl main() Subsection 6.2.7 . You should check how allow the class to be run as a program, as discussed in the instance methods in the object are used. You can also check for the Four Steps MouseEvent of Event Handling (“ import java.awt.event.* ”, “ implements MouseListener ”, definitions for the event-handling methods, and “ addMouseListener ”): import java.awt.*; import java.awt.event.*; import javax.swing.*; /** * A simple demonstration of MouseEvents. Shapes are drawn * on a black background when the user clicks the panel. If * the user Shift-clicks, the panel is cleared. If the user * right-clicks the panel, a blue oval is drawn. Otherwise, * when the user clicks, a red rectangle is drawn. The contents of * the panel are not persistent. For example, they might disap pear * if the panel is resized. * This class has a main() routine to allow it to be run as an appl ication. */ public class SimpleStamper extends JPanel implements Mous eListener {

290 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 277 public static void main(String[] args) { JFrame window = new JFrame("Simple Stamper"); SimpleStamper content = new SimpleStamper(); window.setContentPane(content); ON CLOSE); window.setDefaultCloseOperation(JFrame.EXIT window.setLocation(120,70); window.setSize(450,350); window.setVisible(true); } --------------------- // ------------------------------------------------- /** nel to be black * This constructor simply sets the background color of the pa * and sets the panel to listen for mouse events on itself. */ public SimpleStamper() { setBackground(Color.BLACK); addMouseListener(this); } /** self, * Since this panel has been set to listen for mouse events on it he panel. * this method will be called when the user clicks the mouse on t * This method is part of the MouseListener interface. */ public void mousePressed(MouseEvent evt) { if ( evt.isShiftDown() ) { // The user was holding down the Shift key. Just repaint the pa nel. d, the // Since this class does not define a paintComponent() metho d simply // method from the superclass, JPanel, is called. That metho // fills the panel with its background color, which is black. The // effect is to clear the panel. repaint(); return; } int x = evt.getX(); // x-coordinate where user clicked. int y = evt.getY(); // y-coordinate where user clicked. Graphics g = getGraphics(); // Graphics context for drawing directly. // NOTE: This is considered to be bad style! if ( evt.isMetaDown() ) { tered // User right-clicked at the point (x,y). Draw a blue oval cen // at the point (x,y). (A black outline around the oval will ma ke it // more distinct when shapes overlap.) g.setColor(Color.BLUE); // Blue interior. g.fillOval( x - 30, y - 15, 60, 30 ); g.setColor(Color.BLACK); // Black outline. g.drawOval( x - 30, y - 15, 60, 30 ); } else { // User left-clicked (or middle-clicked) at (x,y). // Draw a red rectangle centered at (x,y).

291 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 278 g.setColor(Color.RED); // Red interior. g.fillRect( x - 30, y - 15, 60, 30 ); g.setColor(Color.BLACK); // Black outline. g.drawRect( x - 30, y - 15, 60, 30 ); } g.dispose(); // We are finished with the graphics context, s o dispose of it. } // end mousePressed(); // The next four empty routines are required by the MouseList ener interface. // They don’t do anything in this class, so their definitions are empty. public void mouseEntered(MouseEvent evt) { } public void mouseExited(MouseEvent evt) { } public void mouseClicked(MouseEvent evt) { } public void mouseReleased(MouseEvent evt) { } } // end class SimpleStamper Note, by the way, that this class violates the rule that all dr awing should be done in a paintComponent() method. The rectangles and ovals are drawn directly in the mousePressed() ntext by saying routine. To make this possible, I need to obtain a graphics co “ ”. After using g for drawing, I call g.dispose() to inform the operating g = getGraphics() g system that I will no longer be using for drawing. I do not advise doing this type of direct n this case. drawing if it can be avoided, but you can see that it does work i 6.3.4 MouseMotionListeners and Dragging Whenever the mouse is moved, it generates events. The operat ing system of the computer detects these events and uses them to move the mouse cursor on the screen. It is also possible for a program to listen for these “mouse motion” events and re spond to them. The most common reason to do so is to implement dragging . Dragging occurs when the user moves the mouse while holding down a mouse button. The methods for responding to mouse motion events are defined in an interface named . This interface specifies two event-handling methods: MouseMotionListener public void mouseDragged(MouseEvent evt); public void mouseMoved(MouseEvent evt); The mouseDragged method is called if the mouse is moved while a button on the mou se , then mouseMoved is pressed. If the mouse is moved while no mouse button is down is called instead. The parameter, evt , is an object of type MouseEvent , which contains the x and y coordinates of the mouse’s location, as usual. As long as the user continues to move the mouse, one of these methods will be called over and over. (So many eve nts are generated that it would be inefficient for a program to hear them all, if it doesn’t want to do anything in response. This is why the mouse motion event-handlers are defined in a separate interface from the other mouse events: You can listen for the mouse events defined in MouseListener without automatically hearing all mouse motion events as well.) If you want your program to respond to mouse motion events, yo u must create an object that implements the interface, and you must register that object to listen MouseMotionListener for events. The registration is done by calling a component’ s addMouseMotionListener() method. The object will then listen for mouseDragged and mouseMoved events associated with

292 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 279 implement the MouseListener that component. In most cases, the listener object will also interface so that it can respond to the other mouse events as w ell. (To get a better idea of how mouse events work, you should try t he sample program Sim- . This program responds to any of the seven different kinds of m ouse events by displaying the coordinates of the mouse, the type of event , and a list of the modifier keys that are down (Shift, Control, Meta, and Alt). You can experi ment with the program to see what happens as you do various things with the mouse. I also en courage you to read the source code. You should now be familiar with all the techniques that it uses.) It is interesting to look at what a program needs to do in order to respond to dragging op- mousePressed() erations. In general, the response involves three methods: mouseDragged() , , and . The dragging gesture starts when the user presses a mouse bu tton, mouseReleased() ser releases the button. This it continues while the mouse is dragged, and it ends when the u esture must be spread out over means that the programming for the response to one dragging g mouseDragged() method can be called many times as the the three methods! Furthermore, the mouse moves. To keep track of what is going on between one meth od call and the next, you need to set up some instance variables. In many applications , for example, in order to process a mouseDragged event, you need to remember the previous coordinates of the m ouse. You can store this information in two instance variables prevX and prevY of type int . It can also be useful to save the starting coordinates, where the original mousePressed event occurred, in boolean dragging , which is set to true instance variables. And I suggest having a variable, while a dragging gesture is being processed. This is necessa ry because in many applications, mousePressed event starts a dragging operation to which you want to respon d. The not every and mouseDragged methods can use the value of dragging to check whether mouseReleased r instance variables as well, but a drag operation is actually in progress. You might need othe in general outline, a class that handles mouse dragging look s like this: import java.awt.event.*; public class MouseDragHandler implements MouseListener, MouseMotionListener { private int startX, startY; // Point where the original mous ePress occurred. oords. private int prevX, prevY; // Most recently processed mouse c private boolean dragging; // Set to true when dragging is in p rocess. . . . // other instance variables for use in dragging public void mousePressed(MouseEvent evt) { if ( we-want-to-start-dragging ) { dragging = true; startX = evt.getX(); // Remember starting position. startY = evt.getY(); prevX = startX; // Remember most recent coords. prevY = startY; . . // Other processing. . } } public void mouseDragged(MouseEvent evt) { if ( dragging == false ) // First, check if we are return; // processing a dragging gesture. int x = evt.getX(); // Current position of Mouse.

293 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 280 int y = evt.getY(); . . // Process a mouse movement from (prevX, prevY) to (x,y). . prevX = x; // Remember the current position for the next call. prevY = y; } public void mouseReleased(MouseEvent evt) { if ( dragging == false ) // First, check if we are return; // processing a dragging gesture. dragging = false; // We are done dragging. . . // Other processing and clean-up. . } } ng the user to sketch a curve by As an example, let’s look at a typical use of dragging: allowi res of graphics and mouse pro- dragging the mouse. This example also shows many other featu ouse on a large white drawing cessing. In the program, you can draw a curve by dragging the m area, and you can select a color for drawing by clicking on one of several colored rectangles to the right of the drawing area. The complete source code can be found in . Here is a picture of the program after some drawing has been do ne: I will discuss a few aspects of the source code here, but I enco urage you to read it carefully in its entirety. There are lots of informative comments in th e source code. ble size, that is, unless the The panel for this example is designed to work for any reasona in terms of the actual width panel is too small. This means that coordinates are computed calling getWidth() and height of the panel. (The width and height are obtained by and getHeight() .) This makes things quite a bit harder than they would be if we assumed some particular fixed size for the panel. Let’s look at some of thes e computations in detail. For example, the large white drawing area extends from y = 3 to y = height - 3 vertically and from to x = width - 56 horizontally. These numbers are needed in order to interpre t x = 3 the meaning of a mouse click. They take into account a gray bor der around the panel and the color palette along the right edge of the panel. The gray bord er is 3 pixels wide. The colored rectangles are 50 pixels wide. Together with the 3-pixel bor der around the panel and a 3-pixel

294 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 281 , this adds up to put the right edge divider between the drawing area and the colored rectangles of the drawing area 56 pixels from the right edge of the panel. ” occupies a 50-by-50 pixel region beneath the colored recta A white square labeled “ CLEAR n- gles on the right edge of the panel. Allowing for this square, we can figure out how much vertical space is available for the seven colored rectangles, and the n divide that space by 7 to get the ver- colorSpace . tical space available for each rectangle. This quantity is r epresented by a variable, Out of this space, 3 pixels are used as spacing between the rec tangles, so the height of each rectangle is colorSpace - 3 . The top of the N -th rectangle is located (N*colorSpace + 3) pixels down from the top of the panel, assuming that we count t he rectangles starting with zero. This is because there are rectangles above the N -th rectangle, each of which uses colorSpace N pixels. The extra 3 is for the border at the top of the panel. Af ter all that, we can write down N the command for drawing the -th rectangle: g.fillRect(width - 53, N*colorSpace + 3, 50, colorSpace - 3) ; That was not easy! But it shows the kind of careful thinking an d precision graphics that are sometimes necessary to get good results. Select a color, clear the The mouse in this program is used to do three different things: agging, so not every mouse drawing, and draw a curve. Only the third of these involves dr click will start a dragging operation. The mousePressed() method has to look at the (x,y) coordinates where the mouse was clicked and decide how to res pond. If the user clicked on the CLEAR rectangle, the drawing area is cleared by calling repaint() . If the user clicked somewhere in the strip of colored rectangles, the correspon ding color is selected for drawing. ch is done by dividing the y This involves computing which color the user clicked on, whi . Finally, if the user clicked on the drawing area, a drag oper ation is coordinate by colorSpace initiated. In this case, a boolean variable, , is set to true so that the mouseDragged dragging and methods will know that a curve is being drawn. The code for thi s follows mouseReleased the general form given above. The actual drawing of the curve is done in the mouseDragged() method, which draws a line from the previous location of the m ouse to its current location. Some effort is required to make sure that the line does not exte nd beyond the white drawing area of the panel. This is not automatic, since as far as the comput er is concerned, the border and the color bar are part of the drawing surface. If the user drag s the mouse outside the drawing area while drawing a line, the mouseDragged() x and y coordinates to routine changes the make them lie within the drawing area. 6.3.5 Anonymous Event Handlers and Adapter Classes As I mentioned above, it is a fairly common practice to use ano nymous inner classes to define listener objects. As discussed in Subsection 5.8.3 , a special form of the new operator is used to create an object that belongs to an anonymous class. For exam ple, a mouse listener object can be created with an expression of the form: new MouseListener() { public void mousePressed(MouseEvent evt) { . . . } public void mouseReleased(MouseEvent evt) { . . . } public void mouseClicked(MouseEvent evt) { . . . } public void mouseEntered(MouseEvent evt) { . . . } public void mouseExited(MouseEvent evt) { . . . } }

295 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 282 ed class and creates an object This is all just one long expression that both defines an unnam that belongs to that class. To use the object as a mouse listen er, it can be passed as the method in a command of the form: addMouseListener() parameter to some component’s new MouseListener() { component.addMouseListener( public void mousePressed(MouseEvent evt) { . . . } public void mouseReleased(MouseEvent evt) { . . . } public void mouseClicked(MouseEvent evt) { . . . } public void mouseEntered(MouseEvent evt) { . . . } public void mouseExited(MouseEvent evt) { . . . } } ); Now, in a typical application, most of the method definitions in this class will be empty. interface must provide definitions for all the methods in that A class that implements an ium of writing empty method interface, even if the definitions are empty. To avoid the ted adapter classes definitions in cases like this, Java provides . An adapter class implements a listener interface by providing empty definitions for all th e methods in the interface. An adapter class is useful only as a basis for making subclasses. In the s ubclass, you can define just those methods that you actually want to use. For the remaining meth ods, the empty definitions that are provided by the adapter class will be used. The adapter cl MouseAdapter implements ass both the MouseListener interface and the MouseMotionListener interface, so it can be used as a basis for creating a listener for any mouse event. As an examp le, if you want a mouse listener that only responds to mouse-pressed events, you can use a com mand of the form: MouseAdapter() component.addMouseListener( new { public void mousePressed(MouseEvent evt) { . . . } } ); To see how this works in a real example, let’s write another ve rsion of the ClickableRandomStrings program from Subsection 6.3.2 MouseAdapter . This version uses an anonymous class based on to handle mouse events: import java.awt.Component; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseListener; import javax.swing.JFrame; public class ClickableRandomStrings2 { public static void main(String[] args) { JFrame window = new JFrame("Random Strings"); RandomStringsPanel content = new RandomStringsPanel(); content.addMouseListener( new MouseAdapter() { // Register a mouse listener that is defined by an anonymous s ubclass // of MouseAdapter. This replaces the RepaintOnClick class that was // used in the original version. public void mousePressed(MouseEvent evt) { Component source = (Component)evt.getSource(); source.repaint(); } } ); window.setContentPane(content); ON CLOSE); window.setDefaultCloseOperation(JFrame.EXIT

296 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 283 window.setLocation(100,75); window.setSize(300,240); window.setVisible(true); } } Anonymous inner classes can be used for other purposes besid es event handling. For exam- ple, suppose that you want to define a subclass of JPanel to represent a drawing surface. The subclass will only be used once. It will redefine the paintComponent() method, but will make . It might make sense to define the subclass as an anonymous inn no other changes to JPanel er . class. You will see this pattern used in some future examples 6.4 Timers, KeyEvents, and State Machines N ot every event is generated by an action on the part of the user. Events can al so be generated by objects as part of their regular programming, a nd these events can be monitored en the events occur. One example by other objects so that they can take appropriate actions wh javax.swing.Timer of this is the class Timer generates events at regular intervals. These . A er task at regular intervals. events can be used to drive an animation or to perform some oth ation. We will then look at We will begin this section with a look at timer events and anim another type of basic user-generated event: the KeyEvents that are generated when the user types on the keyboard. The example at the end of the section us es both a timer and keyboard nt idea of events to implement a simple game and introduces the importa . state machines 6.4.1 Timers and Animation An object belonging to the class javax.swing.Timer exists only to generate events. A Timer , by default, generates a sequence of events with a fixed delay b etween each event and the next. (It is also possible to set a Timer to emit a single event after a specified time delay; in that cas e, the timer is being used as an “alarm.”) Each event belongs to t he class . An object ActionEvent ActionListener that is to listen for the events must implement the interface , which defines just one method: public void actionPerformed(ActionEvent evt) To use a Timer , you must create an object that implements the ActionListener interface. That implement ActionListener is, the object must belong to a class that is declared to “ ”, and that class must define the actionPerformed method. Then, if the object is set to listen for events from the timer, the code in the listener’s actionPerformed method will be executed every time the timer generates an event. Since there is no point to having a timer without having a list ener to respond to its events, the action listener for a timer is specified as a parameter in t he timer’s constructor. The time delay between timer events is also specified in the construct timer is a variable of type or. If Timer , then the statement timer = new Timer( millisDelay, listener ); creates a timer with a delay of millisDelay milliseconds between events (where 1000 millisec- onds equal one second). Events from the timer are sent to the listener . ( millisDelay must be of type int , and listener must be of type ActionListener .) The listener’s actionPerfomed() will be executed every time the timer emits an event. Note tha t a timer is not guaranteed to

297 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 284 ter is busy with some other task, an deliver events at precisely regular intervals. If the compu event might be delayed or even dropped altogether. A timer does not automatically start generating events when the timer object is created. The method in the timer must be called to tell the timer to start run ning. The timer’s start() tarted later by calling stop() method can be used to turn the stream of events off. It can be res start() again. ∗ ∗ ∗ One application of timers is computer animation. A computer animation is just a sequence of still images, presented to the user one after the other. If the time between images is short, en the user perceives continuous and if the change from one image to another is not too great, th Timer motion. The easiest way to do animation in Java is to use a to drive the animation. Each tion is computed and drawn on time the timer generates an event, the next frame of the anima actionPerformed method of an object the screen—the code that implements this goes in the that listens for events from the timer. but it does display a new Our first example of using a timer is not exactly an animation, image for each timer event. The program shows randomly gener ated images that vaguely resemble works of abstract art. In fact, the program draws a n ew random image every time its paintComponent() method is called, and the response to a timer event is simply t o call repaint() , which in turn triggers a call to paintComponent . The work of the program is done in a subclass of JPanel , which starts like this: import java.awt.*; import java.awt.event.*; import javax.swing.*; public class RandomArtPanel extends JPanel { /** * A RepaintAction object calls the repaint method of this pan el each his * time its actionPerformed() method is called. An object of t an * type is used as an action listener for a Timer that generates * ActionEvent every four seconds. The result is that the pane l is * redrawn every four seconds. */ private class RepaintAction implements ActionListener { public void actionPerformed(ActionEvent evt) { repaint(); // Call the repaint() method in the panel class. } } /** * The constructor creates a timer with a delay time of four sec onds * (4000 milliseconds), and with a RepaintAction object as it s * ActionListener. It also starts the timer running. */ public RandomArtPanel() { RepaintAction action = new RepaintAction(); Timer timer = new Timer(4000, action); timer.start(); } /** * The paintComponent() method fills the panel with a random s hade of

298 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 285 pe * gray and then draws one of three types of random "art". The ty * of art to be drawn is chosen at random. */ public void paintComponent(Graphics g) { . . // The rest of the class is omitted . . I will only note that You can find the full source code for this class in the file the very short ner RepaintAction class is a natural candidate to be replaced by an anonymous in class. That can be done where the timer is created: Timer timer = new timer(4000, new ActionListener() { public void actionPerformed(ActionEvent evt) { repaint(); } }); on in a simple computer game. Later in this section, we will use a timer to drive the animati 6.4.2 Keyboard Events In Java, user actions become events in a program. These event s are associated with GUI components. When the user presses a button on the mouse, the e vent that is generated is associated with the component that contains the mouse curso r. What about keyboard events? When the user presses a key, what component is associated wit h the key event that is generated? A GUI uses the idea of to determine the component associated with keyboard input focus events. At any given time, exactly one interface element on t he screen has the input focus, and that is where all keyboard events are directed. If the int erface element happens to be a Java component, then the information about the keyboard eve nt becomes a Java object of type KeyEvent , and it is delivered to any listener objects that are listeni ng for KeyEvents associated with that component. The necessity of managing input focus a dds an extra twist to working with keyboard events. It’s a good idea to give the user some visual feedback about wh ich component has the input focus. For example, if the component is the typing area of a wo rd-processor, the feedback is usually in the form of a blinking text cursor. Another possib le visual clue is to draw a brightly nput focus, as I do in the colored border around the edge of a component when it has the i examples given later in this section. If comp is any component, and you would like it to have the input focus , you can call requestFocusInWindow() , which should work as long as the window that contains the com po- nent is active and there is only one component that is request ing focus. In some cases, when there is only one component involved, it is enough to call thi s method once, just after opening the window, and the component will retain the focus for the re st of the program. (Note that there is also a requestFocus() method that might work even when the window is not active, but the newer method requestFocusInWindow() is preferred in most cases.) In a typical user interface, the user can choose to give the fo cus to a component by clicking on that component with the mouse. And pressing the tab key wil l often move the focus from one component to another. This is handled automatically by t he components involved, without any programming on your part. However, some components do no t automatically request the input focus when the user clicks on them. To solve this proble m, a program can register

299 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 286 response to a user click, the a mouse listener with the component to detect user clicks. In requestFocusInWindow() for the component. This is mousePressed() method should call that are used as drawing surfaces, since objects do not JPanels true, in particular, for JPanel receive the input focus automatically. As our first example of processing key events, we look at a simp le program in which the user moves a square up, down, left, and right by pressing arrow key s. When the user hits the ’R’, ’G’, ’B’, or ’K’ key, the color of the square is set to red, green, bl ue, or black, respectively. Of course, as the input focus. The panel in none of these key events are delivered to the panel unless it h the program changes its appearance when it has the input focu s: When it does, a cyan-colored ored border is drawn. The border is drawn around the panel; when it does not, a gray-col complete source code for this example can be found in the file . I will discuss some aspects of it below. After reading this se ction, you should be able to understand the source code in its entirety. I suggest runnin g the program to see how it works. KeyEvent In Java, keyboard event objects belong to a class called . An object that needs to listen for must implement the interface named KeyListener . Furthermore, the object KeyEvents ’s method. must be registered with a component by calling the component addKeyListener() The registration is done with the command “ component.addKeyListener(listener); ” where is the object that is to listen for key events, and component is the object that will listener ssible for component and listener generate the key events (when it has the input focus). It is po ous to what you learned about mouse to be the same object. All this is, of course, directly analog events in the previous section. The interface defines the following methods, which KeyListener must be included in any class that implements KeyListener : public void keyPressed(KeyEvent evt); public void keyReleased(KeyEvent evt); public void keyTyped(KeyEvent evt); Java makes a careful distinction between and the characters that the keys that you press . There are lots of keys on a keyboard: letter keys, number key s, modifier keys such as you type Control and Shift, arrow keys, page up and page down keys, key pad keys, function keys, and so on. In some cases, such as the shift key, pressing a key does not type a character. On the several keys. For example, to type other hand, typing a character sometimes involves pressing an uppercase ’A’, you have to press the Shift key and then pres s the A key before releasing the lding down the Option Shift key. On my Mac OS computer, I can type an accented e, by ho key, pressing the E key, releasing the Option key, and pressi ng E again. Only one character elease a key at the right time. was typed, but I had to perform three key-presses and I had to r KeyEvent . The types correspond to pressing a key, releasing a In Java, there are three types of keyPressed key, and typing a character. The method is called when the user presses a key, the keyReleased method is called when the user releases a key, and the keyTyped method is called when the user types a character (whether that’s done with one key press or several). Note that one user action, such as pressing the E key, can be responsibl e for two events, a keyPressed keyTyped keyPressed events, event and a event. Typing an upper case ’A’ can generate two keyReleased two keyTyped event. events, and one Usually, it is better to think in terms of two separate stream s of events, one consisting of keyPressed and keyReleased events and the other consisting of keyTyped events. For some applications, you want to monitor the first stream; for other applications, you want to monitor the second one. Of course, the information in the keyTyped stream could be extracted from the keyPressed/keyReleased stream, but it would be difficult (and also system-dependent to some extent). Some user actions, such as pressing the Shif t key, can only be detected as

300 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 287 events. I used to have a computer solitaire game that highlig hted every card that keyPressed hing like that in Java by could be moved, when I held down the Shift key. You can do somet ving the highlight when the Shift highlighting the cards when the Shift key is pressed and remo key is released. key on the keyboard, that There is one more complication. Usually, when you hold down a key will auto-repeat keyPressed events with just . This means that it will generate multiple one keyTyped events. keyReleased at the end of the sequence. It can also generate multiple ou should not expect every For the most part, this will not affect your programming, but y keyPressed event to have a corresponding keyReleased event. Every key on the keyboard has an integer code number. (Actual ly, this is only true s that can’t be used with for keys that Java knows about. Many keyboards have extra key keyPressed Java.) When the keyReleased method is called, the parameter, evt , contains or e obtained by calling the the code of the key that was pressed or released. The code can b evt.getKeyCode() . Rather than asking you to memorize a table of code numbers, function Java provides a named constant for each key. These constants are defined in the KeyEvent KeyEvent.VK class. For example the constant for the shift key is SHIFT . If you want to test ld say “ if (evt.getKeyCode() whether the key that the user pressed is the Shift key, you cou == KeyEvent.VK ”. The key codes for the four arrow keys are KeyEvent.VK LEFT , SHIFT) . Other keys have similar codes. RIGHT , KeyEvent.VK UP , and KeyEvent.VK DOWN KeyEvent.VK (The “VK” stands for “Virtual Keyboard”. In reality, differe nt keyboards use different key d into its own “virtual” codes. codes, but Java translates the actual codes from the keyboar Your program only sees these virtual key codes, so it will wor k with various keyboards on various platforms without modification.) keyTyped event, you want to know which character was typed. This In the case of a evt , in the keyTyped method by calling information can be obtained from the parameter, evt.getKeyChar() the function char representing the . This function returns a value of type character that was typed. KeyboardAndFocusDemo program, I use the keyPressed In the routine to respond when the user presses one of the arrow keys. The program includes inst ance variables, squareLeft and squareTop , that give the position of the upper left corner of the movabl e square. When the user presses one of the arrow keys, the keyPressed routine modifies the appropriate instance repaint() to redraw the panel with the square in its new position. Note variable and calls that the values of and squareTop are restricted so that the square never moves squareLeft outside the white area of the panel: /** * This is called each time the user presses a key while the pane l has * the input focus. If the key pressed was one of the arrow keys, the * the square is moved (except that it is not allowed to move off * edge of the panel, allowing for a 3-pixel border). */ public void keyPressed(KeyEvent evt) { int key = evt.getKeyCode(); // keyboard code for the pressed key if (key == KeyEvent.VK LEFT) { // left-arrow key; move the square left squareLeft -= 8; if (squareLeft < 3) squareLeft = 3; repaint();

301 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 288 } RIGHT) { // right-arrow key; move the square right else if (key == KeyEvent.VK squareLeft += 8; if (squareLeft > getWidth() - 3 - SQUARE SIZE) SIZE; squareLeft = getWidth() - 3 - SQUARE repaint(); } UP) { // up-arrow key; move the square up else if (key == KeyEvent.VK squareTop -= 8; if (squareTop < 3) squareTop = 3; repaint(); } DOWN) { // down-arrow key; move the square down else if (key == KeyEvent.VK squareTop += 8; if (squareTop > getHeight() - 3 - SQUARE SIZE) squareTop = getHeight() - 3 - SQUARE SIZE; repaint(); } } // end keyPressed() rs ’R’, ’G’, ’B’, and ’K’, or Color changes—which happen when the user types the characte the lower case equivalents—are handled in the keyTyped method. I won’t include it here, since keyPressed method. Finally, to complete the it is so similar to the interface, the KeyListener keyReleased method must be defined. In the sample program, the body of this method is empty since the program does nothing in response to keyReleased events. 6.4.3 Focus Events If a component is to change its appearance when it has the inpu t focus, it needs some way to know when it has the focus. In Java, objects are notified about changes of input focus by events FocusEvent lement the of type . An object that wants to be notified of changes in focus can imp FocusListener interface. This interface declares two methods: public void focusGained(FocusEvent evt); public void focusLost(FocusEvent evt); addFocusListener() method must be used to set up a listener for the Furthermore, the the focusGained() method of focus events. When a component gets the input focus, it calls any registered with FocusListener . When it loses the focus, it calls the listener’s focusLost() method. In the sample KeyboardAndFocusDemo program, the response to a focus event is simply to redraw the panel. The method checks whether the panel has the input paintComponent() focus by calling the boolean -valued function hasFocus() , which is defined in the Component class, and it draws a different picture depending on whether o r not the panel has the input focus. The net result is that the appearance of the panel chan ges when the panel gains or loses focus. The methods from the FocusListener interface are defined simply as: public void focusGained(FocusEvent evt) { // The panel now has the input focus. repaint(); // will redraw with a new message and a cyan border }

302 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 289 public void focusLost(FocusEvent evt) { // The panel has now lost the input focus. repaint(); // will redraw with a new message and a gray border } el actually gets the focus. The other aspect of handling focus is to make sure that the pan requestFocusInWindow() for the panel in the program’s main() routine, In this case, I called just after opening the window. This approach works because t here is only one component in the window, and it should have focus as long as the window is ac tive. If the user clicks over to another window while using the program, the window become s inactive and the panel loses focus temporarily, but gets is back when the user clicks back to the program window. There are still decisions to be made about the overall struct ure of the program. In this case, Listener to define an object that listens for both focus I decided to use a nested class named bject of type and key events. In the constructor for the panel, I create an o and register Listener l. See the it to listen for both key events and focus events from the pane for full source code details. 6.4.4 State Machines said to represent the state of that The information stored in an object’s instance variables is n taken by the object can depend object. When one of the object’s methods is called, the actio on its state. (Or, in the terminology we have been using, the d efinition of the method can look at the instance variables to decide what to do.) Furthermore , the state can change. (That is, the definition of the method can assign new values to the in stance variables.) In computer science, there is the idea of a state machine , which is just something that has a state and can change state in response to events or inputs. The respons e of a state machine to an event is a kind of state machine. depends on what state it’s in when the event occurs. An object classes. Sometimes, this point of view can be very useful in designing The state machine point of view can be especially useful in th e type of event-oriented programming that is required by graphical user interfaces. When designing a GUI program, you can ask yourself: What information about state do I need t o keep track of? What events can change the state of the program? How will my response to a g iven event depend on the current state? Should the appearance of the GUI be changed to reflect a change in state? How should the paintComponent() method take the state into account? All this is an alternativ e to the top-down, step-wise-refinement style of program design , which does not apply to the overall design of an event-oriented program. In the KeyboardAndFocusDemo program, shown above, the state of the program is recorded in the instance variables , squareLeft , and squareTop . These state variables are squareColor used in the paintComponent() method to decide how to draw the panel. Their values are changed in the two key-event-handling methods. In the rest of this section, we’ll look at another example, wh ere the state plays an even bigger role. In this example, the user plays a simple arcade- style game by pressing the arrow keys. The program is defined in the source code file . As usual, it would be a good idea to compile and run the program as well as read the ful l source code. Here is a picture:

303 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 290 anel. While the panel The program shows a black “submarine” near the bottom of the p has the input focus, this submarine moves back and forth erra tically near the bottom. Near forth by pressing the left and the top, there is a blue “boat.” You can move this boat back and right arrow keys. Attached to the boat is a red “bomb” (or “dep th charge”). You can drop the bomb by hitting the down arrow key. The objective is to blo w up the submarine by hitting it with the bomb. If the bomb falls off the bottom of the screen, you get a new one. If the submarine explodes, a new sub is created and you get a new bomb . Try it! Make sure to hit the sub at least once, so you can see the explosion. Let’s think about how this game can be programmed. First of al l, since we are doing object- oriented programming, I decided to represent the boat, the d epth charge, and the submarine ed class inside the main panel as objects. Each of these objects is defined by a separate nest by the instance variables in the class, and each object has its own state which is represented boat bomb , and sub in the panel class to refer to the boat, corresponding class. I use variables , bomb, and submarine objects. at things change from time Now, what constitutes the “state” of the program? That is, wh f course, the state includes the to time and affect the appearance or behavior of the program? O positions of the boat, submarine, and bomb, so those objects have instance variables to store the positions. Anything else, possibly less obvious? Well, sometimes the bomb is falling, and sometimes it’s not. That is a difference in state. Since there are two possibilities, I represent this aspect of the state with a boolean variable in the bomb object, bomb.isFalling . Sometimes the submarine is moving left and sometimes it is moving right . The difference is represented sub.isMovingLeft by another boolean variable, . Sometimes, the sub is exploding. This is also part of the state, and it is represented by a boolean vari able, sub.isExploding . However, s something that takes place over the explosions require a little more thought. An explosion i looks different in each frame, a series of frames. While an explosion is in progress, the sub as the size of the explosion increases. Also, I need to know wh en the explosion is over so that I can go back to moving and drawing the sub as usual. So, I u se an integer variable, sub.explosionFrameNumber to record how many frames have been drawn since the explosion started; the value of this variable is used only when an explo sion is in progress. How and when do the values of these state variables change? So me of them seem to change on their own: For example, as the sub moves left and right, the state variables that specify its position change. Of course, these variables are changin g because of an animation, and that animation is driven by a timer. Each time an event is generate d by the timer, some of the state variables have to change to get ready for the next frame of the animation. The changes are made by the action listener that listens for events from the t imer. The boat , bomb , and sub objects each contain an updateForNextFrame() method that updates the state variables of the

304 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 291 tion listener for the timer calls object to get ready for the next frame of the animation. The ac these methods with the statements boat.updateForNewFrame(); bomb.updateForNewFrame(); sub.updateForNewFrame(); repaint() , so that the panel will be redrawn to reflect its new The action listener also calls state. There are several state variables that change in thes e update methods, in addition to rdinate increases from one frame the position of the sub: If the bomb is falling, then its y-coo to the next. If the bomb hits the sub, then the isExploding variable of the sub changes to isFalling variable of the bomb becomes false . The isFalling variable also true, and the If the sub is exploding, then becomes false when the bomb falls off the bottom of the screen. explosionFrameNumber tain its increases from one frame to the next, and when it reaches a cer value, the explosion ends and isExploding is reset to false. At random times, the sub switches between moving to the left and moving to the right. Its direct ion of motion is recorded in the sub’s variable. The sub’s updateForNewFrame() method includes these lines to isMovingLeft change the value of isMovingLeft at random times: if ( Math.random() < 0.04 ) isMovingLeft = ! isMovingLeft; There is a 1 in 25 chance that Math.random() will be less than 0.04, so the statement “ isMovingLeft = ! isMovingLeft ” is executed in one in every twenty-five frames, on av- isMovingLeft erage. The effect of this statement is to reverse the value of , from false to true or from true to false. That is, the direction of motion of the s ub is reversed. In addition to changes in state that take place from one frame to the next, a few state variables change when the user presses certain keys. In the p rogram, this is checked in a the left or right arrow key, the method that responds to user keystrokes. If the user presses rrow key, the bomb changes position of the boat is changed. If the user presses the down a from not-falling to falling. This is coded in the keyPressed() method of a KeyListener that is registered to listen for key events on the panel; that method reads as follows: public void keyPressed(KeyEvent evt) { int code = evt.getKeyCode(); // which key was pressed. if (code == KeyEvent.VK LEFT) { // Move the boat left. (If this moves the boat out of the frame, its // position will be adjusted in the boat.updateForNewFrame () method.) boat.centerX -= 15; } RIGHT) { else if (code == KeyEvent.VK // Move the boat right. (If this moves boat out of the frame, it s // position will be adjusted in the boat.updateForNewFrame () method.) boat.centerX += 15; } DOWN) { else if (code == KeyEvent.VK // Start the bomb falling, if it is not already falling. if ( bomb.isFalling == false ) bomb.isFalling = true; } }

305 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 292 repaint() in this method, since this panel shows an anima- Note that it’s not necessary to call tion that is constantly being redrawn anyway. Any changes in the state will become visible to the user as soon as the next frame is drawn. At some point in the program, I have to make sure that the user does not move the boat off the screen. I could have done this in keyPressed() , but I choose to check for this in another routine, in the boat o bject. The program uses four listeners, to respond to action events from the timer, key events from e user must click the panel to start the user, focus events, and mouse events. In this program, th the game. The game is programmed to run as long as the panel has the input focus. In this example, the program does not automatically request the foc us; the user has to do it. When the user clicks the panel, the mouse listener requests the in put focus and the game begins. The grammed by having the focus timer runs only when the panel has the input focus; this is pro and stop the timer when the panel listener start the timer when the panel gains the input focus onstructor of the class loses the input focus. All four listeners are created in the c SubKillerPanel using anonymous inner classes. (See Subsection 6.3.5 .) I encourage you to read the source code in . Although a few points are and the entire program. Try to tricky, you should with some effort be able to read and underst he state of each of the three understand the program in terms of state machines. Note how t objects in the program changes in response to events from the timer and from the user. While it’s not at all sophisticated as arcade games go, the Su bKiller game does use some interesting programming. And it nicely illustrates how to a pply state-machine thinking in event-oriented programming. 6.5 Basic Components I n preceding sections , you’ve seen how to use a graphics context to draw on the scree n and how to handle mouse events and keyboard events. In one sen se, that’s all there is to g and handle all the mouse and GUI programming. If you’re willing to program all the drawin u would either be doing a lot keyboard events, you have nothing more to learn. However, yo more work than you need to do, or you would be limiting yoursel f to very simple user interfaces. A typical user interface uses standard GUI components such a s buttons, scroll bars, text-input boxes, and menus. These components have already been writte n for you, so you don’t have to w to draw themselves, and they duplicate the work involved in developing them. They know ho vents that concern them. can handle the details of processing the mouse and keyboard e Consider one of the simplest user interface components, a pu sh button. The button has a border, and it displays some text. This text can be changed. S ometimes the button is disabled, so that clicking on it doesn’t have any effect. When it is disab led, its appearance changes. When the user clicks on the push button, the button changes appear ance while the mouse button is pressed and changes back when the mouse button is released. I n fact, it’s more complicated than that. If the user moves the mouse outside the push button before releasing the mouse lement this, it is necessary to button, the button changes to its regular appearance. To imp respond to mouse exit or mouse drag events. Furthermore, on m any platforms, a button can it has the focus. If the button receive the input focus. The button changes appearance when has the focus and the user presses the space bar, the button is triggered. This means that the button must respond to keyboard and focus events as well. Fortunately, you don’t have to program any of this, provided you use an object belonging to the standard class javax.swing.JButton . A JButton object draws itself and processes mouse, keyboard, and focus events on its own. You only hear fr om the JButton when the

306 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 293 ile the button has the input user triggers it by clicking on it or pressing the space bar wh object creates an event object belonging to the class focus. When this happens, the JButton them . The event object is sent to any registered listeners to tell java.awt.event.ActionEvent formation it needs—the fact that the button has been pushed. Your program gets only the in that a button was pushed. ∗ ∗ ∗ The standard components that are defined as part of the Swing g raphical user interface , which is itself a subclass of Component API are defined by subclasses of the class JComponent . JPanel class that we have already been working with extensively.) (Note that this includes the Many useful methods are defined in the Component and JComponent classes and so can be used methods. Suppose that with any Swing component. We begin by looking at a few of these comp is a variable that refers to some . Then the following methods can be used: JComponent comp.getWidth() comp.getHeight() are functions that give the current size of the • and component, in pixels. One warning: When a component is first c reated, its size is zero. The size will be set later, probably by a layout manager. A com mon mistake is to check n a constructor. the size of a component before that size has been set, such as i • comp.setEnabled(true) comp.setEnabled(false) can be used to enable and disable and might change, and the user the component. When a component is disabled, its appearance on, comp.isEnabled() that cannot do anything with it. There is a boolean-valued functi you can call to discover whether the component is enabled. • comp.setVisible(true) and comp.setVisible(false) can be called to hide or show the component. • sets the font that is used for text displayed on the component . See comp.setFont(font) for a discussion of fonts. Subsection 6.2.3 comp.setBackground(color) and comp.setForeground(color) set the background and • foreground colors for the component. See Subsection 6.2.2 . comp.setOpaque(true) tells the component that the area occupied by the component • e the content of the compo- should be filled with the component’s background color befor JLabels are non-opaque. A non-opaque, or “transparent”, nent is painted. By default, only component ignores its background color and simply paints it s content over the content of round color from its container. its container. This usually means that it inherits the backg • comp.setToolTipText(string) sets the specified string as a “tool tip” for the component. The tool tip is displayed if the mouse cursor is in the compone nt and the mouse is not moved for a few seconds. The tool tip should give some informa tion about the meaning of the component or how to use it. • comp.setPreferredSize(size) sets the size at which the component should be displayed, if possible. The parameter is of type java.awt.Dimension , where an object of type Di- mension has two public integer-valued instance variables, width and height . A call to this method usually looks something like “ ”. setPreferredSize( new Dimension(100,50) ) The preferred size is used as a hint by layout managers, but wi ll not be respected in all cases. Standard components generally compute a correct pre ferred size automatically, but it can be useful to set it in some cases. For example, if you use a JPanel as a drawing surface, it is usually a good idea to set a preferred size for i t, since its default preferred size is zero.

307 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 294 mponent object must be Note that using any component is a multi-step process. The co created with a constructor. It must be added to a container. I n many cases, a listener must some cases, a reference to the be registered to respond to events from the component. And in component must be saved in an instance variable so that the co mponent can be manipulated by the program after it has been created. In this section, we wil l look at a few of the basic standard components that are available in Swing. In the next section w e will consider the problem of laying out components in containers. 6.5.1 JButton is a push button that the user can click to trigger some action An object of class JButton . You’ve already seen buttons used in Section 6.1 , but we consider them in much more detail here. To use any component effectively, there are several asp ects of the corresponding class that you should be familiar with. For JButton , as an example, I list these aspects explicitly: Constructors : The JButton class has a constructor that takes a string as a parameter. • mple: This string becomes the text displayed on the button. For exa stopGoButton = . This creates a button object that will display the text, “Go ” (but new JButton("Go") remember that the button must still be added to a container be fore it can appear on the screen). • : When the user clicks on a button, the button generates an eve nt of type Action- Events . This event is sent to any listener that has been registered w ith the button as an Event . ActionListener Listeners ust imple- • : An object that wants to handle events generated by buttons m ActionListener ment the public void interface. This interface defines just one method, “ actionPerformed(ActionEvent evt) ”, which is called to notify the object of an action event. • Registration of Listeners : In order to actually receive notification of an event from a button, an ActionListener must be registered with the button. This is done with the but- addActionListener() method. For example: ton’s stopGoButton.addActionListener( buttonHandler ); Event methods : When • is called by the button, the parameter, actionPerformed(evt) evt , contains information about the event. This information ca n be retrieved by calling methods in the class. In particular, evt.getActionCommand() returns a ActionEvent String giving the command associated with the button. By default, t his command is the text that is displayed on the button, but it is possible to set it to some other string. The method evt.getSource() returns a reference to the object that produced the event, th at is, to the JButton that was pressed. The return value is of type Object , not JButton , because other types of components can also produce ActionEvents . Component methods : Several useful methods are defined in the JBut- • class, in addition to the standard Component methods. For example, ton stopGoButton.setText("Stop") changes the text displayed on the button to “Stop”. And changes the action command associated stopGoButton.setActionCommand("sgb") with this button for action events. The setEnabled() and setText() methods are par- ticularly useful for giving the user information about what is going on in the program. A disabled button is better than a button that gives an obnoxi ous error message such as “Sorry, you can’t click on me now!”

308 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 295 6.5.2 JLabel JLabel JLabel exists just to is certainly the simplest type of component. An object of typ e lthough it can be changed by display a line of text. The text cannot be edited by the user, a your program. The constructor for a specifies the text to be displayed: JLabel JLabel message = new JLabel("Hello World!"); There is another constructor that specifies where in the labe l the text is located, if there is JLabel.LEFT , extra space. The possible alignments are given by the consta , nts JLabel.CENTER JLabel.RIGHT . For example, and JLabel message = new JLabel("Hello World!", JLabel.CENTER ); creates a label whose text is centered in the available space . You can change the text displayed setText() in a label by calling the label’s method: message.setText("Goodbye World!"); JLabel JComponent , you can use methods such as Since the class is a subclass of setForeground() and setFont() with labels. If you want the background color to have any setOpaque(true) on the label, since otherwise the JLabel effect, you should call might not fill in its background. For example: ); JLabel message = new JLabel("Hello World!", JLabel.CENTER message.setForeground(Color.RED); // Display red text.. . message.setBackground(Color.BLACK); // on a black backgr ound... message.setFont(new Font("Serif",Font.BOLD,18)); // in a big bold font. message.setOpaque(true); // Make sure background is fille d in. 6.5.3 JCheckBox A JCheckBox he user can change is a component that has two states: selected or unselected. T ox is represented by a the state of a check box by clicking on it. The state of a checkb boolean value that is true if the box is selected and is false if the box is unselected. A checkbox has a label, which is specified when the box is constructed: JCheckBox showTime = new JCheckBox("Show Current Time"); JCheckBox , but you can also set the state Usually, it’s the user who sets the state of a ng its programmatically. The current state of a checkbox is set usi setSelected(boolean) showTime to be checked, you would say method. For example, if you want the checkbox showTime.setSelected(true)" . To uncheck the box, say “ showTime.setSelected(false)" . “ You can determine the current state of a checkbox by calling i ts isSelected() method, which returns a boolean value. In many cases, you don’t need to worry about events from check boxes. Your program can e isSelected() just check the state whenever it needs to know it by calling th method. However, a checkbox does generate an event when its state is changed by the user, and you can detect this event and respond to it if you want something to happen at the m oment the state changes. When the state of a checkbox is changed by the user, it generates an event of type ActionEvent . If you want something to happen when the user changes the state, you ActionListener must register an with the checkbox by calling its addActionListener() method. (Note that if you change the state by calling the setSelected() method, no ActionEvent is generated. However, there

309 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 296 JCheckBox class, , which simulates a user click on the is another method in the doClick() .) ActionEvent checkbox and does generate an ActionEvent , you can call evt.getSource() in the actionPerformed() When handling an method to find out which object generated the event. (Of cours e, if you are only listening for Object , urned value is of type events from one component, you don’t have to do this.) The ret but you can type-cast it to another type if you want. Once you k now the object that generated the event, you can ask the object to tell you its current state . For example, if you know that cb1 or cb2 , then your the event had to come from one of two checkboxes, actionPerformed() method might look like this: public void actionPerformed(ActionEvent evt) { Object source = evt.getSource(); if (source == cb1) { boolean newState = cb1.isSelected(); ... // respond to the change of state } else if (source == cb2) { boolean newState = cb2.isSelected(); ... // respond to the change of state } } evt.getActionCommand() Alternatively, you can use to retrieve the action command asso- ciated with the source. For a , the action command is, by default, the label of the JCheckBox checkbox. 6.5.4 JTextField and JTextArea The and JTextArea classes represent components that contain text that can be e dited JTextField by the user. A JTextField holds a single line of text, while a JTextArea can hold multiple lines. It is also possible to set a JTextField JTextArea to be read-only so that the user can read the or re subclasses of an abstract class, text that it contains but cannot edit the text. Both classes a , which defines their common properties. JTextComponent and JTextArea have many methods in common. The instance method setText() , JTextField String , can be used to change the text that is displayed in an which takes a parameter of type ved by calling its getText() input component. The contents of the component can be retrie instance method, which returns a value of type . If you want to stop the user from String modifying the text, you can call setEditable(false) . Call the same method with a parameter of true to make the input component user-editable again. The user can only type into a text component when it has the inp ut focus. The user can e mouse, but sometimes it is give the input focus to a text component by clicking it with th useful to give the input focus to a text field programmaticall y. You can do this by calling its requestFocusInWindow() put, method. For example, when I discover an error in the user’s in I usually call requestFocusInWindow() on the text field that contains the error. This helps the user see where the error occurred and lets the user start t yping the correction immediately. By default, there is no space between the text in a text compon ent and the edge of the component, which usually doesn’t look very good. You can use the setMargin() method of the component to add some blank space between the edge of the c omponent and the text. This method takes a parameter of type java.awt.Insets which contains four integer instance

310 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 297 and right edge of the component. variables that specify the margins on the top, left, bottom, For example, textComponent.setMargin( new Insets(5,5,5,5) ); textComponent and each edge of the component. adds a five-pixel margin between the text in ∗ ∗ ∗ The JTextField class has a constructor public JTextField(int columns) is an integer that specifies the number of characters that sho uld be visible in the where columns e text field. (Because characters text field. This is used to determine the preferred width of th can be of different sizes and because the preferred width is no t always respected, the actual number of characters visible in the text field might not be equ al to columns .) You don’t have to specify the number of columns; for example, you might use the text field in a context where it you can use the default constructor will expand to fill whatever space is available. In that case, , with no parameters. You can also use the following construc JTextField() tors, which specify the initial contents of the text field: public JTextField(String contents); public JTextField(String contents, int columns); The constructors for a JTextArea are public JTextArea() public JTextArea(int rows, int columns) public JTextArea(String contents) public JTextArea(String contents, int rows, int columns) rows specifies how many lines of text should be visible in the text a The parameter rea. This determines the preferred height of the text area, just as determines the preferred width. columns es; the text area can be scrolled However, the text area can actually contain any number of lin o use a JTextArea as the CENTER to reveal lines that are not currently visible. It is common t component of a BorderLayout. In that case, it is less useful t o specify the number of lines and columns, since the TextArea will expand to fill all the space a vailable in the center area of the container. The class adds a few useful methods to those inherited from JTextComponent . JTextArea append(moreText) , where moreText is of type For example, the instance method , adds String the specified text at the end of the current content of the text area. (When using append() or setText() to add text to a JTextArea , line breaks can be inserted in the text by using the newline character, ’\n’ .) And setLineWrap(wrap) , where wrap is of type boolean , tells what should happen when a line of text is too long to be displayed in wrap is true, the text area. If then any line that is too long will be “wrapped” onto the next l ine; if wrap is false, the line will simply extend outside the text area, and the user will have to scroll the text area horizontally to see the entire line. The default value of wrap is false. Since it might be necessary to scroll a text area to see all the text that it contains, you might expect a text area to come with scroll bars. Unfortunately, t his does not happen automatically. To get scroll bars for a text area, you have to put the JTextArea inside another component, called a JScrollPane . This can be done as follows: JTextArea inputArea = new JTextArea(); JScrollPane scroller = new JScrollPane( inputArea );

311 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 298 l the text in the text area. The The scroll pane provides scroll bars that can be used to scrol scroll bars will appear only when needed, that is when the siz e of the text exceeds the size of a container, you should add the text area. Note that when you want to put the text area into the scroll pane, not the text area itself, to the container. S ee the program for a very short example of using a text area in a scroll pane. ∗ ∗ ∗ When the user is typing in a ActionEvent is generated. JTextField and presses return, an ActionListener with the text field, If you want to respond to such events, you can register an addActionListener() method. (Since a JTextArea using the text field’s can contain multiple lines of text, pressing return in a text area does not generat e an event; it simply begins a new line of text.) JTextField JPasswordField , which is identical except that it does not reveal has a subclass, the text that it contains. The characters in a JPasswordField are all displayed as asterisks (or esigned to let the user enter a some other fixed character). A password field is, obviously, d password without showing that password on the screen. Text components are actually quite complex, and I have cover ed only their most basic properties here. I will return to the topic of text component s in Chapter 13 . 6.5.5 JSlider A JSlider provides a way for the user to select an integer value from a ra nge of possible values. The user does this by dragging a “knob” along a bar. A slider ca n, optionally, be decorated , shows e program with tick marks and with labels. This picture, from the sampl three sliders with different decorations and with different r anges of values: Here, the second slider is decorated with tick marks, and the third one is decorated with labels. It’s possible for a single slider to have both types of decora tions. The most commonly used constructor for specifies the start and end of the range JSliders of values for the slider and its initial value when it first app ears on the screen: public JSlider(int minimum, int maximum, int value) If the parameters are omitted, the values 0, 100, and 50 are us ed. By default, a slider is horizon- tal, but you can make it vertical by calling its method setOrientation(JSlider.VERTICAL) . The current value of a JSlider can be read at any time with its getValue() method, which returns a value of type . If you want to change the value, you can do so with the method int setValue(n) , which takes a parameter of type int . If you want to respond immediately when the user changes the v alue of a slider, you can register a listener with the slider. JSliders , unlike other components we have seen, do not generate ActionEvents . Instead, they generate events of type ChangeEvent . ChangeEvent and

312 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 299 javax.swing.event rather than , so related classes are defined in the package java.awt.event , you should at the beginning ChangeEvents if you want to use import javax.swing.event.* ChangeListener interface, of your program. You must also define some object to implement the alling its and you must register the change listener with the slider by c addChangeListener() method. A ChangeListener must provide a definition for the method: public void stateChanged(ChangeEvent evt) This method will be called whenever the value of the slider ch anges. Note that it will be called setValue() when you change the value with the method, as well as when the user changes the value. In the method, you can call evt.getSource() to find out which object stateChanged() rated the change event, call the generated the event. If you want to know whether the user gene getValueIsAdjusting() method, which returns true if the user is dragging the knob slider’s on the slider. e interval between the tick Using tick marks on a slider is a two-step process: Specify th ayed. There are actually two marks, and tell the slider that the tick marks should be displ s. You can have one or types of tick marks, “major” tick marks and “minor” tick mark the other or both. Major tick marks are a bit longer than minor tick marks. The method setMinorTickSpacing(i) indicates that there should be a minor tick mark every i units along the slider. The parameter is an integer. (The spacing is in te rms of values on the slider, not pixels.) For the major tick marks, there is a similar command , . setMajorTickSpacing(i) ear. You also have to call Calling these methods is not enough to make the tick marks app . For example, the second slider in the above illustration wa s created setPaintTicks(true) and configured using the commands: slider2 = new JSlider(); // (Uses default min, max, and value .) slider2.addChangeListener(this); slider2.setMajorTickSpacing(25); slider2.setMinorTickSpacing(5); slider2.setPaintTicks(true); the labels and tell the slider to Labels on a slider are handled similarly. You have to specify paint them. Specifying labels is a tricky business, but the JSlider class has a method to simplify it. You can create a set of labels and add them to a slider named sldr with the command: sldr.setLabelTable( sldr.createStandardLabels(i) ); where i is an integer giving the spacing between the labels. To arran ge for the labels to be displayed, call . For example, the third slider in the above illustration setPaintLabels(true) was created and configured with the commands: slider3 = new JSlider(2000,2100,2014); slider3.addChangeListener(this); slider3.setLabelTable( slider3.createStandardLabels( 50) ); slider3.setPaintLabels(true); 6.6 Basic Layout C omponents are the fundamental building blocks of a graphical user inte rface. But you have to do more with components besides create them. Another aspe ct of GUI programming is laying out components on the screen, that is, deciding where they are dr awn and how big they are. You have probably noticed that computing coordina tes can be a difficult problem,

313 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 300 a. Java has a solution for this, as especially if you don’t assume a fixed size for the drawing are well. containers Components are the visible objects that make up a GUI. Some co , mponents are which can hold other components. Containers in Java are obje cts that belong to some subclass . The content pane of a JFrame of java.awt.Container is an example of a container. The JPanel , which we have mostly used as a drawing surface up until now, i s another standard class example of a container. JPanel object is a container, it can hold other components. Because a Because a is JPanel itself a component, you can add a to another JPanel . This makes complex nesting of JPanel JPanels n in components possible. can be used to organize complicated user interfaces, as show this illustration: of the two smaller panels in turn In this picture, a large panel holds two smaller panels. Each holds three components. setting their sizes and The components in a container must be “laid out,” which means positions. It’s possible to program the layout yourself, bu t layout is ordinarily done by a layout manager . A layout manager is an object associated with a container th at implements some policy for laying out the components in that container. Different types of layout manager implement different policies. In this section, we will cover the three most common types of examples that use components layout manager, and then we will look at several programming and layout. Every container has a default layout manager and has an insta nce method, setLayout() , that takes a parameter of type LayoutManager and that is used to specify a different layout manager for the container. Components are added to a contain er by calling an instance method named add() in the container object. There are actually several version s of the add() method, with different parameter lists. Different versions of add() are appropriate for different layout managers, as we will see below. 6.6.1 Basic Layout Managers d as parameters in the Java has a variety of standard layout managers that can be use setLayout() method. They are defined by classes in the package java.awt . Here, we will look at just three of these layout manager classes: FlowLayout , BorderLayout , and GridLayout . A FlowLayout simply lines up components in a row across the container. The size of each component is equal to that component’s “preferred size.” Af ter laying out as many items as will fit in a row across the container, the layout manager will move on to the next row. The default

314 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 301 JPanel is a ; that is, a JPanel uses a FlowLayout unless you specify a layout for a FlowLayout method. setLayout() different layout manager by calling the panel’s ht-aligned, or centered within The components in a given row can be either left-aligned, rig en components. If the default that row, and there can be horizontal and vertical gaps betwe constructor, “ ”, is used, then the components on each row will be centered new FlowLayout() and both the horizontal and the vertical gaps will be five pixe ls. The constructor public FlowLayout(int align, int hgap, int vgap) ssible values of align are can be used to specify alternative alignment and gaps. The po , FlowLayout.LEFT , and FlowLayout.CENTER . FlowLayout.RIGHT container FlowLayout as its layout Suppose that is a container object that is using a comp , can be added to the container with the statement manager. Then, a component, container.add(comp); The will line up all the components that have been added to the con tainer in this FlowLayout way. They will be lined up in the order in which they were added . For example, this picture shows five buttons in a panel that uses a FlowLayout : Note that since the five buttons will not fit in a single row acro ss the panel, they are arranged in two rows. In each row, the buttons are grouped together and are centered in the row. The buttons were added to the panel using the statements: panel.add(button1); panel.add(button2); panel.add(button3); panel.add(button4); panel.add(button5); When a container uses a layout manager, the layout manager is ordinarily responsible for computing the preferred size of the container (although a di fferent preferred size could be set by calling the container’s method). A FlowLayout prefers to put its setPreferredSize components in a single row, so the preferred width is the tota l of the preferred widths of all the components, plus the horizontal gaps between the compon ents. The preferred height is the maximum preferred height of all the components. ∗ ∗ ∗ A BorderLayout layout manager is designed to display one large, central com ponent, with up to four smaller components arranged around the edges of the c entral component. If a container, cntr , is using a BorderLayout , then a component, comp , should be added to the container using a statement of the form cntr.add( comp, borderLayoutPosition ); where borderLayoutPosition specifies what position the component should occupy in the layout and is given as one of the constants , BorderLayout.NORTH , BorderLayout.CENTER BorderLayout.SOUTH , BorderLayout.EAST , or BorderLayout.WEST . The meaning of the five positions is shown in this diagram:

315 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 302 NF GH I East Center est W I F H S K Note that a border layout can contain fewer than five componen ts, so that not all five of the possible positions need to be filled. It would be very unusual , however, to have no center component. A NORTH and SOUTH components BorderLayout sets the sizes of its components as follows: The width is set equal to the full width of (if present) are shown at their preferred heights, but their the container. The EAST and WEST components are shown at their preferred widths, but their height is set to the height of the container, minus the space o NORTH and SOUTH ccupied by the components. Finally, the component takes up any remaining space. The preferred CENTER CENTER nto account size of the component is ignored when the layout is done, but it is taken i when the preferred size of the container as a whole is compute d. You should make sure that the components that you put into a BorderLayout are suitable for the positions that they will work well in the NORTH or occupy. A horizontal slider or text field, for example, would SOUTH position, but wouldn’t make much sense in the or WEST position. EAST new BorderLayout() , leaves no space between components. If you The default constructor, would like to leave some space, you can specify horizontal an d vertical gaps in the constructor of the BorderLayout object. For example, if you say panel.setLayout(new BorderLayout(5,7)); then the layout manager will insert horizontal gaps of 5 pixe ls between components and vertical gaps of 7 pixels between components. The background color of the container will show through in these gaps. The default layout for the original content pa JFrame is a ne that comes with a BorderLayout with no horizontal or vertical gap. ∗ ∗ ∗ layout manager. A grid layout lays out components in Finally, we consider the GridLayout a grid containing rows and columns of equal sized rectangles . This illustration shows how the components would be arranged in a grid layout with 4 rows and 3 columns: LO LZ LO LU [ X P L L L Y Q \ L L L R O LO LO LOU If a container uses a GridLayout add method for the container takes a single , the appropriate Component parameter of type cntr.add(comp) ). Components are added to the (for example: grid in the order shown; that is, each row is filled from left to right before going on the next row. The constructor for a GridLayout takes the form “ new GridLayout(R,C) ”, where R is the number of rows and C is the number of columns. If you want to leave horizontal gaps of H pixels

316 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 303 V pixels between rows, use “ ” between columns and vertical gaps of new GridLayout(R,C,H,V) instead. GridLayout When you use a , it’s probably good form to add just enough components to fill the grid. However, this is not required. In fact, as long as yo u specify a non-zero value for the number of rows, then the number of columns is essentially ign ored. The system will use just as many columns as are necessary to hold all the components that you add to the container. If you want to depend on this behavior, you should probably specify zero as the number of columns. You can also specify the number of rows as zero. In that case, y ou must give a non-zero number of columns. The system will use the specified number of column s, with just as many rows as necessary to hold the components that are added to the contai ner. Horizontal grids, with a single row, and vertical grids, wit h a single column, are very com- mon. For example, suppose that , button2 , and button3 are buttons and that you’d button1 horizontal grid for the panel, like to display them in a horizontal row in a panel. If you use a e the same size. The panel can be then the buttons will completely fill that panel and will all b created as follows: JPanel buttonBar = new JPanel(); buttonBar.setLayout( new GridLayout(1,3) ); // (Note: The "3" here is pretty much ignored, and // you could also say "new GridLayout(1,0)". // To leave gaps between the buttons, you could use // "new GridLayout(1,0,5,5)".) buttonBar.add(button1); buttonBar.add(button2); buttonBar.add(button3); You might find this button bar to be more attractive than the on e that uses the default FlowLay- out layout manager. 6.6.2 Borders We have seen how to leave gaps between the components in a cont ainer, but what if you would like to leave a border around the outside of the container? Th is problem is not handled by layout managers. Instead, borders in Swing are represented by objects. A Border object can be JComponent added to any pace. , not just to containers. Borders can be more than just empty s The class javax.swing.BorderFactory contains a large number of static methods for creating border objects. For example, the function BorderFactory.createLineBorder(Color.BLACK) returns an object that represents a one-pixel wide black lin e around the outside of a component. If comp is a JComponent , a border can be added to comp using its setBorder() method. For example: .BLACK) ); comp.setBorder( BorderFactory.createLineBorder(Color Once a border has been set for a JComponent , the border is drawn automatically, without any further effort on the part of the programmer. The border is drawn along the edges of the component, just inside its boundary. The layout manager of a JPanel or other container will take the space occupied by the border into account. The compo nents that are added to the container will be displayed in the area inside the border. I d on’t recommend using a border on a JPanel that is being used as a drawing surface. However, if you do thi s, you should take the

317 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 304 rder, that part of your drawing border into account. If you draw in the area occupied by the bo will be covered by the border. Here are some of the static methods that can be used to create b orders: • ht) — leaves an empty bor- BorderFactory.createEmptyBorder(top,left,bottom,rig der around the edges of a component. Nothing is drawn in this s pace, so the background border. The parameters color of the component will appear in the area occupied by the are integers that give the width of the border along the top, l eft, bottom, and right edges JPanel that contains other of the component. This is actually very useful when used on a e edge of the panel. It components. It puts some space between the components and th JLabel can also be useful on a , which otherwise would not have any space between the text and the edge of the label. • BorderFactory.createLineBorder(color,thickness) — draws a line around all four edges of a component. The first parameter is of type and specifies the color of the Color line. The second parameter is an integer that specifies the th ickness of the border, in pixels. If the second parameter is omitted, a line of thickne ss 1 is drawn. • BorderFactory.createMatteBorder(top,left,bottom,rig ht,color) — is similar to createLineBorder , except that you can specify individual thicknesses for the top, left, bottom, and right edges of the component. • — creates a border that looks like a groove BorderFactory.createEtchedBorder() etched around the boundary of the component. The effect is ach ieved using lighter and es not work well with every darker shades of the component’s background color, and it do background color. • BorderFactory.createLoweredBevelBorder() —gives a component a three-dimensional effect that makes it look like it is lowered into the computer s creen. As with an Etched- Border, this only works well for certain background colors. • BorderFactory.createRaisedBevelBorder() —similar to a LoweredBevelBorder, but the component looks like it is raised above the computer scre en. • BorderFactory.createTitledBorder(title) —creates a border with a title. The title is a String , which is displayed in the upper left corner of the border. There are many other methods in the BorderFactory class, most of them providing vari- ations of the basic border styles given here. The following i llustration shows six components with six different border styles. The text in each component i s the command that created the border for that component:

318 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 305 an be found in .) (The source code for the program that produced this picture c 6.6.3 SliderAndButtonDemo Now that we have looked at components and layouts, it’s time t o put them together into some JLabel , three JButtons , and a complete programs. We start with a simple demo that uses a JSliders couple of GridLayout , as shown in this picture: , all laid out in a The sliders in this program control the foreground and backg round color of the label, and the buttons control its font style. Writing this program is a mat ter of creating the components, laying them out, and programming listeners to respond to eve nts from the sliders and buttons. My program is defined as a subclass of JPanel that implements ChangeListener and ActionLis- tener , so that the panel itself can act as the listener for change ev ents from the sliders and action nts are created and configured, a events from the buttons. In the constructor, the six compone GridLayout onents are added to is installed as the layout manager for the panel, and the comp the panel: /* Create the display label, with properties to match the values of the sliders and the setting of the combo box. */ displayLabel = new JLabel("Hello World!", JLabel.CENTER) ; displayLabel.setOpaque(true); displayLabel.setBackground( new Color(100,100,100) ); displayLabel.setForeground( Color.RED ); displayLabel.setFont( new Font("Serif", Font.BOLD, 30) ) ; displayLabel.setBorder(BorderFactory.createEmptyBor der(0,8,0,8)); /* Create the sliders, and set up the panel to listen for ChangeEvents that are generated by the sliders. */

319 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 306 bgColorSlider = new JSlider(0,255,100); bgColorSlider.addChangeListener(this); fgColorSlider = new JSlider(0,100,0); fgColorSlider.addChangeListener(this); he /* Create three buttons to control the font style, and set up t panel to listen for ActionEvents from the buttons. */ JButton plainButton = new JButton("Plain Font"); plainButton.addActionListener(this); JButton italicButton = new JButton("Italic Font"); italicButton.addActionListener(this); JButton boldButton = new JButton("Bold Font"); boldButton.addActionListener(this); /* Set the layout for the panel, and add the six components. Use a GridLayout with 3 rows and 2 columns, and with 5 pixels between components. */ setLayout(new GridLayout(3,2,5,5)); add(displayLabel); add(plainButton); add(bgColorSlider); add(italicButton); add(fgColorSlider); add(boldButton); ActionListener The class also defines the methods required by the ChangeListener inter- and faces. The actionPerformed() method is called when the user clicks one of the buttons. This method changes the font in the JLabel , where the font depends on which button was clicked. To determine which button was clicked, the method uses evt.getActionCommand() , which returns the text from the button: public void actionPerformed(ActionEvent evt) { String cmd = evt.getActionCommand(); if (cmd.equals("Plain Font")) { displayLabel.setFont( new Font("Serif", Font.PLAIN, 30) ); } else if (cmd.equals("Italic Font")) { ) ); displayLabel.setFont( new Font("Serif", Font.ITALIC, 30 } else if (cmd.equals("Bold Font")) { displayLabel.setFont( new Font("Serif", Font.BOLD, 30) ) ; } } stateChanged() method, which is called when the user manipulates one of the s liders, And the uses the value on the slider to compute a new foreground or bac kground color for the label. The method checks evt.getSource() to determine which slider was changed: public void stateChanged(ChangeEvent evt) { if (evt.getSource() == bgColorSlider) { int bgVal = bgColorSlider.getValue(); displayLabel.setBackground( new Color(bgVal,bgVal,bgV al) ); // NOTE: The background color is a shade of gray,

320 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 307 // determined by the setting on the slider. } else { float hue = fgColorSlider.getValue()/100.0f; 0f, 1.0f) ); displayLabel.setForeground( Color.getHSBColor(hue, 1. // Note: The foreground color ranges through all the colors // of the spectrum. } } Note that the slider variables are global variables in the pr ogram because they are referenced stateChanged() method as well as in the constructor. On the other hand, the bu tton in the at is the only place where they are variables are local variables in the constructor because th used. The complete source code for this example is in the file . 6.6.4 A Simple Calculator As our next example, we look briefly at an example that uses nes ted subpanels to build a more complex user interface. The program has two JTextFields where the user can enter two numbers, JButtons four the two numbers, and that the user can click to add, subtract, multiply, or divide a JLabel that displays the result of the operation. Here is a picture f rom the program: This example uses a panel with a GridLayout that has four rows and one column. In this case, the layout is created with the statement: setLayout(new GridLayout(4,1,3,3)); kground color of the panel is which allows a 3-pixel gap between the rows where the gray bac visible. nts, a JLabel displaying the The first row of the grid layout actually contains two compone x = ” and a JTextField . A grid layout can only have one component in each position. I n text “ this case, the component in the first row is a JPanel , a subpanel that is nested inside the main panel. This subpanel in turn contains the label and text field . This can be programmed as follows: xInput = new JTextField("0", 10); // Create a text field size d to hold 10 chars. JPanel xPanel = new JPanel(); // Create the subpanel. xPanel.add( new JLabel(" x = ")); // Add a label to the subpane l. xPanel.add(xInput); // Add the text field to the subpanel add(xPanel); // Add the subpanel to the main panel. The subpanel uses the default FlowLayout layout manager, so the label and text field are simply placed next to each other in the subpanel at their preferred s ize, and are centered in the subpanel.

321 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 308 contains four buttons. In this Similarly, the third row of the grid layout is a subpanel that with one row and four columns, so that the buttons are case, the subpanel uses a GridLayout all the same size and completely fill the subpanel. actionPerformed() One other point of interest in this example is the method that responds when the user clicks one of the buttons. This method must retr ieve the user’s numbers from the text fields, perform the appropriate arithmetic operati on on them (depending on which JLabel (named button was clicked), and set the text of the ) to represent the result. answer However, the contents of the text fields can only be retrieved as strings, and these strings must l is set to display an error message: be converted into numbers. If the conversion fails, the labe public void actionPerformed(ActionEvent evt) { double x, y; // The numbers from the input boxes. try { String xStr = xInput.getText(); x = Double.parseDouble(xStr); } catch (NumberFormatException e) { // The string xStr is not a legal number. answer.setText("Illegal data for x."); xInput.requestFocusInWindow(); return; } try { String yStr = yInput.getText(); y = Double.parseDouble(yStr); } catch (NumberFormatException e) { // The string yStr is not a legal number. answer.setText("Illegal data for y."); yInput.requestFocusInWindow(); return; } /* Perform the operation based on the action command from the button. The action command is the text displayed on the butto n. Note that division by zero produces an error message. */ String op = evt.getActionCommand(); if (op.equals("+")) answer.setText( "x + y = " + (x+y) ); else if (op.equals("-")) answer.setText( "x - y = " + (x-y) ); else if (op.equals("*")) answer.setText( "x * y = " + (x*y) ); else if (op.equals("/")) { if (y == 0) answer.setText("Can’t divide by zero!"); else answer.setText( "x / y = " + (x/y) ); } } // end actionPerformed()

322 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 309 . The complete source code for this example can be found in 6.6.5 Using a null Layout As mentioned above, it is possible to do without a layout mana ger altogether. For our next example, we’ll look at a panel that does not use a layout manag er. If you set the layout manager of a container to be container.setLayout(null) , then you assume complete null , by calling n that container. responsibility for positioning and sizing the components i comp is any component, then the statement If comp.setBounds(x, y, width, height); puts the top left corner of the component at the point , measured in the coordinate system (x,y) width and height of the component of the container that contains the component, and it sets the ponent if the container that to the specified values. You should only set the bounds of a com a non-null layout manager, the contains it has a null layout manager. In a container that has layout manager is responsible for setting the bounds, and yo u should not interfere with its job. Assuming that you have set the layout manager to null , you can call the setBounds() method any time you like. (You can even make a component that m oves or changes size while the user is watching.) If you are writing a panel that has a kno wn, fixed size, then you can Note that you must also add the set the bounds of each component in the panel’s constructor. add(component) instance method; otherwise, the components to the panel, using the panel’s component will not appear on the screen. and a panel that displays a Our example contains four components: two buttons, a label, checkerboard pattern: This is just an example of using a null layout; it doesn’t do an ything, except that clicking the buttons changes the text of the label. (We will use this examp le in Section 7.5 as a starting point for a checkers game.) The panel in this program is defined by the class , which is created as a NullLayoutDemo subclass of JPanel . The four components are created and added to the panel in the constructor. Then the setBounds() method of each component is called to set the size and positio n of the component: public NullLayoutDemo() { setLayout(null); // I will do the layout myself! setBackground(new Color(0,120,0)); // A dark green backgr ound.

323 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 310 setBorder( BorderFactory.createEtchedBorder() ); setPreferredSize( new Dimension(350,240) ); /* Create the components and add them to the content pane. If y ou don’t add them to a container, they won’t appear, even if you set their bounds! */ board = new Checkerboard(); tatic // (Checkerboard is a subclass of JPanel, defined below as a s // nested class inside the main class.) add(board); newGameButton = new JButton("New Game"); newGameButton.addActionListener(this); add(newGameButton); resignButton = new JButton("Resign"); resignButton.addActionListener(this); add(resignButton); message = new JLabel("Click \"New Game\" to begin."); message.setForeground( new Color(100,255,100) ); // Ligh t green. message.setFont(new Font("Serif", Font.BOLD, 14)); add(message); /* Set the position and size of each component by calling its setBounds() method. */ board.setBounds(20,20,164,164); newGameButton.setBounds(210, 60, 120, 30); resignButton.setBounds(210, 120, 120, 30); message.setBounds(20, 200, 330, 30); } // end constructor It’s fairly easy in this case to get a reasonable layout. It’s much more difficult to do your own layout if you want to allow for changes of size. In that case, y ou have to respond to changes in the container’s size by recomputing the sizes and positions of all the components that it contains. If you want to respond to changes in a container’s size, you ca n register an appropriate listener with the container. Any component generates an event of type ComponentEvent when its size changes (and also when it is moved, hidden, or shown). You can register a ComponentListener ng the sizes and positions of with the container and respond to resize events by recomputi e for more information about all the components in the container. Consult a Java referenc ComponentEvents . However, my real advice is that if you want to allow for chang es in the container’s size, try to find a layout manager to do the work fo r you. The complete source code for this example is in . 6.6.6 A Little Card Game For a final example, let’s look at something a little more inte resting as a program. The example is a simple card game in which you look at a playing card and try to predict whether the next card will be higher or lower in value. (Aces have the lowest va lue in this game.) You’ve seen a , Subsection 5.4.3 . Section 5.4 also introduced Deck text-oriented version of the same game in Hand , and Card classes that are used by the program. In this GUI version of th e game, you click on a button to make your prediction. If you predict wrong, you lose. If you make three correct

324 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 311 ck the “New Game” button to predictions, you win. After completing one game, you can cli start a new game. Here is what the program looks like in the mid dle of a game: . I encourage The complete source code for the panel can be found in the file you to compile and run it. Remember that you also need , and , , since they define classes that are used in the program. The overall structure of the main panel in this example shoul d be reasonably clear: It and a large drawing surface has three buttons in a subpanel at the bottom of the main panel are not components in this that displays the cards and a message. (The cards and message el’s method.) example; they are drawn using the graphics context in the pan paintComponent() BorderLayout . The drawing surface occupies the CENTER The main panel uses a position of the border layout. The subpanel that contains the buttons occup ies the SOUTH position of the border layout, and the other three positions of the borderla yout are empty. The drawing surface is defined by a nested class named CardPanel , which is subclass of JPanel . I have chosen to let the drawing surface object do most of the work of the game: It ing the appropriate actions. The listens for events from the three buttons and responds by tak HighLowGUI itself, which is also a subclass of JPanel . The constructor main panel is defined by of the class creates all the other components, sets up event handli ng, and lays out HighLowGUI the components: public HighLowGUI() { // The constructor. setBackground( new Color(130,50,40) ); setLayout( new BorderLayout(3,3) ); // BorderLayout with 3 -pixel gaps. CardPanel board = new CardPanel(); // Where the cards are dra wn. add(board, BorderLayout.CENTER); JPanel buttonPanel = new JPanel(); // The subpanel that hold s the buttons. buttonPanel.setBackground( new Color(220,200,180) ); add(buttonPanel, BorderLayout.SOUTH); JButton higher = new JButton( "Higher" ); higher.addActionListener(board); // The CardPanel liste ns for events. buttonPanel.add(higher); JButton lower = new JButton( "Lower" ); lower.addActionListener(board); buttonPanel.add(lower); JButton newGame = new JButton( "New Game" ); newGame.addActionListener(board); buttonPanel.add(newGame);

325 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 312 30,50,40), 3) ); setBorder(BorderFactory.createLineBorder( new Color(1 } // end constructor , is a nice example of thinking The programming of the drawing surface class, CardPanel in terms of a state machine. (See Subsection 6.4.4 .) It is important to think in terms of the states that the game can be in, how the state can change, and ho w the response to events can depend on the state. The approach that produced the origi nal, text-oriented game in ms of a process is not appropriate here. Trying to think about the game in ter Subsection 5.4.3 that goes step-by-step from beginning to end is more likely t o confuse you than to help you. The state of the game includes the cards and the message. The c ards are stored in an Hand . The message is a object of type . These values are stored in instance variables. String There is also another, less obvious aspect of the state: Some times a game is in progress, and Sometimes we are between the user is supposed to make a prediction about the next card. . It’s a good idea to keep games, and the user is supposed to click the “New Game” button track of this basic difference in state. The CardPanel class uses a boolean instance variable gameInProgress for this purpose. named utton. The CardPanel The state of the game can change whenever the user clicks on a b class implements the ActionListener interface and defines an actionPerformed() method to respond to the user’s clicks. This method simply calls one of three other methods, doHigher() , doLower() , or , depending on which button was pressed. It’s in these three e vent- newGame() handling methods that the action of the game takes place. We don’t want to let the user start a new game if a game is curren tly in progress. That would be cheating. So, the response in the newGame() method is different depending on whether the gameInProgress is true or false. If a game is in progress, the state variable instance message variable should be set to be an error message. If a game is not i n progress, then all the state variables should be set to appropriate values for the beginn ing of a new game. In any case, the board must be repainted so that the user can see that the state has changed. The complete newGame() method is as follows: /** * Called by the CardPanel constructor, and called by actionP erformed() if * the user clicks the "New Game" button. Start a new game. */ void doNewGame() { if (gameInProgress) { // If the current game is not over, it is an error to try // to start a new game. message = "You still have to finish this game!"; repaint(); return; } me. deck = new Deck(); // Create the deck and hand to use for this ga hand = new Hand(); deck.shuffle(); hand.addCard( deck.dealCard() ); // Deal the first card int o the hand. message = "Is the next card higher or lower?"; gameInProgress = true; repaint(); } // end doNewGame()

326 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 313 doHigher() and methods are almost identical to each other (and could The doLower() , if I were more clever). Let’s probably have been combined into one method with a parameter look at the routine. This is called when the user clicks the “Higher” but ton. This doHigher() should do is check the only makes sense if a game is in progress, so the first thing doHigher() gameInProgress false , then doHigher() should just value of the state variable . If the value is set up an error message. If a game is in progress, a new card sho uld be added to the hand and the user’s prediction should be tested. The user might win or lose at this time. If so, the value of the state variable must be set to false because the game is over. In any gameInProgress doHigher() case, the board is repainted to show the new state. Here is the method: /** * Called by actionPerformed() when user clicks the "Higher" button. * Check the user’s prediction. Game ends if user guessed * wrong or if the user has made three correct predictions. */ void doHigher() { if (gameInProgress == false) { // If the game has ended, it was an error to click "Higher", // So set up an error message and abort processing. message = "Click \"New Game\" to start a new game!"; repaint(); return; } hand.addCard( deck.dealCard() ); // Deal a card to the hand. int cardCt = hand.getCardCount(); . Card thisCard = hand.getCard( cardCt - 1 ); // Card just dealt Card prevCard = hand.getCard( cardCt - 2 ); // The previous ca rd. if ( thisCard.getValue() < prevCard.getValue() ) { gameInProgress = false; message = "Too bad! You lose."; } else if ( thisCard.getValue() == prevCard.getValue() ) { gameInProgress = false; message = "Too bad! You lose on ties."; } guesses. else if ( cardCt == 4) { // The hand is full, after three correct gameInProgress = false; message = "You win! You made three correct guesses."; } else { message = "Got it right! Try for " + cardCt + "."; } repaint(); } // end doHigher() The paintComponent() method of the CardPanel class uses the values in the state variables to decide what to show. It displays the string stored in the variable. It draws each message of the cards in the hand . There is one little tricky bit: If a game is in progress, it dr aws an extra face-down card, which is not in the hand, to represent t he next card in the deck. Drawing the cards requires some care and computation. I wrote a metho d, “ void drawCard(Graphics g, Card card, int x, int y) ”, which draws a card with its upper left corner at the point (x,y) . The paintComponent() routine decides where to draw each card and calls this routin e

327 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 314 . ce code, to do the drawing. You can check out all the details in the sour ve. A version of the program (The playing cards used in this program are not very impressi with images that actually look like cards can be found in .) Subsection 13.1.3 6.7 Menus and Dialogs many of the basic aspects of GUI programming, but W e have already encountered professional programs use many additional features. We wil l cover some of the advanced features Chapter 13 , but in this section we look briefly at a few more of Java GUI programming in features that are essential for writing GUI programs. I will discuss these features in the context of a “MosaicDraw” program that is shown in this picture: The source code for the program is in the file . The program also requires and . You will want to try it out! rea of this program, it leaves As the user clicks-and-drags the mouse in the large drawing a a trail of little colored squares. There is some random varia tion in the color of the squares. (This is meant to make the picture look a little more like a rea l mosaic, which is a picture made out of small colored stones in which there would be some natur al color variation.) There is a menu bar above the drawing area. The “Control” menu contain s commands for filling and t the appearance of the picture. clearing the drawing area, along with a few options that affec ed when the user draws. The The “Color” menu lets the user select the color that will be us “Tools” menu affects the behavior of the mouse. Using the defa ult “Draw” tool, the mouse he mouse leaves a swath of colored leaves a trail of single squares. Using the “Draw 3x3” tool, t ols, which let the user set squares squares that is three squares wide. There are also “Erase” to back to their default black color. The drawing area of the program is a panel that belongs to the MosaicPanel class, a subclass of JPanel that is defined in MosaicPanel is a highly reusable class for repre- . senting mosaics of colored rectangles. It was also used behi nd the scenes in the sample program class does not directly support drawing on the mosaic, but Subsection 4.6.3 . The MosaicPanel in it does support setting the color of each individual square. The MosaicDraw program installs a mouse listener on the panel; the mouse listener responds to m ousePressed and mouseDragged events on the panel by setting the color of the square that con tains the mouse. This is a nice

328 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 315 at was not programmed into the example of applying a listener to an object to do something th object itself. The file is a simple class that contains only the main() routine for the pro- gram. Most of the programming for MosaicDraw can be found in . MosaicPanel class, if I had not decided to use that pre-existing (It might have gone into the class in unmodified form.) It is the MosaicPanel ob- MosaicDrawController class that creates a ar that is shown at the top of ject and adds a mouse listener to it. It also creates the menu b the program, and it implements all the commands in the menu ba r. It has an instance method getMosaicPanel() that returns a reference to the mosaic panel that it has creat ed, and it getMenuBar() that returns a menu bar for the program. These has another instance method an be added to the program’s methods are used to obtain the panel and menu bar so that they c window. I urge you to study and MosaicDr I will not be dis- cussing all aspects of the code here, but you should be able to understand it all after reading this section. As for, it uses some techniq ues that you would not understand s in this file to learn about the at this point, but I encourage you to at least read the comment API for mosaic panels. 6.7.1 Menus and Menubars nu bar. Fortunately, menus MosaicDraw is the first example that we have seen that uses a me d by the class are very easy to use in Java. The items in a menu are represente (this JMenuItem javax.swing ). Menu items are used in class and other menu-related classes are in package JMenuItem and JButton are both subclasses almost exactly the same way as buttons. In fact, of a class, AbstractButton , that defines their common behavior. In particular, a JMenuItem is created using a constructor that specifies the text of the men u item, such as: JMenuItem fillCommand = new JMenuItem("Fill"); You can add an to a JMenuItem by calling the menu item’s addActionListener() ActionListener method. The actionPerformed() method of the action listener is called when the user selects lling its the item from the menu. You can change the text of the item by ca setText(String) method, and you can enable it and disable it using the method. All this setEnabled(boolean) JButton works in exactly the same way as for a . The main difference between a menu item and a button, of course , is that a menu item is meant to appear in a menu rather than in a panel. A menu in Jav a is represented by the class JMenu . A JMenu has a name, which is specified in the constructor, and it has an add(JMenuItem) method that can be used to add a to the menu. For example, the JMenuItem llows, where “Tools” menu in the MosaicDraw program could be created as fo is a listener variable of type ActionListener : JMenu toolsMenu = new JMenu("Tools"); // Create a menu with n ame "Tools" JMenuItem drawCommand = new JMenuItem("Draw"); // Create a menu item. drawCommand.addActionListener(listener); // Add listen er to menu item. toolsMenu.add(drawCommand); // Add menu item to menu. JMenuItem eraseCommand = new JMenuItem("Erase"); // Creat e a menu item. eraseCommand.addActionListener(listener); // Add liste ner to menu item. toolsMenu.add(eraseCommand); // Add menu item to menu. . . // Create and add other menu items.

329 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 316 . Once a menu has been created, it must be added to a menu bar. A me nu bar is represented . A menu bar is just a container for menus. It does not have a nam by the class e, JMenuBar and its constructor does not have any parameters. It has an add(JMenu) method that can be used to add menus to the menu bar. The name of the menu then ap pears in the menu , bar. For example, the MosaicDraw program uses three menus, , and controlMenu colorMenu . We could create a menu bar and add the menus to it with the stat ements: toolsMenu JMenuBar menuBar = new JMenuBar(); menuBar.add(controlMenu); menuBar.add(colorMenu); menuBar.add(toolsMenu); The final step in using menus is to use the menu bar in a window su JFrame . We ch as a have already seen that a frame has a “content pane.” The menu b ar is another component of JFrame the frame, not contained inside the content pane. The class has an instance method setMenuBar(JMenuBar) that can be used to set the menu bar. (There can only be one, so this is a “set” method rather than an “add” method.) In the Mos aicDraw program, the menu MosaicDrawController object and can be obtained by calling that object’s bar is created by a method. The main() routine in gets the menu bar from the getMenuBar() controller and adds it to the window. Here is the basic code th at is used (in somewhat modified form) to set up the interface: MosaicDrawController controller = new MosaicDrawControl ler(); MosaicPanel content = controller.getMosaicPanel(); window.setContentPane( content ); // Use panel from contro ller as content pane. JMenuBar menuBar = controller.getMenuBar(); window.setJMenuBar( menuBar ); // Use the menu bar from the c ontroller. Using menus always follows the same general pattern: Create a menu bar. Create menus and add them to the menu bar. Create menu items and add them to t he menus (and set up listening to handle action events from the menu items). Use t he menu bar in a window by setJMenuBar() method. calling the window’s ∗ ∗ ∗ There are other kinds of menu items, defined by subclasses of JMenuItem , that can be added to menus. One of these is JCheckBoxMenuItem , which represents menu items that can be in one of two states, selected or not selected. A JCheckBoxMenuItem has the same functionality and is used in the same way as a JCheckBox (see Subsection 6.5.3 ). Three JCheckBoxMenuItems is used to turn the random are used in the “Control” menu of the MosaicDraw program. One color variation of the squares on and off. Another turns a symm etry feature on and off; when symmetry is turned on, the user’s drawing is reflected horizo ntally and vertically to produce a symmetric pattern. And the third checkbox menu item shows an d hides the “grouting” in the mosaic; the grouting is the gray lines that are drawn around e ach of the little squares in the mosaic. The menu item that corresponds to the “Use Randomnes s” option in the “Control” menu could be set up with the statements: JMenuItem useRandomnessToggle = new JCheckBoxMenuItem(" Use Randomness"); useRandomnessToggle.addActionListener(listener); // S et up a listener. useRandomnessToggle.setSelected(true); // Randomness i s initially turned on. controlMenu.add(useRandomnessToggle); // Add the menu it em to the menu.

330 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 317 JCheckBoxMenuItem corresponds to a boolean- In my program, the “Use Randomness” in the useRandomness MosaicDrawController valued instance variable named class. This vari- s tested whenever the user draws able is part of the state of the controller object. Its value i one of the squares, to decide whether or not to add a random var iation to the color of the square. When the user selects the “Use Randomness” command f rom the menu, the state of the cted to se- JCheckBoxMenuItem is reversed, from selected to not-selected or from not-sele ActionListener for the menu item checks whether the menu item is selected or n ot, lected. The and it changes the value of useRandomness to match. Note that selecting the menu command in the window. It just changes does not have any immediate effect on the picture that is shown the part of the user will have a the state of the program so that future drawing operations on enu works in much the same different effect. The “Use Symmetry” option in the “Control” m way. The “Show Grouting” option is a little different. Select ing the “Show Grouting” option ithout the grouting, depending does have an immediate effect: The picture is redrawn with or w on the state of the menu item. My program uses a single to respond to all of the menu items in all the ActionListener menus. This is not a particularly good design, but it is easy t o implement for a small program like this one. The method of the listener object uses the statement actionPerformed() String command = evt.getActionCommand(); to get the action command of the source of the event; this will be the text of the menu item. The listener tests the value of command to determine which menu item was selected by the user. If the menu item is a JCheckBoxMenuItem , the listener must check the state of the menu item. The menu item is the source of the event that is being processe d. The listener can get its hands on the menu item object by calling evt.getSource() getSource() . Since the return value of Object , for example, is is of type , the return value must be type-cast to the correct type. Here the code that handles the “Use Randomness” command: if (command.equals("Use Randomness")) { // Set the value of useRandomness depending on the menu item’ s state. ource(); JCheckBoxMenuItem toggle = (JCheckBoxMenuItem)evt.getS useRandomness = toggle.isSelected(); } actionPerformed() method uses a rather long if..then..else (The statement to check all the possible action commands. It might be more natural and effi cient use a switch statement with command as the selector and all the possible action commands as cases .) ∗ ∗ ∗ In addition to menu items, a menu can contain lines that separ ate the menu items into ins such a separator. A JMenu groups. In the MosaicDraw program, the “Control” menu conta has an instance method that can be used to add a separator to the menu. For addSeparator() example, the separator in the “Control” menu was created wit h the statement: controlMenu.addSeparator(); A menu can also contain a submenu. The name of the submenu appe ars as an item in the main menu. When the user moves the mouse over the submenu name , the submenu pops up. (There is no example of this in the MosaicDraw program.) It is very easy to do this in Java: You can add one JMenu to another JMenu using a statement such as mainMenu.add(submenu) , and it becomes a submenu.

331 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 318 6.7.2 Dialogs One of the commands in the “Color” menu of the MosaicDraw prog ram is “Custom Color. . . ”. e the user can select a color. When the user selects this command, a new window appears wher dialog box . A dialog is a type of window that is dialog This window is an example of a or the user. For example, a dialog box generally used for short, single purpose interactions with estion, to let the user select a can be used to display a message to the user, to ask the user a qu file to be opened, or to let the user select a color. In Swing, a d ialog box is represented by an or to a subclass. object belonging to the class JDialog JDialog class is very similar to JFrame and is used in much the same way. Like a The frame, a dialog box is a separate window. Unlike a frame, howe ver, a dialog is not completely independent. Every dialog is associated with a frame (or ano ther dialog), which is called its . The dialog box is dependent on its parent. For example, if th e parent is parent window closed, the dialog box will also be closed. It is possible to c reate a dialog box without specifying system to serve as the parent. a parent, but in that case an invisible frame is created by the modal or modeless . When a modal dialog is created, its parent Dialog boxes can be either frame is blocked. That is, the user will not be able to interac t with the parent until the dialog ts in the same way, so they seem box is closed. Modeless dialog boxes do not block their paren a lot more like independent windows. In practice, modal dial og boxes are easier to use and are ill look at are modal. much more common than modeless dialogs. All the examples we w Aside from having a parent, a JDialog can be created and used in the same way as a JFrame . However, I will not give any examples here of using JDialog directly. Swing has many convenient methods for creating common types of dialog boxe s. For example, the color choice dialog that appears when the user selects the “Custom Color” command in the MosaicDraw JColorChooser , which is a subclass of . The JColorChooser program belongs to the class JDialog y easy to use: class has a static method that makes color choice dialogs ver Color JColorChooser.showDialog(Component parentComp, String title, Color initialColor) When you call this method, a dialog box appears that allows th e user to select a color. The window of the dialog will be the first parameter specifies the parent of the dialog; the parent parentComp window (if any) that contains null and it can itself be a ; this parameter can be appears in the title bar of the frame or dialog object. The second parameter is a string that initialColor , specifies the color that is selected when dialog box. And the third parameter, the color choice dialog first appears. The dialog has a sophis ticated interface that allows the user to select a color. When the user presses an “OK” button, t he dialog box closes and the selected color is returned as the value of the method. The use r can also click a “Cancel” button or close the dialog box in some other way; in that case, null is returned as the value of the method. This is a modal dialog, and showDialog() does not return until the user dismisses the dialog box in some way. By using this predefined color choo ser dialog, you can write one line of code that will let the user select an arbitrary color. Swing also has a JFileChooser class that makes it almost as easy to show a dialog box that lets the u ser select a file to be opened or saved. ∗ ∗ ∗ The JOptionPane class includes a variety of methods for making simple dialog boxes that are variations on three basic types: a “message” dialog, a “c onfirm” dialog, and an “input” dialog. (The variations allow you to provide a title for the d ialog box, to specify the icon that

332 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 319 og box. I will only cover the appears in the dialog, and to add other components to the dial most basic forms here.) A message dialog simply displays a message string to the user . The user (hopefully) reads the message and dismisses the dialog by clicking the “OK” but ton. A message dialog can be shown by calling the static method: void JOptionPane.showMessageDialog(Component parentCo mp, String message) The message can be more than one line long. Lines in the messag e should be separated by . New lines will not be inserted automatically, even if the me newline characters, \n ssage is very this refers to a Component : long. For example, assuming that the special variable JOptionPane.showMessageDialog( this, "This program is ab out to crash!\n" + "Sorry about that."); er type in a string as a response. An input dialog displays a question or request and lets the us You can show an input dialog by calling: String JOptionPane.showInputDialog(Component parentCo mp, String question) Again, parentComp can be null , and the question can include newline characters. The dialo g utton. If the user clicks box will contain an input box, an “OK” button, and a “Cancel” b return value of the method is “Cancel”, or closes the dialog box in some other way, then the null . If the user clicks “OK”, then the return value is the string t hat was entered by the user. Note that the return value can be an empty string (which is not the same as a null value), if the user clicks “OK” without typing anything in the input box . If you want to use an input dialog to get a numerical value from the user, you will have to convert the return value into a number (see Subsection 3.7.2 ). As an example, String name; name = JOptionPanel.showInputDialog(null, "Hi! What’s yo ur name?"); if (name == null) JOptionPane.showMessageDialog(null, "Well, I’ll call yo u Grumpy."); else u, " + name); JOptionPane.showMessageDialog(null, "Pleased to meet yo Finally, a confirm dialog presents a question and three respo nse buttons: “Yes”, “No”, and “Cancel”. A confirm dialog can be shown by calling: int JOptionPane.showConfirmDialog(Component parentCom p, String question) The return value tells you the user’s response. It is one of th e following constants: — the user clicked the “Yes” button OPTION JOptionPane.YES • • JOptionPane.NO OPTION — the user clicked the “No” button OPTION — the user clicked the “Cancel” button • JOptionPane.CANCEL • JOptionPane.CLOSE OPTION — the dialog was closed in some other way. By the way, it is possible to omit the Cancel button from a confi rm dialog by calling one of the other methods in the JOptionPane class. Just call: JOptionPane.showConfirmDialog( NO OPTION ) parent, question, title, JOptionPane.YES

333 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 320 es” button and a “No” button The final parameter is a constant which specifies that only a “Y should be used. The third parameter is a string that will be di splayed as the title of the dialog box window. A small demo program, is available to demonstrate JColorChooser and several JOptionPane dialogs. 6.7.3 Fine Points of Frames object in a main() routine In previous sections, whenever I used a frame, I created a JFrame orks fine, but a more object- and installed a panel as the content pane of that frame. This w oriented approach is to define a subclass of JFrame and to set up the contents of the frame in the constructor of that class. This is what I did in the case of the MosaicDraw program. is defined as a subclass of MosaicDraw . The definition of this class is very short, but it JFrame illustrates several new features of frames that I want to dis cuss: public class MosaicDraw extends JFrame { public static void main(String[] args) { JFrame window = new MosaicDraw(); ON CLOSE); window.setDefaultCloseOperation(JFrame.EXIT window.setVisible(true); } public MosaicDraw() { super("Mosaic Draw"); ler(); MosaicDrawController controller = new MosaicDrawControl setContentPane( controller.getMosaicPanel() ); setJMenuBar( controller.getMenuBar() ); pack(); Dimension screensize = Toolkit.getDefaultToolkit().get ScreenSize(); setLocation( (screensize.width - getWidth())/2, (screensize.height - getHeight())/2 ); } } super("Mosaic Draw") , which calls The constructor in this class begins with the statement . The parameter specifies a title that will appear in the constructor in the superclass, JFrame the title bar of the window. The next three lines of the constr uctor set up the contents of the window; a MosaicDrawController is created, and the content pane and menu bar of the window are obtained from the controller. The next line is something window is a variable of new. If type JFrame (or JDialog ), then the statement window.pack() will resize the window so that its size matches the preferred size of its contents. (In this cas e, of course, “ pack() ” is equivalent to “ ”; that is, it refers to the window that is being created by the constructor.) this.pack() The pack() method is usually the best way to set the size of a window. Note that it will only work correctly if every component in the window has a correct preferred size. This is only a problem in two cases: when a panel is used as a drawing surface and when a panel is used as a container with a null layout manager. In both these cases there is no way for the sys tem to determine the correct preferred size automatically, and yo u should set a preferred size by hand. For example: panel.setPreferredSize( new Dimension(400, 250) );

334 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 321 hat it is exactly centered on The last two lines in the constructor position the window so t the screen. The line ScreenSize(); Dimension screensize = Toolkit.getDefaultToolkit().get screensize.width determines the size of the screen. The size of the screen is pixels in the hor- pixels in the vertical direction. The screensize.height izontal direction and setLocation() method of the frame sets the position of the upper left corner of the frame on the screen. The ” is the amount of horizontal space left on the expression “ screensize.width - getWidth() ided by 2 so that half of the empty screen after subtracting the width of the window. This is div space will be to the left of the window, leaving the other half of the space to the right of the window. Similarly, half of the extra vertical space is above the window, and half is below. Note that the constructor has created the window and set its s ize and position, but that at the end of the constructor, the window is not yet visible on the screen. (More exactly, the object constructor has created the window , but the visual representation of that object on the screen has not yet been created.) To show the window on the scr een, it will be necessary to window.setVisible(true) call its instance method, . In addition to the constructor, the MosaicDraw class includes a main() routine. This makes MosaicDraw as a stand-alone application. (The main() routine, as a it possible to run static method, has nothing to do with the function of a object, and it could (and perhaps MosaicDraw main() should) be in a separate class.) The MosaicDraw and makes it visible routine creates a on the screen. It also calls window.setDefaultCloseOperation(JFrame.EXIT ON CLOSE); which means that the program will end when the user closes the window. Note that this is MosaicDraw less flexible. It is not done in the constructor because doing it there would make possible, for example, to write a program that lets the user o pen multiple MosaicDraw windows. In that case, we don’t want to shut down the whole program just because the user has closed one lt close operation of a window: of the windows. There are other possible values for the defau • JFrame.DO ON NOTHING — the user’s attempts to close the window by clicking its CLOSE close box will be ignored, except that it will generate a . A program can WindowEvent r attempts to close the listen for this event and take any action it wants when the use window. JFrame.HIDE • ON CLOSE — when the user clicks its close box, the window will be hidden just as if window.setVisible(false) were called. The window can be made visible again by calling window.setVisible(true) . This is the value that is used if you do not specify setDefaultCloseOperation . another value by calling • JFrame.DISPOSE ON CLOSE — the window is closed and any operating system resources used by the window are released. It is not possible to make the window visible again. (This is the proper way to permanently get rid of a window with out ending the program. You can accomplish the same thing programmatically by calli ng the instance method window.dispose() .) 6.7.4 Creating Jar Files As the final topic for this chapter, we look again at jar files. R ecall that a jar file is a “java archive” that can contain a number of class files. When creati ng a program that uses more than one class, it’s usually a good idea to place all the class es that are required by the program

335 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 322 ne file to run the program. In into a jar file. If that is done, then a user will only need that o . A user can run an executable jar fact, it is possible to make a so-called executable jar file ouble-clicking the icon of the file in much the same way as any other application, usually by d jar file. (The user’s computer must have a correct version of J ava installed, and the computer must be configured correctly for this to work. The configurati on is usually done automatically when Java is installed, at least on Windows and Mac OS.) The question, then, is how to create a jar file. The answer depe nds on what programming environment you are using. The two basic types of programmin g environment—command line and IDE—were discussed in Section 2.6 . Any IDE (Integrated Programming Environment) for Java should have a command for creating jar files. In the Eclip se IDE, for example, it can be done as follows: In the Package Explorer pane, select the pro gramming project (or just all the he selection, and choose “Export” individual source code files that you need). Right-click on t from the menu that pops up. In the window that appears, select “JAR file” and click “Next”. In the window that appears next, enter a name for the jar file in the box labeled “JAR file”. (Click the “Browse” button next to this box to select the file n ame using a file dialog box.) The gular jar file, not an executable name of the file should end with “.jar”. If you are creating a re created. To create an executable one, you can hit “Finish” at this point, and the jar file will be file, hit the “Next” button twice to get to the “Jar Manifest Specification” screen. At the bottom of this screen is an input box labeled “Main class”. Yo u have to enter the name of the main() routine that will be run when the jar file is executed. If you class that contains the hit the “Browse” button next to the “Main class” box, you can s elect the class from a list of main() routines. Once you’ve selected the main class, you can click the classes that contain “Finish” button to create the executable jar file. (Note that newer versions of Eclipse also have an option for exporting an executable Jar file in fewer steps. ) It is also possible to create jar files on the command line. The Java Development Kit includes a command-line program named jar that can be used to create jar files. If all your classes are in the default package (like most of the examples in this book ), then the command is easy jar , change to the directory that to use. To create a non-executable jar file on the command line en give the command contains the class files that you want to include in the jar. Th jar cf JarFileName.jar *.class JarFileName can be any name that you want to use for the jar file. The “ * ” in “ *.class ” where is a wildcard that makes *.class match every class file in the current directory. This means e jar file. If you want to include that all the class files in the directory will be included in th only certain class files, you can name them individually, sep arated by spaces. (Things get more n that case, the class files must be complicated if your classes are not in the default package. I in subdirectories of the directory in which you issue the jar command. See Subsection 2.6.6 .) Making an executable jar file on the command line is more compl icated. There has to be some way of specifying which class contains the main() routine. This is done by creating a manifest file . The manifest file can be a plain text file containing a single l ine of the form Main-Class: ClassName where ClassName should be replaced by the name of the class that contains the main() routine. For example, if the routine is in the class MosaicDraw , then the manifest file should main() read “ Main-Class: MosaicDraw ”. You can give the manifest file any name you like. Put it in the same directory where you will issue the jar command, and use a command of the form jar cmf ManifestFileName JarFileName.jar *.class

336 CHAPTER 6. INTRODUCTION TO GUI PROGRAMMING 323 to create the jar file. (The jar command is capable of performing a variety of different opera - tions. The first parameter to the command, such as “ cf ” or “ cmf ”, tells it which operation to perform.) By the way, if you have successfully created an executable ja r file, you can run it on the command line using the command “ java -jar ”. For example: java -jar JarFileName.jar

337 Exercises 324 Exercises for Chapter 6 Subsection 6.3.3 , a rectangle or oval is drawn on (solution) 1. In the example from SimpleStamper r shift-clicks, the panel the panel when the user clicks the mouse. Except, when the use sion will continue to draw is cleared instead. Modify this class so that the modified ver figures as the user drags the mouse. That is, the mouse will lea ve a trail of figures as the user drags. However, if the user shift-clicks, the panel sho uld simply be cleared and no figures should be drawn even if the user drags the mouse after s hift-clicking. Here is a picture of my solution: The source code for the original program is . See the discussion Subsection 6.3.4 . (Note that the original version uses a black background, of dragging in with a black border around each shape. That didn’t work well w ith a lot of closely spaced shapes, so the new version uses a white background.) If you want to make the problem a little more challenging, whe n drawing shapes during a drag operation, make sure that the shapes that are drawn are at least, say, 5 pixels apart. To implement this, you have to keep track of the position of th e last shape that was drawn. 2. Write a program that shows a small red square and a small blue s quare. The user should be (solution) able to drag either square with the mouse. (You’ll need an ins tance variable to remember which square the user is dragging.) The user can drag the squa re out of the panel if she wants; if she does this, there is no way to get it back. Note that for this exercise, you should do all the drawing in t paintComponent() he method (as indeed you should whenever possible). 3. Write a program that shows a pair of dice. When the user clicks on the panel in the (solution) program, the dice should be rolled (that is, the dice should b e assigned newly computed random values). Each die should be drawn as a square showing f rom 1 to 6 dots. Since you have to draw two dice, its a good idea to write a subroutine, “ void drawDie(Graphics g, int val, int x, int y) ”, to draw a die at the specified (x,y) coordinates. The second parameter, val , specifies the value that is showing on the die. Assume that th e size of the panel is 100 by 100 pixels. Here is a picture of the p anel that displays the dice:

338 Exercises 325 In Exercise 6.3, you wrote a pair-of-dice panel where the dic (solution) e are rolled when the user 4. clicks on the panel. Now make a pair-of-dice program in which the user rolls the dice by clicking a button. The button should appear under the pane l that shows the dice. Also make the following change: When the dice are rolled, ins tead of just showing the new value, show a short animation during which the values on t he dice are changed in ore like they are actually every frame. The animation is supposed to make the dice look m rolling. (solution) write a program where the 5. In Exercise 3.8, you drew a checkerboard. For this exercise, user can select a square by clicking on it. (Use a for the checkerboard.) Highlight JPanel en the program starts, the selected square by drawing a colored border around it. Wh no square is selected. When the user clicks on a square that is not currently selected, it becomes selected (and the previously selected square, if an y, is unselected). If the user clicks the square that is selected, it becomes unselected. A ssume that the size of the panel is exactly 160 by 160 pixels, so that each square on the checke rboard is 20 by 20 pixels. Here is my checkerboard, with the square in row 3, column 3 sel ected: For this exercise, you should modify the SubKiller game from . You can (solution) 6. Subsection 6.4.4 start with the existing source code, from the file . Modify the game so it keeps track of the number of hits and misses and displays thes e quantities. That is, every time the depth charge blows up the sub, the number of hits goes up by one. Every time the depth charge falls off the bottom of the screen without hit ting the sub, the number of misses goes up by one. There is room at the top of the panel to di splay these numbers. To do this exercise, you only have to add a half-dozen lines to the source code. But you have to figure out what they are and where to add them. To do this , you’ll have to read the source code closely enough to understand how it works. 7. Exercise 5.2 involved a class, , that could compute some statistics of a set (solution) of numbers. Write a GUI program that uses the StatCalc class to compute and display

339 Exercises 326 e an instance variable of statistics of numbers entered by the user. The panel will hav that does the computations. The panel should include a JTextField where type StatCalc lay four statistics for the the user enters a number. It should have four labels that disp numbers that have been entered: the number of numbers, the su m, the mean, and the standard deviation. Every time the user enters a new number, the statistics displayed on t into the and the labels should change. The user enters a number by typing i JTextField pressing return. There should be a “Clear” button that clear s out all the data. This means creating a new object and resetting the displays on the labels. My panel als o has StatCalc an “Enter” button that does the same thing as pressing the ret JTextField . urn key in the JTextField when the user presses return, so your ActionEvent (Recall that a generates an panel should register itself to listen for from the JTextField as well as the ActionEvents buttons.) Here is a picture of my solution to this problem: 8. Write a program that has a JTextArea where the user can enter some text. Then program (solution) should have a button such that when the user clicks on the butt on, the panel will count the user’s input, and the the number of lines in the user’s input, the number of words in hould be displayed on three number of characters in the user’s input. This information s textInput is a JTextArea , then you can get the contents of the labels. Recall that if by calling the function textInput.getText() . This function returns a String JTextArea containing all the text from the text area. The number of char acters is just the length of this String . Lines in the String are separated by the new line character, ’\n’ , so the number of lines is just the number of new line characters in th String , plus one. Words e are a little harder to count. Exercise 3.4 has some advice abo ut finding the words in a String . Essentially, you want to count the number of characters tha t are first characters in words. Don’t forget to put your JTextArea in a JScrollPane , and add the scroll pane to the container, not the text area. Scrollbars should appear w hen the user types more text than will fit in the available area. Here is a picture of my solu tion:

340 Exercises 327 A polygon gments. The (solution) 9. is a geometric figure made up of a sequence of connected line se of the polygon. The vertices Graph- points where the line segments meet are called the r these commands, the ics class includes commands for drawing and filling polygons. Fo g is a variable of type ys. If coordinates of the vertices of the polygon are stored in arra then Graphics g.drawPolygon(xCoords, yCoords, pointCt) • will draw the outline of the polygon (xCoords[0],yCoords[0]) (xCoords[1],yCoords[1]) , with vertices at the points , (xCoords[pointCt-1],yCoords[pointCt-1]) . The third parameter, . . . , , pointCt is an int that specifies the number of vertices of the polygon. Its valu e should be 3 or greater. The first two parameters are arrays of t ype int[] . Note that the polygon automatically includes a line from th e last (xCoords[pointCt-1],yCoords[pointCt-1]) point, , back to the starting point (xCoords[0],yCoords[0]) . g.fillPolygon(xCoords, yCoords, pointCt) fills the interior of the polygon with • ing as in the the current drawing color. The parameters have the same mean drawPolygon() method. Note that it is OK for the sides of the polygon to cross each other, but the interior of a polygon with self-intersec tions might not be exactly what you expect. Write a program that lets the user draw polygons. As the user c licks a sequence of points, count them and store their x- and y-coordinates in tw o arrays. These points will be the vertices of the polygon. As the user is creating the polyg on, you should just connect all the points with line segments. When the user clicks near t he starting point, draw the complete polygon. Draw it with a red interior and a black bord er. Once the user has completed a polygon, the next click will clear the data and st art a new polygon from scratch. All drawing should be done in the paintComponent() method. Here is a picture of my solution after the user has drawn a fair ly complex polygon:

341 Exercises 328 Write a GUI Blackjack program that lets the user play a game of Blackjack, with the 10. (solution) rds and the dealer’s cards, computer as the dealer. The program should draw the user’s ca just as was done for the graphical HighLow card game in . You can use Subsection 6.6.6 , for some ideas about how to write the source code for that game, your Blackjack game. The structures of the HighLow panel and the Blackjack panel are method from the HighLow drawCard() very similar. You will certainly want to use the program. You can find a description of the game of Blackjack in Exercise 5.5. Add the following rule to that description: If a player takes five cards without going over 21, that player wins immediately. This rule is used in some casinos. For your prog ram, it means that you only nel is just wide enough have to allow room for five cards. You should assume that the pa nd and the dealer’s hand. to show five cards, and that it is tall enough show the user’s ha Note that the design of a GUI Blackjack game is very different f rom the design of the text-oriented program that you wrote for Exercise 5.5. The u ser should play the game by clicking on “Hit” and “Stand” buttons. There should be a “New Game” button that can be used to start another game after one game ends. You have to d ecide what happens when each of these buttons is pressed. You don’t have much cha nce of getting this right unless you think in terms of the states that the game can be in a nd how the state can change. Your program will need the classes defined in , , , and . n use a guide, except The next exercise has a picture of a blackjack game that you ca that the version for this exercise does not allow betting. (solution) n the “Hit”, “Stand”, and In the Blackjack game from Exercise 6.10, the user can click o 11. “NewGame” buttons even when it doesn’t make sense to do so. It would be better if the buttons were disabled at the appropriate times. The “New Gam e” button should be dis- abled when there is a game in progress. The “Hit” and “Stand” b uttons should be disabled when there is not a game in progress. The instance variable gameInProgress tells whether or not a game is in progress, so you just have to make sure that t he buttons are properly enabled and disabled whenever this variable changes value. I strongly advise writing a sub- routine that can be called whenever it is necessary to set the value of the gameInProgress variable. Then the subroutine can take responsibility for e nabling and disabling the but- tons. Recall that if bttn is a variable of type JButton , then bttn.setEnabled(false) disables the button and bttn.setEnabled(true) enables the button.

342 Exercises 329 for the user to place bets As a second (and more difficult) improvement, make it possible $100. Add a JTextField on the Blackjack game. When the program starts, give the user to the strip of controls along the bottom of the panel. The use r can enter the bet in this JTextField . When the game begins, check the amount of the bet. You should do this when the game begins, not when it ends, because several errors can occur: The contents of the JTextField might not be a legal number, the bet that the user places might be more money than the user has, or the bet might be < = 0. You should detect these errors and show an error message instead of starting the game. The user’s bet sh ould be an integral number of dollars. It would be a good idea to make the JTextField uneditable while the game is in progress. If is the JTextField , you can make it editable and uneditable by the user with betInput the commands betInput.setEditable(true) and betInput.setEditable(false) . In the paintComponent() method, you should include commands to display the amount of money that the user has left. should not start a new There is one other thing to think about: Ideally, the program game when it is first created. The user should have a chance to s et a bet amount before the game starts. So, in the constructor for the drawing surfa ce class, you should not call doNewGame() . You might want to display a message such as “Welcome to Black jack” before the first game starts. Here is a picture of my program:

343 Quiz 330 Quiz on Chapter 6 (answers) with “events.” Explain what 1. Programs written for a graphical user interface have to deal Give at least two different examples of events, and discuss event. is meant by the term how a program might respond to those events. 2. Explain carefully what the repaint() method does. Java has a standard class called JPanel . Discuss 3. ways in which JPanels can be used. two 4. paintComponent() method: Draw the picture that will be produced by the following public static void paintComponent(Graphics g) { super.paintComponent(g); for (int i=10; i <= 210; i = i + 50) for (int j = 10; j <= 210; j = j + 50) g.drawLine(i,10,j,60); } 5. Suppose you would like a panel that displays a green square in side a red circle, as illus- trated. Write a paintComponent() method for the panel class that will draw the image. 6. Java has a standard class called . What is the purpose of this class? What MouseEvent MouseEvent does an object of type do? One of the main classes in Swing is the JComponent class. What is meant by a component? 7. What are some examples? 8. What is the function of a LayoutManager in Java? 9. Consider the illustration of nested panels from the beginni ng of Section 6.6 . What type of layout manager is being used for each of the three panels in that picture? 10. Explain how Timers are used to do animation. 11. What is a JCheckBox and how is it used? 12. How is the preferred size of a component set, and how is it used?

344 Chapter 7 Arrays and ArrayLists omputers get a lot of their power from working with . A data C data structures ect is a data structure, but this structure is an organized collection of related data. An obj type of data structure—consisting of a fairly small number o f named instance variables—is just the beginning. In many cases, programmers build complicate d data structures by hand, by Chapter 9 . But linking objects together. We’ll look at these custom-built data structures in basic that it is built into every there is one type of data structure that is so important and so programming language: the array. Section 3.8 and Subsection 5.1.4 . We continue the You have already encountered arrays in study of arrays in this chapter, including some new details o f their use and some additional array-processing techniques. In particular, we will look a t the important topic of algorithms for searching and sorting an array. s created. But in many cases, An array has a fixed size that can’t be changed after the array i it is useful to have a data structure that can grow and shrink a s necessary. In this chapter, we , that represents such a data structure. ArrayList will look at a standard class, 7.1 Array Details A rray basics have been discussed in previous chapters, but there are still details of Java syntax to be filled in, and there is a lot more to say about using arrays. This section looks at some of the syntactic details, with more information about a rray processing to come in the rest of the chapter. To briefly review some of the basics. . . . An array is a numbered sequence of elements , and each element acts like a separate variable. All of the elemen ts are of the same type, which is called the base type of the array. The array as a whole also has a type. If the base ty pe is btype , then the array is of type . Each element in the array has an index , which is just btype[ ] ray is , then the i-th element of the its numerical position in the sequence of elements. If the ar A A[i] . The number of elements in an array is called its length array is A . The length of an array is A.length . The length of an array can’t be changed after the array is cre ated. The elements of the array A are A[0] , A[1] , . . . , A[A.length-1] . An attempt to refer to an array element with an index outside the range from zero to causes an ArrayIndexOutOfBoundsException . A.length-1 Arrays in Java are objects, so an array variable can only refe r to an array, it does not contain the array. The value of an array variable can also be null . In that case, it does not refer to any array, and an attempt to refer to an array elem ent such as A[i] will cause a NullPointerException . Arrays are created using a special form of the new operator. For example, 331

345 CHAPTER 7. ARRAYS AND ARRAYLISTS 332 int[] A = new int[10]; creates a new array with base type A to refer to the int and length 10, and it sets the variable newly created array. 7.1.1 For-each Loops Arrays are often processed using loops. A for loop makes it easy to process each element for is an array of in an array from beginning to end. For example, if , then all the namelist Strings values in the list can be printed using for (int i = 0; i < namelist.length; i++) { System.out.println( namelist[i] ); } ive form of the This type of processing is so common that there is an alternat loop that for makes it easier to write. The alternative is called a . It is probably easiest to for-each loop l the values in an array of : start with an example. Here is a for-each loop for printing al Strings for ( String name : namelist ) { System.out.println( name ); } for (String name : namelist) The meaning of “ ” is “for each string, name, in the array, namelist, do the following”. The effect is that the variable name takes on each of the values in namelist in turn, and the body of the loop is executed for each of those v alues. Note that there is no array index in the loop. The loop control variable , name , represents one of the values in the array, not the index of one of the values. The for-each loop is meant specifically for processing all th e values in a data structure, and we will see in Chapter 10 for-each that it applies to other data structures besides arrays. The loop makes it possible to process the values without even kno wing the details of how the data is structured. In the case of arrays, it lets you avoid the com plications of using array indices. A for-each loop will perform the same operation for each valu e that is stored in an array. If itemArray BaseType[ ] , then a for-each loop for itemArray has the form: is an array of type for ( BaseType item : itemArray ) { . . // process the item . } As usual, the braces are optional if there is only one stateme nt inside the loop. In this loop, item is the loop control variable. It is declared as a variable of t BaseType , where BaseType ype is the base type of the array. (In a for-each loop, the loop con must be declared trol variable in the loop; it cannot be a variable that already exists outsi de the loop.) When this loop is executed, each value from the array is assigned to item in turn and the body of the loop is executed for each value. Thus, the above loop is exactly equi valent to: for ( int index = 0; index < itemArray.length; index++ ) { BaseType item; item = itemArray[index]; // Get one of the values from the arr ay . . // process the item . }

346 CHAPTER 7. ARRAYS AND ARRAYLISTS 333 A is an array of type , then we could print all the values from A with For example, if int[ ] the for-each loop: for ( int item : A ) System.out.println( item ); with: A and we could add up all the positive integers in n A int sum = 0; // This will be the sum of all the positive numbers i for ( int item : A ) { if (item > 0) sum = sum + item; } The for-each loop is not always appropriate. For example, th ere is no simple way to use it to process the items in just a part of an array, or to process the elements in reverse order. t to process all the values, in However, it does make the code a little simpler when you do wan order. since it eliminates any need to use array indices. It’s important to note that a for-each loop processes the values in the array, not the (where an element means the actual memory location that is pa rt of the array). For elements array of integers with 17’s: example, consider the following incorrect attempt to fill an int[] intList = new int[10]; for ( int item : intList ) { // INCORRECT! DOES NOT MODIFY THE ARRAY! item = 17; } The assignment statement item = 17 assigns the value 17 to the loop control variable, item . However, this has nothing to do with the array. When the body o f the loop is executed, the item item = 17 value from one of the elements of the array is copied into . The statement replaces that copied value but has no effect on the array eleme nt from which it was copied; the value in the array is not changed. The loop is equivalent to int[] intList = new int[10]; for ( int i = 0; i < intList.length; i++ ) { int item = intList[i]; item = 17; } which certainly does not change the value of any element in th e array. 7.1.2 Variable Arity Methods Before Java 5, every method in Java had a fixed arity. (The arity of a method is defined as the number of parameters in a call to the method.) In a fixed ari ty method, the number of parameters must be the same in every call to the method and mus t be the same as the number of formal parameters in the method’s definition. Java 5 intro variable arity methods . duced In a variable arity method, different calls to the method can h ave different numbers of parame- ters. For example, the formatted output method System.out.printf , which was introduced in Subsection 2.4.1 , is a variable arity method. The first parameter of System.out.printf must be a String , but it can have any number of additional parameters, of any t ypes. Calling a variable arity method is no different from calling a ny other sort of method, but writing one requires some new syntax. As an example, conside r a method that can compute

347 CHAPTER 7. ARRAYS AND ARRAYLISTS 334 double . The definition of such a method could the average of any number of values of type begin with: public static double average( double... numbers ) { Here, the after the type name, double , is what makes this a variable arity method. It ... indicates that any number of values of type double can be provided when the subroutine is , called, so that for example , average(0.375) , and average(1,4,9,16) average(3.14,2.17) average() are all legal calls to this method. Note that actual paramete rs of type int can even average . The integers will, as usual, be automatically converted to real numbers. be passed to ters that correspond to the When the method is called, the values of all the actual parame his array that is actually passed to variable arity parameter are placed into an array, and it is t T actually the method. That is, in the body of a method, a variable arity p arameter of type T[ ] looks like an ordinary parameter of type . The length of the array tells you how many actual parameters were provided in the method call. In the average example, the body of the numbers method would see an array named double[ ] . The number of actual parameters of type in the method call would be , and the values of the actual parameters would numbers.length numbers[0] be numbers[1] , and so on. A complete definition of the method would be: , public static double average( double... numbers ) { // Inside this method, numbers if of type double[]. double sum; // The sum of all the actual parameters. double average; // The average of all the actual parameters. sum = 0; for (int i = 0; i < numbers.length; i++) { sum = sum + numbers[i]; // Add one of the actual parameters to t he sum. } average = sum / numbers.length; return average; } By the way, it is possible to pass a single array to a variable a rity method, instead of a list salesData is a variable of type double[ ] of individual values. For example, suppose that . Then it would be legal to call , and this would compute the average of all the average(salesData) numbers in the array. The formal parameter list in the definition of a variable-ari ty method can include more than ... can only be applied to the very last formal parameter. one parameter, but the As an example, consider a method that can draw a polygon throu gh any number of points. The points are given as values of type Point , where an object of type Point has two instance variables, x y , of type int . In this case, the method has one ordinary parameter—the and ition to the variable arity graphics context that will be used to draw the polygon—in add parameter. Remember that inside the definition of the method , the parameter points becomes an array of Points : public static void drawPolygon(Graphics g, Point... point s) { if (points.length > 1) { // (Need at least 2 points to draw anyt hing.) for (int i = 0; i < points.length - 1; i++) { // Draw a line from i-th point to (i+1)-th point g.drawLine( points[i].x, points[i].y, points[i+1].x, po ints[i+1].y ); } // Now, draw a line back to the starting point. g.drawLine( points[points.length-1].x, points[points. length-1].y, points[0].x, points[0].y );

348 CHAPTER 7. ARRAYS AND ARRAYLISTS 335 } } When this method is called, the subroutine call statement mu st have one actual parameter of , which can be followed by any number of actual parameters of t Point . Graphics type ype For a final example, let’s look at a method that strings togeth er all of the values in a list of strings into a single, long string. This example uses a for-e ach loop to process the array: public static String concat( String... values ) { StringBuffer buffer; // Use a StringBuffer for more efficie nt concatenation. buffer = new StringBuffer(); // Start with an empty buffer. for ( String str : values ) { // A "for each" loop for processing the values. buffer.append(str); // Add string to the buffer. } return buffer.toString(); // return the contents of the buf fer } Given this method definition, would return the string “Hel- concat("Hello", "World") loWorld”, and would return an empty string. Since a variable arity method c an concat() concat(lines) lines is of also accept an array as actual parameter, we could also call where String[ ] . This would concatenate all the elements of the array into a s ingle string. type 7.1.3 Array Literals le with a list of values at the time We have seen that it is possible to initialize an array variab it is declared. For example, int[] squares = { 1, 4, 9, 16, 25, 36, 49 }; This initializes squares to refer to a newly created array that contains the seven valu es in the list A list initializer of this form can be used only in a declaration statement, to give an initial value to a newly declared array variable. It cannot be used in an assignment statement to here is another, similar notation for assign a value to a variable that already existed. However, t tion uses another form of the creating a new array that can be used in other places. The nota new operator to both create a new array object and fill it with valu es. (The rather odd syntax is similar to the syntax for anonymous inner classes, which w ere discussed in Subsection 5.8.3 .) As an example, to assign a new value to an array variable, cubes , of type int[ ] , you could use: cubes = new int[] { 1, 8, 27, 64, 125, 216, 343 }; This is an assignment statement rather than a declaration, s o the array initializer syntax, without “ new int[] ,” would not be legal here. The general syntax for this form of the new operator is new base-type 〉 [ ] { 〈 〈 〉 } list-of-values This is actually an expression whose value is a reference to a newly created array object. In this sense, it is an “array literal,” since it is something that yo u can type in a program to represent a value. This means that it can be used in any context where an o bject of type 〈 base-type 〉 [] is legal. For example, you could pass the newly created array as an actual parameter to a subroutine. Consider the following utility method for crea ting a menu from an array of strings:

349 CHAPTER 7. ARRAYS AND ARRAYLISTS 336 /** * Creates a JMenu. The names for the JMenuItems in the menu are * given as an array of strings. * @param menuName the name for the JMenu that is to be created. e menu. * @param handler the listener that will respond to items in th em. * This ActionListener is added as a listener for each JMenuIt * @param itemNames an array holding the text that appears in e ach * JMenuItem. If a null value appears in the array, the corresp onding * item in the menu will be a separator rather than a JMenuItem. * @return the menu that has been created and filled with items . */ public static JMenu createMenu( mes ) { String menuName, ActionListener handler, String[] itemNa JMenu menu = new JMenu(menuName); for ( String itemName : itemNames ) { if ( itemName == null ) { menu.addSeparator(); } else { JMenuItem item = new JMenuItem(itemName); item.addActionListener(handler); menu.add(item); } } return menu; } The third parameter in a call to createMenu is an array of strings. The array that is passed as an actual parameter could be created in place, using the new operator. For example, assuming listener ActionListener , we can use the following statement to create an entire that is of type File menu: JMenu fileMenu = createMenu( "File", listener { "New", "Open", "Close", null, "Quit" } ); new String[] This should convince you that being able to create and use an a rray “in place” in this way can be very convenient, in the same way that anonymous inner clas ses are convenient. By the way, it is perfectly legal to use the “ ” syntax instead of new BaseType[] { ... } the array initializer syntax in the declaration of an array v ariable. For example, instead of saying: int[] primes = { 2, 3, 5, 7, 11, 13, 17, 19 }; you can say, equivalently, int[] primes = new int[] { 2, 3, 5, 7, 11, 17, 19 }; In fact, rather than use a special notation that works only in the context of declaration state- ments, I sometimes prefer to use the second form. ∗ ∗ ∗ One final note: For historical reasons, an array declaration such as int[] list; can also be written as

350 CHAPTER 7. ARRAYS AND ARRAYLISTS 337 int list[]; which is a syntax used in the languages C and C++. However, thi s alternative syntax does not really make much sense in the context of Java, and it is probab ly best avoided. After all, the intent is to declare a variable of a certain type, and the name int[ ] ”. It makes of that type is “ type-name 〉 〈 variable-name 〉 sense to follow the “ 〈 ;” syntax for such declarations. 7.2 Array Processing M ost examples of array processing that we have looked at have actually been fairly straightforward: processing the elements of the array in or der from beginning to end, or random access to an arbitrary element of the array. In this section a nd later in the chapter, you’ll see some of the more interesting things that you can do with array s. 7.2.1 Some Processing Examples voiding array indices outside the To begin, here’s an example to remind you to be careful about a lines is an array of type String[] , and we want to know whether legal range. Suppose that lines contains any duplicate elements in consecutive locations. That is, we want to know lines[i].equals(lines[i+1]) whether i . Here is a failed attempt to check for any index that condition: boolean dupp = false; // Assume there are no duplicates for ( int i = 0; i < list.length; i++ ) { if ( lines[i].equals(lines[i+1]) ) { // THERE IS AN ERROR HERE! dupp = true; // we have found a duplicate! break; } } This loop looks like many others that we have written, so what’s th e problem? The error for i i equal to lines.length-1 . In that case, occurs when takes on its final value in the loop, is equal to lines.length . But the last element in the array has index i+1 , lines.length-1 so lines.length is not a legal index. This means that the reference to lines[i+1] causes an ArrayIndexOutOfBoundsException. This is easy to fix; we jus t need to stop the loop before i+1 goes out of range: boolean dupp = false; // Assume there are no duplicates for ( int i = 0; i < ; i++ ) { list.length - 1 if ( lines[i].equals(lines[i+1]) ) { dupp = true; // we have found a duplicate! break; } } This type of error can be even more insidious when working wit h partially full arrays (see Subsection 3.8.4 ), where usually only part of the array is in use, and a counter is used to keep track of how many spaces in the array are used. With a partiall y full array, the problem is not looking beyond the end of the array, but looking beyond the part of the array that is in use . When your program tries to look beyond the end of an array, at least the program will crash to let you know that there is a problem. With a partially full array, the problem can go undetected.

351 CHAPTER 7. ARRAYS AND ARRAYLISTS 338 ∗ ∗ ∗ For the next example, let’s continue with partially full arr ays. We have seen how to add an item to a partially full array, but suppose that we also wan t to be able to remove items? Suppose that you write a game program, and that players can jo in the game and leave the game as it progresses. As a good object-oriented programmer, you probably have a class named Player to represent the individual players in the game. A list of all players who are currently in the , of type Player[ ] game could be stored in an array, playerList . Since the number of players can d you will need a variable, playerCt , change, you will follow the partially full array pattern, an to record the number of players currently in the game. Assumi ng that there will never be more than 10 players in the game, you could declare the variables a s: Player[] playerList = new Player[10]; // Up to 10 players. int playerCt = 0; // At the start, there are no players. playerCt After some players have joined the game, will be greater than 0, and n the array elements the player objects representing the players will be stored i , playerList[1] , . . . , playerList[playerCt-1] . Note that the array element playerList[0] is not in use. The procedure for adding a new player, playerList[playerCt] , to newPlayer the game is simple: playerList[playerCt] = newPlayer; // Put new player in next // available spot. playerCt++; // And increment playerCt to count the new playe r. But deleting a player from the game is a little harder, since y ou don’t want to leave a “hole” in the array where the deleted player used to be. Suppose you w ant to delete the player at index k in playerList . The number of players goes down by one, so one fewer space is u sed in the array. If you are not worried about keeping the players in any particular order, then one tion in the array into position way to do this is to move the player from the last occupied posi playerCt : k and then to decrement the value of playerList[k] = playerList[playerCt - 1]; playerCt--; The player previously in position k is no longer in the array, so we have deleted that player from the list. The player previously in position is now in the array twice. But playerCt - 1 it’s only in the occupied or valid part of the array once, sinc e playerCt has decreased by one. Remember that every element of the array has to hold some valu e, but only the values in positions 0 through playerCt - 1 will be looked at or processed in any way. (By the way, you should think about what happens if the player that is being de leted is in the last position in the list. The code does still work in this case. What exactly h appens?) Suppose that when deleting the player in position k , you’d like to keep the remaining players in the same order. (Maybe because they take turns in the order in which they are stored in the array.) To do this, all the players in positions k+1 and above must move down one position in the array. Player k+1 replaces player k , who is out of the game. Player k+2 fills the spot left open when player k+1 is moved. And so on. The code for this is for (int i = k+1; i < playerCt; i++) { playerList[i-1] = playerList[i]; } playerCt--;

352 CHAPTER 7. ARRAYS AND ARRAYLISTS 339 Here is an illustration of the two ways of deleting an item fro m a partially full array. Here, player “C” is being deleted: playerList playerList A A ] playerCt ] playerCt _ _ B B F † C ‡ Alternatively, all o delete " rom f d b ` ‡ D the items that E the array g hjklm obp the b jjr| v fr  E drops f s p r u or q E ˆ array can move oves k pzm vw q { ˆ F up one sp k‚m € into the space ƒ b„ m ~ k‚ hj om m |z € m pr w m }~ b om E replaces ƒ„ ^ ace that ` zm ^ h ~ ^ ^ hjk‚ m ~ … € { om used to h w j r { pzm ^ ^ is no longer in u € ~m ∗ ∗ ∗ This leaves open the question of what happens when a partiall y full array becomes full, but you still want to add more items to it? We can’t change the size of the array—but we can make e new array. But what does it a new, bigger array and copy the data from the old array into th mean to copy an array in the first place? Suppose that and B are array variables, with the same base type, and that A already refers A B to refer to a copy of A . The first thing to note is that the to an array. Suppose that we want assignment statement B = A; not A . Arrays are objects, and an array variable can only hold a poi nter does make a copy of to an array. The assignment statement copies the pointer fro A into B , and the result is that m A and B now point to the same array. For example, A[0] and B[0] are just different names for exactly the same array element. To make B A , we need to make an entirely refer to a copy of A are of type B . Let’s say that A and B new array and copy all the items from double[ ] . into A , we can say Then to make a copy of double B; B = new double[A.length]; // Make a new array with the same len gth as A. for ( int i = 0; i < A.length; i++ ) { B[i] = A[i]; } To solve the problem of adding to a partially full array that h as become full, we just need to make a new array that is bigger than the existing array. The usual choice is to make a new array twice as big as the old. We need to meet one more requi rement: At the end, the variable that referred to the old array must now point to the n ew array. That variable is what gives us access to the data, and at the end that data is in the ne w array. Fortunately, a simple assignment statement will make the variable point to the cor rect array. Let’s suppose that we are using playerList and playerCt to store the players in a game, as in the example above, and we want to add newPlayer to the game. Here is how we can do that even if the playerList array is full: if ( playerCt == playerList.length ) { // The number of players is already equal to the size of the arr ay. // The array is full. Make a new array that has more space. Player[] temp; // A variable to point to the new array.

353 CHAPTER 7. ARRAYS AND ARRAYLISTS 340 he old array. temp = new Player[ 2*playerList.length ]; // Twice as big as t for ( int i = 0; i < playerList.length; i++ ) { temp[i] = playerList[i]; // Copy item from old array into new array. } r array. playerList = temp; // playerList now points to the new, bigge } // At this point, we know that there is room in the array for new Player. playerList[playerCt] = newPlayer; playerCt++; After the new array has been created, there is no longer any va riable that points to the old array, so it will be garbage collected. 7.2.2 Some Standard Array Methods Copying an array seems like such a common method that you migh t expect Java to have a built- in method already defined to do it. In fact, Java comes with sev eral standard array-processing static methods in a class named methods. The methods are defined as , which is in the Arrays package . For example, for any array, list , java.util Arrays.copyOf( list, lengthOfCopy ) is a function that returns a new array whose length is given by , containing items lengthOfCopy list . If lengthOfCopy copied from list.length , then extra spaces in the new is greater than array will have their default value (zero for numeric arrays , null for object arrays, and so on). If lengthOfCopy is less than or equal to list.length , then only as many items are copied from list A is any array, then as will fit in the new array. So if B = Arrays.copyOf( A, A.length ); sets to refer to an exact copy of A , and B playerList = Arrays.copyOf( playerList, 2*playerList.le ngth ); ially full array with just one could be used to double the amount of space available in a part line of code. We can also use to decrease the size of a partially full array. We Arrays.copyOf might want to do that to avoid having a lot of excess, unused sp aces. To implement this idea, the code for deleting player number k from the list of players might become playerList[k] = playerList[playerCt-1]; playerCt--; if ( playerCt < playerList.length/2 ) { // More than half the spaces are empty. Cut the array size in ha lf. th/2 ); playerList = Arrays.copyOf( playerList, playerList.leng } I should mention that class Arrays copyOf methods, one for actually contains a bunch of each of the primitive types and one for objects. I should also note that when an array of objects is copied, it is only pointers to objects that are copied into the new array. The contents of the objects are not copied. This is the usual rule for assignment of pointers. ∗ ∗ ∗ The Arrays class contains other useful methods. I’ll mention a few of th em. As with Arrays.copyOf , there are actually multiple versions of all of these method s, for different array types.

354 CHAPTER 7. ARRAYS AND ARRAYLISTS 341 Arrays.fill( array, value ) — Fill an entire array with a specified value. The type • must be compatible with the base type of the value array of . For example, assuming double[ ] is an array of type Arrays.fill(numlist,17) will set every numlist that , then to have the value 17. element of numlist — Fills part of the • with Arrays.fill( array, fromIndex, toIndex, value ) array , starting at index number and ending with index number toIndex-1 . value fromIndex toIndex Note that itself is not included. • — A function that returns a String containing all the values Arrays.toString( array ) array The values in from , separated by commas and enclosed between square brackets. the array are converted into strings in the same way they woul d be if they were printed out. Arrays.sort( array ) — Sorts the entire array. To sort an array means to rearrange • his method works for arrays the values in the array so that they are in increasing order. T String and arrays of primitive type values (except for boolean , which would be kind of of aningful to compare any two silly). But it does not work for all arrays, since it must be me values in the array, to see which is “smaller.” We will discus s array-sorting algorithms in Section 7.4 . • Arrays.sort( array, fromIndex, toIndex ) — Sorts just the elements from array[fromIndex] up to array[toIndex-1] Arrays.binarySearch( array, value ) — Searches for in the array . The array • value int . If the must already be sorted into increasing order. This is a funct ion that returns an value is found in the array, the return value is the index of an element that contains that ue is -1. We will discuss the value. If the value does not occur in the array, the return val binary search algorithm in Section 7.4 . 7.2.3 RandomStrings Revisited One of the examples in Subsection 6.3.2 was a GUI program that shows multiple copies of a r clicks the program window, the message in random positions, colors, and fonts. When the use positions, colors, and fonts are changed to new random value s. Like several other examples from that chapter, the program had a flaw: It didn’t have any wa y of storing the data that it would need to redraw itself. Arrays provide us with one possi ble solution to this problem. We can write a new version of RandomStrings that uses an array to store the position, font, and tion is used to draw the strings, so color of each string. When the panel is painted, this informa that the panel will paint itself correctly whenever it has to be redrawn. When the user clicks, the array is filled with new random values and the panel is repa inted using the new data. So, the only time that the picture will change is in response to a m ouse click. The new version of the program is . a named constant, In the program, the number of copies of the message is given by COUNT . One way to store the position, color, and font of MESSAGE COUNT strings would MESSAGE be to use four arrays: int[] x = new int[MESSAGE COUNT]; int[] y = new int[MESSAGE COUNT]; Color[] color = new Color[MESSAGE COUNT]; Font[] font = new Font[MESSAGE COUNT];

355 CHAPTER 7. ARRAYS AND ARRAYLISTS 342 paintComponent() method, the -th These arrays would be filled with random values. In the i . Its color would be given by (x[i],y[i]) copy of the string would be drawn at the point . And it would be drawn in the font font[i] . This would be accomplished by the color[i] paintComponent() method public void paintComponent(Graphics g) { super.paintComponent(); // (Fill with background color.) for (int i = 0; i < MESSAGE COUNT; i++) { g.setColor( color[i] ); g.setFont( font[i] ); g.drawString( message, x[i], y[i] ); } } parallel arrays This approach is said to use . The data for a given copy of the message is s laid out in parallel columns— spread out across several arrays. If you think of the arrays a x in the first column, array y in the second, array color in the third, and array font array i -th string can be found along the i -th row. There is in the fourth—then the data for the nothing wrong with using parallel arrays in this simple exam ple, but it does go against the object-oriented philosophy of keeping related data in one o bject. If we follow this rule, then we don’t have to imagine the relationship among the data, because all the data for one copy of the message is physically in one place. So, when I wrote the pr ogram, I made a simple class to ge: represent all the data that is needed for one copy of the messa /** * An object of this type holds the position, color, and font * of one copy of the string. */ private static class StringData { int x, y; // The coordinates of the left end of baseline of stri ng. Color color; // The color in which the string is drawn. Font font; // The font that is used to draw the string. } To store the data for multiple copies of the message, I use an a rray of type StringData[ ] . The array is declared as an instance variable, with the name stringData : StringData[] stringData; Of course, the value of stringData is null until an actual array is created and assigned to it. The array has to be created and filled with data. Furthermo re, each element of the array StringData which has to be created before it can be used. The following is an object of type ata: subroutine is used to create the array and fill it with random d private void createStringData() { int width = getWidth(); int height = getHeight(); COUNT]; stringData = new StringData[MESSAGE for (int i = 0; i < MESSAGE COUNT; i++) { // Create an object to represent the data for string number i, // and fill it with random values. stringData[i] = new StringData(); int fontIndex = (int)(Math.random() * 5); stringData[i].font = fonts[fontIndex]; // one of 5 fonts, s elected at random float hue = (float)Math.random();

356 CHAPTER 7. ARRAYS AND ARRAYLISTS 343 ); // random color stringData[i].color = Color.getHSBColor(hue, 1.0F, 1.0F ; // random x-coord stringData[i].x = -50 + (int)(Math.random()*(width+40)) stringData[i].y = (int)(Math.random()*(height+20)); // random y-coord } } This method is called before the panel is painted for the first time. It is also called when the user clicks the panel with the mouse, so that a mouse click will cause new random data to be created. Those are the only times when the picture can ch ange. For example, resizing paintComponent() to be called, but since the data hasn’t changed, the window will cause paintComponent() will just redraw the same picture. Here is the code from paintComponent() that draws all the strings, using the data from the array: COUNT; i++) { for (int i = 0; i < MESSAGE g.setColor( color ); stringData[i]. stringData[i]. g.setFont( font ); g.drawString( message, stringData[i]. x, stringData[i]. y ); } Note that I could also have used a for-each loop here, which mi ght be easier to understand: for ( StringData data : stringData ) { g.setColor( data.color ); g.setFont( data.font ); g.drawString( message, data.x, data.y ); } In this loop, the loop control variable, data , holds a copy of one of the values from the array. That value is a reference to an object of type StringData , which has instance variables named color , , x , and y . Once again, the use of a for-each loop has eliminated the nee d to work font with array indices. ∗ ∗ ∗ e font for a given copy of the RandomStringsWithArray uses one other array of objects. Th n the original version, there message is chosen at random from a set of five possible fonts. I were five variables of type to represent the fonts. The variables were named font1 , font2 , Font font3 , font4 , and font5 . To select one of these fonts at random, a switch statement can be used: Font randomFont; // One of the 5 fonts, chosen at random. int rand; // A random integer in the range 0 to 4. fontNum = (int)(Math.random() * 5); switch (fontNum) { case 0: randomFont = font1; break; case 1: randomFont = font2; break; case 2: randomFont = font3; break; case 3: randomFont = font4;

357 CHAPTER 7. ARRAYS AND ARRAYLISTS 344 break; case 4: randomFont = font5; break; } In the new version of the program, the five fonts are stored in a fonts . n array, which is named This array is declared as an instance variable of type Font[ ] Font[] fonts; The array is created in the constructor, and each element of t he array is set to refer to a new object: Font . fonts = new Font[5]; // Create the array to hold the five fonts fonts[0] = new Font("Serif", Font.BOLD, 14); fonts[1] = new Font("SansSerif", Font.BOLD + Font.ITALIC, 24); fonts[2] = new Font("Monospaced", Font.PLAIN, 20); fonts[3] = new Font("Dialog", Font.PLAIN, 30); fonts[4] = new Font("Serif", Font.ITALIC, 36); This makes it much easier to select one of the fonts at random. It can be done with the statements Font randomFont; // One of the 5 fonts, chosen at random. int fontIndex; // A random number in the range 0 to 4. fontIndex = (int)(Math.random() * 5); randomFont = fonts[ fontIndex ]; The switch statement has been replaced by a single line of code. In fact, the preceding four lines can be replaced by the single line: Font randomFont = fonts[ (int)(Math.random() * 5) ]; xample uses the random access This is a very typical application of arrays. Note that this e directly to the array element property of arrays: We can pick an array index at random and go at that index. ften stored as numbers 1, 2, Here is another example of the same sort of thing. Months are o slated into the names January, 3, . . . , 12. Sometimes, however, these numbers have to be tran February, . . . , December. The translation can be done very ea sily with an array. The array can be declared and initialized as static String[] monthName = { "January", "February", "Marc h", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; If mnth is a variable that holds one of the integers 1 through 12, then monthName[mnth-1] is the name of the corresponding month. We need the “ -1 ” because months are numbered starting from 1, while array elements are numbered starting from 0. Si mple array indexing does the translation for us!

358 CHAPTER 7. ARRAYS AND ARRAYLISTS 345 7.2.4 Dynamic Arrays Earlier, we discussed how a partially full array can be used t o store a list of players in a game, allowing the list to grow and shrink over the course of the gam e. The list is “dynamic” in the sense that its size changes while the program is running. Dyn amic lists are very common, and we might think about trying to write a class to represent the c oncept. By writing a class, we can avoid having to repeat the same code every time we want to use a similar data structure. We change. Think about operations want something that is like an array, except that its size can that we might want to perform on a dynamic array. Some essenti al and useful operations would include • add an item to the end of the array • remove the item at a specified position in the array get the value of one of the elements in the array • set the value of one of the elements in the array • get the number of items currently in the array • When we design our class, these operations will become insta nce methods in that class. The items in the dynamic array will actually be stored in a normal array, using the partially full array pattern. Using what we know, the class is not difficult to write. We do have to decide what to do when an attempt is made to access an array element th at doesn’t exist. It seems natural to throw an index-out-of-bounds exception in that c ase. Let’s suppose that the items int in the array will be of type . import java.util.Arrays; /** * Represents a list of int values that can grow and shrink. */ public class DynamicArrayOfInt { ding the ints private int[] items = new int[8]; // partially full array hol private int itemCt; /** * Return the item at a given index in the array. * Throws ArrayIndexOutOfBoundsException if the index is no t valid. */ public int get( int index ) { if ( index < 0 || index >= itemCt ) throw new ArrayIndexOutOfBoundsException("Illegal inde x, " + index); return items[index]; } /** * Set the value of the array element at a given index. * Throws ArrayIndexOutOfBoundsException if the index is no t valid. */ public void set( int index, int item ) { if ( index < 0 || index >= itemCt ) throw new ArrayIndexOutOfBoundsException("Illegal inde x, " + index); items[index] = item; }

359 CHAPTER 7. ARRAYS AND ARRAYLISTS 346 /** * Returns the number of items currently in the array. */ public int size() { return itemCt; } /** * Adds a new item to the end of the array. The size increases by o ne. */ public void add(int item) { if (itemCt == items.length) items = Arrays.copyOf( items, 2*items.length ); items[itemCt] = item; itemCt++; } /** * Removes the item at a given index in the array. The size of the array d up one * decreases by one. Items following the removed item are move * space in the array. * Throws ArrayIndexOutOfBoundsException if the index is no t valid. */ public void remove(int index) { if ( index < 0 || index >= itemCt ) throw new ArrayIndexOutOfBoundsException("Illegal inde x, " + index); for (int j = index+1; j < itemCt; j++) items[j-1] = items[j]; itemCt--; } } // end class DynamicArrayOfInt Everything here should be clear, except possibly why the ori ginal size of the items array is 8. In fact, the number 8 is arbitrary and has no effect on the functio nality of the class. Any positive integer would work, but it doesn’t make sense for the array to start off very big. The array will grow as needed if the number of items turns out to be large. used a partially full array of int to print a list of The example ut. In that case, an ordinary input numbers in the reverse of the order in which they are inp un of the program, the size array of length 100 was used to hold the numbers. In any given r esulting in an exception. The of the array could be much too large, or it could be too small, r will adapt itself to any number program can now be written using a DynamicArrayOfInt, which of inputs. For the program, see . It’s a silly program, but the principle holds in any application where the amount of data c annot be predicted in advance: The size of a dynamic data structure can adapt itself to any am ount of data. This is a nice example, but there is a real problem with it. Sup pose that we want to have a dynamic array of . We can’t use a DynamicArrayOfInt object to hold strings, so it looks String like we need to write a whole new class, DynamicArrayOfString . If we want a dynamic array to store players in a game, we would need a class DynamicArrayOfPlayer . And so on. It looks like we have to write a dynamic array class for every possible type of data! That can’t be right! In fact, Java has a solution to this problem, a standard class th at implements dynamic arrays and can work with any type of data. The class is called ArrayList , and we’ll see how it works in the next section.

360 CHAPTER 7. ARRAYS AND ARRAYLISTS 347 7.3 ArrayList Subsection 7.2.4 , we can easily encode the dynamic array pattern A s we have just seen in into a class, but it looks like we need a different class for eac h data type. In fact, Java has a e to avoid the multitude of classes, feature called “parameterized types” that makes it possibl and Java has a single class named that implements the dynamic array pattern for all ArrayList data types. 7.3.1 ArrayList and Parameterized Types String Java has a standard type that represents dynamic arrays of Strings . Similarly, ArrayList < > < there is a type > that can be used to represent dynamic arrays of JButtons . ArrayList JButton Player ArrayList < Player > is a class representing players in a game, then the type And if can be Players . used to represent a dynamic array of It might look like we still have a multitude of classes here, b ut in fact there is only one class, the class, defined in the package java.util . But ArrayList is a parameterized type . ArrayList he single class , we get A parameterized type can take a type parameter, so that from t ArrayList ArrayList < String > , ArrayList < JButton > , and in fact ArrayList a multitude of types including T > < for any object type . The type parameter T must be an object type such as a class name or T an interface name. It cannot be a primitive type. This means t hat, unfortunately, you can not have an ArrayList of int or an ArrayList of char . Consider the type ArrayList < String > . As a type, it can be used to declare variables, such as ArrayList namelist; It can also be used as the type of a formal parameter in a subrou tine definition, or as the return new operator to create objects: type of a subroutine. It can be used with the namelist = new ArrayList(); ArrayList String > and represents a dynamic list of The object created in this way is of type < for adding a String to the list, strings. It has instance methods such as namelist.add(str) for getting the string at index i , and namelist.size() namelist.get(i) for getting the number of items currently in the list. ArrayList Player is a class representing players in a But we can also use with other types. If game, we can create a list of players with ArrayList playerList = new ArrayList(); plr Then to add a player, playerList.add(plr) . And we , to the game, we just have to say can remove player number k with playerList.remove(k) . When you use a type such as ArrayList < T > , the compiler will ensure that only objects of type T of type T will be can be added to the list. An attempt to add an object that is not te that objects belonging to a syntax error, and the program will not compile. However, no T can be added to the list, since objects belonging to a subclas s of T are still a subclass of considered to be of type T . Thus, for example, a variable of type ArrayList < JComponent > can be used to hold objects of type , JPanel , JTextField , or any other subclass of JComponent . JButton (Of course, this is the same way arrays work: An object of type T[ ] can hold objects belonging to any subclass of T .) Similarly, if T is an interface, then any object that implements interface T can be added to the list.

361 CHAPTER 7. ARRAYS AND ARRAYLISTS 348 ArrayList < > has all of the instance methods that you would expect in An object of type T list a dynamic array implementation. Here are some of the most use is a ful. Suppose that T . Then we have: variable of type > ArrayList < • list.size() — This function returns the current size of the list, that is, the number of ist are numbers in the range items currently in the list. The only valid positions in the l list.size()-1 . Note that the size can be zero. A call to the default construc tor 0 to new ArrayList() creates a list of size zero. — Adds an object onto the end of the list, increasing the size b y 1. The • list.add(obj) , can refer to an object of type null , or it can be obj . parameter, T — This function returns the value stored at position N in the list. The • list.get(N) T return type of this function is N must be an integer in the range 0 to list.size()-1 . . If is outside this range, an error of type IndexOutOfBoundsException occurs. Calling N A[N] A , except that you can’t use this function is similar to referring to for an array, list.get(N) on the left side of an assignment statement. list.set(N, obj) — Assigns the object, obj , to position N in the ArrayList , replacing the • N . The parameter obj must be of type T . The integer item previously stored at position must be in the range from to N list.size()-1 . A call to this func