Fundamentals of Java Programming

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     Passing 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     For-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     Formatted 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

III   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