Think Java: How to Think Like a Computer Scientist

291 Pages·2016·1.33 MB·English

Think Java
How to Think Like a Computer Scientist
Version 6.1.3

Think Java
How to Think Like a Computer Scientist
Version 6.1.3
Allen B. Downey and Chris Mayfield
Green Tea Press
Needham, Massachusetts
Copyright ' 2016 Allen B. Downey and Chris Mayfield.
Green Tea Press
9 Washburn Ave
Needham, MA 02492
Permission is granted to copy, distribute, and/or modify this work under
the terms of the Creative Commons Attribution-NonCommercial-ShareAlike
3.0 Unported License, which is available at http://creativecommons.org/
licenses/by-nc-sa/3.0/.
The original form of this book is LATEX source code. Compiling this code has
theeffect ofgeneratinga device-independent representation ofthe book, which
can be converted to other formats and printed.
The LATEX source for this book is available from http://thinkjava.org.
Contents
Preface xiii
1 The way of the program 1
1.1 What is programming? . . . . . . . . . . . . . . . . . . . . . 1
1.2 What is computer science? . . . . . . . . . . . . . . . . . . . 2
1.3 Programming languages . . . . . . . . . . . . . . . . . . . . 3
1.4 The hello world program . . . . . . . . . . . . . . . . . . . . 4
1.5 Displaying strings . . . . . . . . . . . . . . . . . . . . . . . . 6
1.6 Escape sequences . . . . . . . . . . . . . . . . . . . . . . . . 7
1.7 Formatting code . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.8 Debugging code . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.9 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.10 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2 Variables and operators 15
2.1 Declaring variables . . . . . . . . . . . . . . . . . . . . . . . 15
2.2 Assignment . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3 State diagrams . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.4 Printing variables . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5 Arithmetic operators . . . . . . . . . . . . . . . . . . . . . . 19
vi CONTENTS
2.6 Floating-point numbers . . . . . . . . . . . . . . . . . . . . . 21
2.7 Rounding errors . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.8 Operators for strings . . . . . . . . . . . . . . . . . . . . . . 23
2.9 Composition . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.10 Types of errors . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.11 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3 Input and output 33
3.1 The System class . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 The Scanner class . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3 Program structure . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4 Inches to centimeters . . . . . . . . . . . . . . . . . . . . . . 37
3.5 Literals and constants . . . . . . . . . . . . . . . . . . . . . . 38
3.6 Formatting output . . . . . . . . . . . . . . . . . . . . . . . 38
3.7 Centimeters to inches . . . . . . . . . . . . . . . . . . . . . . 40
3.8 Modulus operator . . . . . . . . . . . . . . . . . . . . . . . . 41
3.9 Putting it all together . . . . . . . . . . . . . . . . . . . . . . 41
3.10 The Scanner bug . . . . . . . . . . . . . . . . . . . . . . . . 43
3.11 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4 Void methods 49
4.1 Math methods . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2 Composition revisited . . . . . . . . . . . . . . . . . . . . . . 50
4.3 Adding new methods . . . . . . . . . . . . . . . . . . . . . . 51
4.4 Flow of execution . . . . . . . . . . . . . . . . . . . . . . . . 54
CONTENTS vii
4.5 Parameters and arguments . . . . . . . . . . . . . . . . . . . 55
4.6 Multiple parameters . . . . . . . . . . . . . . . . . . . . . . . 56
4.7 Stack diagrams . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.8 Reading documentation . . . . . . . . . . . . . . . . . . . . . 59
4.9 Writing documentation . . . . . . . . . . . . . . . . . . . . . 61
4.10 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5 Conditionals and logic 67
5.1 Relational operators . . . . . . . . . . . . . . . . . . . . . . . 67
5.2 Logical operators . . . . . . . . . . . . . . . . . . . . . . . . 68
5.3 Conditional statements . . . . . . . . . . . . . . . . . . . . . 69
5.4 Chaining and nesting . . . . . . . . . . . . . . . . . . . . . . 71
5.5 Flag variables . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.6 The return statement . . . . . . . . . . . . . . . . . . . . . . 72
5.7 Validating input . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.8 Recursive methods . . . . . . . . . . . . . . . . . . . . . . . 74
5.9 Recursive stack diagrams . . . . . . . . . . . . . . . . . . . . 76
5.10 Binary numbers . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.11 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
5.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
6 Value methods 85
6.1 Return values . . . . . . . . . . . . . . . . . . . . . . . . . . 85
6.2 Writing methods . . . . . . . . . . . . . . . . . . . . . . . . 88
6.3 Method composition . . . . . . . . . . . . . . . . . . . . . . 90
6.4 Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
viii CONTENTS
6.5 Boolean methods . . . . . . . . . . . . . . . . . . . . . . . . 93
6.6 Javadoc tags . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
6.7 More recursion . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.8 Leap of faith . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.9 One more example . . . . . . . . . . . . . . . . . . . . . . . 98
6.10 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
6.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7 Loops 105
7.1 The while statement . . . . . . . . . . . . . . . . . . . . . . 105
7.2 Generating tables . . . . . . . . . . . . . . . . . . . . . . . . 107
7.3 Encapsulation and generalization . . . . . . . . . . . . . . . 109
7.4 More generalization . . . . . . . . . . . . . . . . . . . . . . . 112
7.5 The for statement . . . . . . . . . . . . . . . . . . . . . . . . 114
7.6 The do-while loop . . . . . . . . . . . . . . . . . . . . . . . . 115
7.7 Break and continue . . . . . . . . . . . . . . . . . . . . . . . 116
7.8 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.9 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
8 Arrays 123
8.1 Creating arrays . . . . . . . . . . . . . . . . . . . . . . . . . 123
8.2 Accessing elements . . . . . . . . . . . . . . . . . . . . . . . 124
8.3 Displaying arrays . . . . . . . . . . . . . . . . . . . . . . . . 125
8.4 Copying arrays . . . . . . . . . . . . . . . . . . . . . . . . . 127
8.5 Array length . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.6 Array traversal . . . . . . . . . . . . . . . . . . . . . . . . . 128
8.7 Random numbers . . . . . . . . . . . . . . . . . . . . . . . . 129
CONTENTS ix
8.8 Traverse and count . . . . . . . . . . . . . . . . . . . . . . . 131
8.9 Building a histogram . . . . . . . . . . . . . . . . . . . . . . 131
8.10 The enhanced for loop . . . . . . . . . . . . . . . . . . . . . 133
8.11 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
8.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
9 Strings and things 139
9.1 Characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
9.2 Strings are immutable . . . . . . . . . . . . . . . . . . . . . 141
9.3 String traversal . . . . . . . . . . . . . . . . . . . . . . . . . 141
9.4 Substrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
9.5 The indexOf method . . . . . . . . . . . . . . . . . . . . . . 144
9.6 String comparison . . . . . . . . . . . . . . . . . . . . . . . . 144
9.7 String formatting . . . . . . . . . . . . . . . . . . . . . . . . 145
9.8 Wrapper classes . . . . . . . . . . . . . . . . . . . . . . . . . 146
9.9 Command-line arguments . . . . . . . . . . . . . . . . . . . . 147
9.10 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
9.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
10 Objects 155
10.1 Point objects . . . . . . . . . . . . . . . . . . . . . . . . . . 155
10.2 Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
10.3 Objects as parameters . . . . . . . . . . . . . . . . . . . . . 157
10.4 Objects as return types . . . . . . . . . . . . . . . . . . . . . 158
10.5 Mutable objects . . . . . . . . . . . . . . . . . . . . . . . . . 159
10.6 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160
10.7 The null keyword . . . . . . . . . . . . . . . . . . . . . . . . 161
x CONTENTS
10.8 Garbage collection . . . . . . . . . . . . . . . . . . . . . . . 162
10.9 Class diagrams . . . . . . . . . . . . . . . . . . . . . . . . . 162
10.10 Java library source . . . . . . . . . . . . . . . . . . . . . . . 163
10.11 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
10.12 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
11 Classes 171
11.1 The Time class . . . . . . . . . . . . . . . . . . . . . . . . . 172
11.2 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
11.3 More constructors . . . . . . . . . . . . . . . . . . . . . . . . 174
11.4 Getters and setters . . . . . . . . . . . . . . . . . . . . . . . 176
11.5 Displaying objects . . . . . . . . . . . . . . . . . . . . . . . . 178
11.6 The toString method . . . . . . . . . . . . . . . . . . . . . . 179
11.7 The equals method . . . . . . . . . . . . . . . . . . . . . . . 180
11.8 Adding times . . . . . . . . . . . . . . . . . . . . . . . . . . 181
11.9 Pure methods and modifiers . . . . . . . . . . . . . . . . . . 183
11.10 Vocabulary . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
11.11 Exercises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
12 Arrays of objects 189
12.1 Card objects . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
12.2 Card toString . . . . . . . . . . . . . . . . . . . . . . . . . . 191
12.3 Class variables . . . . . . . . . . . . . . . . . . . . . . . . . . 193
12.4 The compareTo method . . . . . . . . . . . . . . . . . . . . 194
12.5 Cards are immutable . . . . . . . . . . . . . . . . . . . . . . 195
12.6 Arrays of cards . . . . . . . . . . . . . . . . . . . . . . . . . 196
12.7 Sequential search . . . . . . . . . . . . . . . . . . . . . . . . 198