1) Programming Basics 1
a)
Java and the Java Virtual Machine 3
1.1 Computers and Their Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.1 The computer programs in your machine . . . . . . . . . . . . . . . . . . . . 3
1.1.2 Java Virtual Machines - JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.3 Code editing and code compiling . . . . . . . . . . . . . . . . . . . . . . . . . 6
b) Our First Programs 13
2.1 The First Program, “Hello, World!” . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.1 Method declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.2 Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.1.3 System.out.println and System.out.print . . . . . . . . . . . . . . . . . . 17
2.1.4 Spacing in the source code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.2 Commenting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.3 Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.4 Using Multiple Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
• println versus print revisited . . . . . . . . . . . . . . . . . . . . . . . . . . 23
• Printing multiple-line texts on the screen . . . . . . . . . . . . . . . . . . . . 25
2.4.3 Escaping characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.4.4 Printing shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
c) Using Data for Computation 39
3.1 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.1.1 Data and their taxonomy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.1.2 Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.1.3 Variable declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.1.4 Naming variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.1.5 Value assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.2 The primitive data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2.1 Quarterbacks program again . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3 Using Variables for Computation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3.1 Number arithmetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3.2 Formula evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.3.3 Our first calculation program . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.3.4 Mixing different number types . . . . . . . . . . . . . . . . . . . . . . . . . . 57
3.3.5 Computing the Body-Mass Index . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.3.6 Sum of integers from 1 to 100 `a la Gauss . . . . . . . . . . . . . . . . . . . . 61
3.3.7 Simplified expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
3.4 An Introduction to String Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.4.1 String objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
3.4.2 String additions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
3.4.3 Escaping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
3.4.4 Connection with other types . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4 Reading Keyboard Input 83
4.1 The Class Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.2 Reading input with a Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5 Decomposing Code into Components 99
5.1 Code Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.1.1 Printing rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.1.2 Quadrangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
5.1.3 Old MacDonald Had a Farm . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
5.1.4 The benefits of code decomposition . . . . . . . . . . . . . . . . . . . . . . . . 114
5.2 Using Multiple Program Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
6 P assing Values to and from Methods 123
6.1 Passing Values to Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
6.1.1 Methods that work with parameters . . . . . . . . . . . . . . . . . . . . . . . 123
6.1.2 Method overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
6.2 Receiving a Value from a Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
6.3 Class Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.3.1 Mathematical functions in Java . . . . . . . . . . . . . . . . . . . . . . . . . . 137
6.3.2 Application using Math methods . . . . . . . . . . . . . . . . . . . . . . . . . 146
2) Loops and Conditional Execution 157
7 F or-Loops 159
7.1 Repetitive Code Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
7.2 Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
7.2.1 Simple iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
7.2.2 Iteration with an auxiliary variable . . . . . . . . . . . . . . . . . . . . . . . . 173
7.3 Double For-Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
8 Using Conditions to Control the Flow 187
8.1 Condition and its evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
8.2 The If Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
8.2.1 If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
8.2.2 Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
8.2.3 Special conditional evaluation rules . . . . . . . . . . . . . . . . . . . . . . . . 209
8.3 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
8.3.1 Computing max and min in a series of numbers . . . . . . . . . . . . . . . . . 211
8.3.2 A betting game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
9 F ormatted Printing using printf 225
9.1 Formatted Printing of Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
9.2 Formatted Printing of Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
9.3 Formatted Printing of Floating Point Numbers . . . . . . . . . . . . . . . . . . . . . 229
10 String Methods for Text Processing 237
10.1 String Methods for Information Extraction . . . . . . . . . . . . . . . . . . . . . . . 237
10.2 String Methods for Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
10.3 String methods for Pattern Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
10.4 String methods for creating new String objects . . . . . . . . . . . . . . . . . . . . 246
10.5 Class StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
11 Branching Using Switch Statements 259
11.1 Switch Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
11.2 Switching on a Char or a String Value . . . . . . . . . . . . . . . . . . . . . . . . . . 266
12 While and Do-while Loops 277
12.1 The While Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
12.1.1 What is a while-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
12.1.2 Collect numbers until the total reaches a target . . . . . . . . . . . . . . . . . 279
12.1.3 Integer overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
12.1.4 Vending machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
12.1.5 The Collatz Conjecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
12.1.6 From decimal to binary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
12.2 Do-while statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
12.2.1 Do-while versus while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
12.2.2 Waiting for Godot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
12.2.3 Converting to binary, again . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
12.3 Terminating a Scanner of Keyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
12.4 Approximating the Square Root . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
II I Arrays 311
13 Arrays 313
13.1 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
13.1.1 What is an array? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
13.1.2 Counting the number of occurrences . . . . . . . . . . . . . . . . . . . . . . . 314
13.2 Offset Indexing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
13.2.1 Offset indexing to avoid wasteful use of array elements . . . . . . . . . . . . . 322
13.2.2 Offset indexing for BMI calculation . . . . . . . . . . . . . . . . . . . . . . . . 323
13.2.3 Character occurrence counting . . . . . . . . . . . . . . . . . . . . . . . . . . 325
13.2.4 Negative offset indexing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
13.3 Primality Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
13.4 Using Multiple Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
13.5 ArrayIndexOutOfBoundsException . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
14 Class Arrays, Resizing Arrays, and Arrays with Capacity 347
14.1 Class Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
14.2 Coordinated Array Modifications with Sustained Length . . . . . . . . . . . . . . . . 351
14.2.1 Reversing element order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
14.2.2 Cyclic shifting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
14.3 Modifications That Require Resizing . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
14.3.1 Insertion and deletion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
14.3.2 Merging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
14.4 args - the Argument Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
14.5 Searching in an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
14.5.1 Sequential search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
14.5.2 Sequential search in an array with elements in order . . . . . . . . . . . . . . 370
14.5.3 Binary search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
14.6 Arrays with Capacity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
15 Multidimensional Arrays 385
15.1 Two-dimensional Rectangular Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
15.1.1 Multi-dimensional arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
15.1.2 Summation of over subsequences . . . . . . . . . . . . . . . . . . . . . . . . . 386
15.2 Matrix multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
15.2.1 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
15.2.2 Two dimensional rotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
15.3 Jagged Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
IV Object Classes 401
16 Class File 403
16.1 An Introduction to Object Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
16.2 File Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
16.3 File methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
16.3.1 List of File methods we may use . . . . . . . . . . . . . . . . . . . . . . . . . 405
16.3.2 Error handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
16.3.3 Listing of File objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417
16.4 Scanner of a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
16.5 Writing to Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
17 Designing Object Classes 435
17.1 Using Object Classes for Packaging Data Elements . . . . . . . . . . . . . . . . . . . 435
17.1.1 The position of a game piece . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
17.1.2 Private instance variables and the toString method . . . . . . . . . . . . . . 440
17.1.3 Using constants in an object class . . . . . . . . . . . . . . . . . . . . . . . . 442
17.1.4 Information hiding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
17.2 Bank Account . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
17.3 Array with Capacity (as an Object Class) . . . . . . . . . . . . . . . . . . . . . . . . 461
18 Interfaces, Subclasses, Inheritance, and Polymorphism 471
18.1 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
18.1.1 Interface as a template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
18.1.2 A simple pizza application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472
18.1.3 The “simple” pizza collection class . . . . . . . . . . . . . . . . . . . . . . . . 473
18.1.4 The pizza collection main class . . . . . . . . . . . . . . . . . . . . . . . . . . 478
18.2 Subclasses and Superclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
18.2.1 Extending existing classes and interfaces . . . . . . . . . . . . . . . . . . . . . 480
18.2.2 Writing extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482
18.3 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490
18.4 Interface Comparable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493
V Advanced Concepts 499
19 Cumulative Algorithms 501
19.1 What is a Cumulative Algorithm? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501
19.2 Computing Recurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
19.3 Computing the Factorial Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
20 Recursive Algorithms 513
20.1 The Factorial Again . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513
20.2 GCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
20.3 The Tower of Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
