Tài liệu Introduction to Programming Using Java docx

CONTENTS iii
4.2.3 Subroutines in Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
4.2.4 Member Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
4.3 Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
4.3.1 Using Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
4.3.2 Formal and Actual Parameters . . . . . . . . . . . . . . . . . . . . . . . . 126
4.3.3 Overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
4.3.4 Subroutine Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
4.3.5 Throwing Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
4.3.6 Global and Local Variables . . . . . . . . . . . . . . . . . . . . . . . . . . 131
4.4 Return Values . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
4.4.1 The return statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
4.4.2 Function Examples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
4.4.3 3N+1 Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.5 APIs, Packages, and Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
4.5.1 Toolboxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
4.5.2 Java’s Standard Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
4.5.3 Using Classes from Packages . . . . . . . . . . . . . . . . . . . . . . . . . 140
4.5.4 Javadoc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
4.6 More on Program Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
4.6.1 Preconditions and Postconditions . . . . . . . . . . . . . . . . . . . . . . . 144
4.6.2 A Design Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
4.6.3 The Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
4.7 The Tr uth About Declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151
4.7.1 Initialization in Declarations . . . . . . . . . . . . . . . . . . . . . . . . . 152
4.7.2 Named Constants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
4.7.3 Naming and Scope Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
Exercises for Chapter 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
Quiz on Chapter 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
5 Objects and Classes 163
5.1 Objects and Instance Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
5.1.1 Objects, Classes, and Instances . . . . . . . . . . . . . . . . . . . . . . . . 164
5.1.2 Fundamentals of Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
5.1.3 Getters and Setters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
5.2 Constructors and Object Initialization . . . . . . . . . . . . . . . . . . . . . . . . 171
5.2.1 Initializing Instance Variables . . . . . . . . . . . . . . . . . . . . . . . . . 171
5.2.2 Constructors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
5.2.3 Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
5.3 Programming with Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
5.3.1 Some Built-in Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
5.3.2 Wrapper Classes and Autoboxing . . . . . . . . . . . . . . . . . . . . . . . 179
5.3.3 The class “Object” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
5.3.4 Object-oriented Analysis and Design . . . . . . . . . . . . . . . . . . . . . 181
5.4 Programming Example: C ard, Hand, Deck . . . . . . . . . . . . . . . . . . . . . . 183
5.4.1 Designing the classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
5.4.2 The Card Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
5.4.3 Example: A Simple Card Game . . . . . . . . . . . . . . . . . . . . . . . . 189
CONTENTS iv
5.5 Inheritance and Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
5.5.1 Extending Existing Classes . . . . . . . . . . . . . . . . . . . . . . . . . . 192
5.5.2 Inheritance and Class Hierarchy . . . . . . . . . . . . . . . . . . . . . . . 194
5.5.3 Example: Vehicles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
5.5.4 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
5.5.5 Abstract Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
5.6 this and super . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
5.6.1 The Special Variable this . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
5.6.2 The Special Variable super . . . . . . . . . . . . . . . . . . . . . . . . . . 204
5.6.3 Constructors in Subclasses . . . . . . . . . . . . . . . . . . . . . . . . . . 206
5.7 Interfaces, Nested Classes, and Other Details . . . . . . . . . . . . . . . . . . . . 207
5.7.1 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
5.7.2 Nested Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
5.7.3 Anonymous Inner Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
5.7.4 Mixing Static and Non-static . . . . . . . . . . . . . . . . . . . . . . . . . 212
5.7.5 Static Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
5.7.6 Enums as Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
Exercises for Chapter 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
Quiz on Chapter 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
6 Introduction to GUI Programming 223
6.1 The Basic GUI Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
6.1.1 JFr ame and JPanel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
6.1.2 Components and Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
6.1.3 Events and Listeners . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
6.2 Applets and HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
6.2.1 JApplet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
6.2.2 Reusing Your JPanels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
6.2.3 Basic HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
6.2.4 Applets on Web Pages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
6.3 Graphics and Painting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
6.3.1 Coordinates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
6.3.2 Colors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
6.3.3 Fonts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
6.3.4 Shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
6.3.5 Graphics2D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
6.3.6 An Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
6.4 Mouse Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
6.4.1 Event Handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
6.4.2 MouseEvent and MouseListener . . . . . . . . . . . . . . . . . . . . . . . . 251
6.4.3 Mouse Coordinates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
6.4.4 MouseMotionListeners and Dragging . . . . . . . . . . . . . . . . . . . . . 256
6.4.5 Anonymous Event Handlers . . . . . . . . . . . . . . . . . . . . . . . . . . 260
6.5 Timer and Keyboard Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
6.5.1 Timers and Animation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
6.5.2 Keyboar d Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
6.5.3 Focus Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
CONTENTS v
6.5.4 State Machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
6.6 Basic Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
6.6.1 JButton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273
6.6.2 JLabel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
6.6.3 JCheckBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
6.6.4 JTextField and JTextArea . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
6.6.5 JComboBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
6.6.6 JSlider . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
6.7 Basic Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
6.7.1 Basic Layout Managers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281
6.7.2 Borders . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
6.7.3 SliderAndComboBoxDemo . . . . . . . . . . . . . . . . . . . . . . . . . . 285
6.7.4 A Simp le Calculator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
6.7.5 Using a null Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
6.7.6 A Little Card Game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
6.8 Menus and Dialogs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
6.8.1 Menus and Menubars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
6.8.2 Dialogs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298
6.8.3 Fine Points of Frames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300
6.8.4 Creating Jar Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
Exercises for Chapter 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Quiz on Chapter 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
7 Arrays 311
7.1 Creating and Using Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
7.1.1 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
7.1.2 Using Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
7.1.3 Array Initialization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
7.2 Programming With Ar rays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
7.2.1 Arrays and for Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
7.2.2 Arrays and for-each Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
7.2.3 Array Types in Subroutines . . . . . . . . . . . . . . . . . . . . . . . . . . 319
7.2.4 Random Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
7.2.5 Arrays of Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
7.2.6 Variable Arity Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
7.3 Dynamic Arr ays and ArrayLists . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
7.3.1 Partially Full Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 327
7.3.2 Dynamic Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
7.3.3 ArrrayLists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
7.3.4 Parameterized Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
7.3.5 Vectors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
7.4 Searching and Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
7.4.1 Searching . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
7.4.2 Association Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
7.4.3 Insertion Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
7.4.4 Selection Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
7.4.5 Unsorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
CONTENTS vi
7.5 Multi-dimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
7.5.1 Creating Two-dimensional Arrays . . . . . . . . . . . . . . . . . . . . . . 350
7.5.2 Using Two-dimensional Arrays . . . . . . . . . . . . . . . . . . . . . . . . 352
7.5.3 Example: Checkers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
Exercises for Chapter 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
Quiz on Chapter 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
8 Correctness and Robustness 370
8.1 Introduction to Correctness and Robustness . . . . . . . . . . . . . . . . . . . . . 370
8.1.1 Horror Stories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
8.1.2 Java to the Rescue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
8.1.3 Problems Remain in Java . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
8.2 Writing Correct P rograms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
8.2.1 Provably Correct Programs . . . . . . . . . . . . . . . . . . . . . . . . . . 375
8.2.2 Robust Handling of Input . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
8.3 Exceptions and try catch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
8.3.1 Exceptions and Exception Class es . . . . . . . . . . . . . . . . . . . . . . 383
8.3.2 The try Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385
8.3.3 Throwing Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
8.3.4 Mandatory Exception Handling . . . . . . . . . . . . . . . . . . . . . . . . 389
8.3.5 Programming with Exceptions . . . . . . . . . . . . . . . . . . . . . . . . 390
8.4 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
8.5 Introduction to Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
8.5.1 Creating and Ru nning Threads . . . . . . . . . . . . . . . . . . . . . . . . 397
8.5.2 Operations on Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
8.5.3 Mutual Exclusion with “synchronized” . . . . . . . . . . . . . . . . . . . . 402
8.5.4 Wait and Notify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405
8.5.5 Volatile Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
8.6 Analysis of Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410
Exercises for Chapter 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
Quiz on Chapter 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 421
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 . . . . . . . . . . . . . . . . . . . . . . . . 428
9.1.4 Blob Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431
9.2 Linked Data Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
9.2.1 Recursive Linking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
9.2.2 Linked Lists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
9.2.3 Basic Linked List Processing . . . . . . . . . . . . . . . . . . . . . . . . . 437
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 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
CONTENTS vii
9.4 Binary Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
9.4.1 Tree Traversal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
9.4.2 Binary Sort Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458
9.4.3 Expression Trees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463
9.5 A Simp le Recursive Descent Parser . . . . . . . . . . . . . . . . . . . . . . . . . . 466
9.5.1 Backus-Naur Form . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
9.5.2 Recursive Descent Parsing . . . . . . . . . . . . . . . . . . . . . . . . . . . 468
9.5.3 Building an Expression Tree . . . . . . . . . . . . . . . . . . . . . . . . . . 472
Exercises for Chapter 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Quiz on Chapter 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 478
10 Generic Programming a nd Collection Classes 480
10.1 Generic Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
10.1.1 Generic Programming in Smalltalk . . . . . . . . . . . . . . . . . . . . . . 481
10.1.2 Generic Programming in C++ . . . . . . . . . . . . . . . . . . . . . . . . 482
10.1.3 Generic Programming in Java . . . . . . . . . . . . . . . . . . . . . . . . . 483
10.1.4 The Java Collection Framework . . . . . . . . . . . . . . . . . . . . . . . . 484
10.1.5 Iterators and for-each Loops . . . . . . . . . . . . . . . . . . . . . . . . . . 486
10.1.6 E q uality and Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
10.1.7 Generics and Wrapper Classes . . . . . . . . . . . . . . . . . . . . . . . . 490
10.2 Lists and S ets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
10.2.1 ArrayList and LinkedList . . . . . . . . . . . . . . . . . . . . . . . . . . . 491
10.2.2 Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494
10.2.3 TreeSet and Hash Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
10.2.4 E numSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498
10.3 Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499
10.3.1 The Map Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
10.3.2 Views, SubSets, and SubMaps . . . . . . . . . . . . . . . . . . . . . . . . 501
10.3.3 Hash Tables and Hash Codes . . . . . . . . . . . . . . . . . . . . . . . . . 504
10.4 Programming with the Collection Framework . . . . . . . . . . . . . . . . . . . . 506
10.4.1 Symbol Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
10.4.2 Sets Inside a Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
10.4.3 Using a Comparator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 510
10.4.4 Word Counting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512
10.5 Writing Generic Classes and Methods . . . . . . . . . . . . . . . . . . . . . . . . 514
10.5.1 Simple Generic Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
10.5.2 Simple Generic Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
10.5.3 Type Wildcards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
10.5.4 Boun ded Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522
Exercises for Chapter 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 526
Quiz on Chapter 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530
11 Files and Networking 531
11.1 Streams, Readers, and Writers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531
11.1.1 Character an d Byte Streams . . . . . . . . . . . . . . . . . . . . . . . . . 531
11.1.2 P rintWriter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 533
11.1.3 Data Streams . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 534
11.1.4 R eading Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535
CONTENTS viii
11.1.5 The Scanner Class . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538
11.1.6 Serialized Object I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 539
11.2 Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
11.2.1 R eading and Writing Files . . . . . . . . . . . . . . . . . . . . . . . . . . . 540
11.2.2 Files and Directories . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543
11.2.3 File Dialog Boxes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546
11.3 Programming With Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 548
11.3.1 Copying a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 549
11.3.2 Persistent Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551
11.3.3 Files in GUI Pr ograms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553
11.3.4 Storing Objects in Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555
11.4 Networking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 562
11.4.1 URL s and URLConnections . . . . . . . . . . . . . . . . . . . . . . . . . . 563
11.4.2 TCP/IP and Client/Server . . . . . . . . . . . . . . . . . . . . . . . . . . 565
11.4.3 Sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566
11.4.4 A Trivial Client/Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568
11.4.5 A Simple Network Chat . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572
11.5 Network Pr ogramming and Threads . . . . . . . . . . . . . . . . . . . . . . . . . 575
11.5.1 A Threaded GUI Chat Program. . . . . . . . . . . . . . . . . . . . . . . . 576
11.5.2 A Multithreaded Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579
11.5.3 Distributed Computing . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582
11.6 A Brief Introduction to XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
11.6.1 Basic XML Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 590
11.6.2 XMLEncoder and XML Decoder . . . . . . . . . . . . . . . . . . . . . . . 592
11.6.3 Working With the DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594
Exercises for Chapter 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 600
Quiz on Chapter 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 603
12 Advanced GUI Programming 604
12.1 Im ages and Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 604
12.1.1 Images and BufferedImages . . . . . . . . . . . . . . . . . . . . . . . . . . 604
12.1.2 Working With Pixels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610
12.1.3 R esources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613
12.1.4 Cursors and Icons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 614
12.1.5 Image File I/O . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 615
12.2 Fancier Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617
12.2.1 Measurin g Text . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 618
12.2.2 Transparency . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620
12.2.3 Antialiasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 622
12.2.4 Strokes and Paints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623
12.2.5 Transforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626
12.3 Actions and Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629
12.3.1 Action and AbstractAction . . . . . . . . . . . . . . . . . . . . . . . . . . 629
12.3.2 Icons on Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 631
12.3.3 R adio Button s . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632
12.3.4 Toolbars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 635
12.3.5 Keyboard Accelerators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636
CONTENTS ix
12.3.6 HTML on Buttons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638
12.4 C omplex Components and MVC . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
12.4.1 Model-View-Controller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639
12.4.2 Lists and ListModels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640
12.4.3 Tables and TableModels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 643
12.4.4 Documents and Editors . . . . . . . . . . . . . . . . . . . . . . . . . . . . 647
12.4.5 Custom Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 648
12.5 Finishing Touches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
12.5.1 The Mand elbrot Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653
12.5.2 Design of the Program . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655
12.5.3 Internationalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657
12.5.4 E vents, Events, Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 659
12.5.5 Custom Dialogs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661
12.5.6 P references . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662
Exercises for Chapter 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 664
Quiz on Chapter 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667
Appendix: Source Files 668
Preface
Introduction to Programming Using Java is a f ree introductory computer programming
textbook that uses Java as the language of instruction. It is suitable for use in an introductory
programming course and for people who are trying to learn programming on their own. There
are no prerequisites beyond a general familiarity with the ideas of computers and programs.
There is enough material for a full year of college-level programming. Chapters 1 through 7
can be used as a textbook in a one-semester college-level course or in a year-long high school
course.
This version of the book covers “Java 5.0”. It also works well with later versions of Java.
(While Java 5.0 introduced major new features that need to be covered in an introductory
programming course, Java 6.0 and the upcoming Java 7.0 do not.) Many of the examples in
the book use features that were not present before Java 5.0. Note that Java applets appear
throughout the pages of the on-line version of this book. Many of those applets will be non-
functional in Web browsers that do not support Java 5.0.
The home web site for this book is
http://math.hws .edu/javanotes/. The page at that
address contains links for downloading a copy of the web site and for downloading a PDF
version of the book.
∗ ∗ ∗
In style, this is a textbook rather than a tutorial. That is, it concentrates on explaining
concepts rath er than giving step-by-step how-to-do-it guides. I have tried to use a conversational
writing style that might be closer to classroom lecture than to a typical textbook. You’ll
find programming exercises at the end of most chapters, and you will find a detailed solution
for each exercise, with the sort of discussion that I would give if I presented the solution in
class. (Solutions to the exercises can be found in the on-lin e vers ion only.) I strongly advise
that you read the exercise solutions if you want to get the most out of this book. This is
certainly not a Java reference book, and it is not even close to a comprehens ive survey of all
the features of Java. It is not written as a quick introduction to Java for people who already
know another programming language. Instead, it is directed mainly towards people who are
learning programming for the first time, and it is as much about general programming concepts
as it is about Java in particular. I believe that Introduction to Programming using Java is
fully competitive with the conventionally pu blished, printed programming textbooks that are
available on the market. (Well, all r ight, I’ll conf ess that I think it’s better.)
There are several approaches to teaching Java. One approach uses graphical user inter face
programming from the very beginning. Some people believe that 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 mor e basic building blocks of programming and builds
from there. After an introductory chapter, I cover procedural programming in Chapters 2, 3,
and 4. Object-oriented programming is introduced in Chapter 5. Chapters 6 cover s the closely
related topic of event-oriented programming and graphical user interfaces . Ar rays are covered in
x
Preface xi
Chapter 7. Chapter 8 marks a tu rning point in the book, moving beyond the fundamental ideas
of programming to cover more advanced topics. Ch apter 8 is mostly about writing robust and
correct programs, but it also has a section on parallel pr ocessing an d threads. Chapters 9 and
10 cover recursion and data structures, including the Java Collection Framework. Chapter 11 is
about files and n etworking. Finally, Chapter 12 returns to the topic of graphical user interface
programming to cover some of Java’s more advanced capabilities.
∗ ∗ ∗
Major changes were made for the fifth edition of this book. Perhaps the most significant
change is the use of parameterized types in the chapter on generic programming. Par ameterized
types—Java’s version of templates—were the most eagerly anticipated new feature in Java 5.0.
Other new features in Java 5.0 are also covered. Enumerated types are introduced, although
they are not covered in their f ull complexity. The “for-each” loop is covered and is used
extensively. Formatted output is also used extensively, and the Scanner clas s is covered (though
not until Chapter 11). Static import is covered briefly, as are variable arity methods.
The non-standard Text IO class that I use for input in the first half of the book has been
rewritten to support formatted output. I have also added some file I/O capabilities to this class
to make it possible to cover some examples that use files early in the book.
Javadoc comments are covered for the first time in the fifth edition. Almost all code examples
have been revised to use Javadoc-style comments.
The coverage of graphical user interface programming has been reorganized, much of it has
been rewritten, and new material has been added. In previous ed itions, I emp hasized applets.
Stand-alone GUI applications were covered at the end, almost as an afterthought. In the fifth
edition, the emphasis on applets is gone, and almost all examples are presented as stand-alone
applications. However, applet versions of each example are still presented on the web pages of
the on-line version of the book. The chapter on advanced GUI pr ogramming has been moved
to the end, and a significant amount of new material has been added, including coverage of
some of the features of Graphics2D.
Aside from the changes in content, the appearance of the book has b een improved, especially
the appearance of the PDF version. For the first time, the quality of the PDF approaches that
of conventional textbooks.
Version 5.1 of this book is a min or update of Version 5.0. A number of typographical an d
co ding errors in Version 5.0 have been corrected. Also, the discussion of the Eclipse IDE in
Section 2.6 has been updated to be consistent with more recent versions of Eclipse.
∗ ∗ ∗
The latest complete edition of Introduction to Programming using Java is always available
on line at
http://math.hws .edu/javanotes/. The first version of the book was written in 1996,
and there have been several editions since then. All editions are arch ived at the following Web
addresses:
• First ed ition:
http://math.hws .edu/eck/cs124/javanotes1/ (Covers Java 1.0.)
• Second edition:
http://math.hws .edu/eck/cs124/javanotes2/ (Covers Java 1.1.)
• Third edition:
http://math.hws .edu/eck/cs124/javanotes3/ (Covers Java 1.1.)
• Fourth edition:
http://math.hws .edu/eck/cs124/javanotes4/ (Covers Java 1.4.)
• Fifth edition:
http://math.hws .edu/eck/cs124/javanotes5/ (Covers Java 5.0.)
Introduction to Programming using Java is free, but it is not in the public domain. As of
Version 5.0, it is published under the terms of the Creative Commons Attribution-Share Alike
Preface xii
2.5 License. To view a copy of this license, visit
http://creativecommons.org/licenses/by-sa/2.5/
or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San Francisco, Califor-
nia, 94105, USA. This license allows redistribu tion and modification under certain terms. For
example, you can:
• Post an unmodified copy of the on-line version on your own Web site (includin g th e parts
that list the author and state the license under which it is distributed!).
• Give away or sell printed, unmodified copies of this book, as long as they meet the re-
quirements of th e licen se.
• Make modified copies of the complete book or parts of it and post them on the web or
otherwise distribute them, provided that attribution to the author is given, the modifica-
tions are clearly noted, and the modified copies are distributed under the same license as
the original. This includes translations to other languages.
While it is not actually required by the license, I do appreciate hearing from people wh o
are using or distributing my work.
∗ ∗ ∗
A technical note on production: The on-line and PDF versions of this book are created
from a single source, which is written largely in XML. To produce the PDF version, the XML
is processed into a form that can be used by the TeX typesetting program. In addition to XML
files, the source includes DTDs, XSLT transform ations, Java source code files, image files, a
TeX macro file, and a couple of scripts that are used in processing.
I have made the complete source files available for download at the following
address:
http://math.hws .edu/eck/cs124/downloads/javanotes5-full-source.zip
These files were not originally meant for p ublication, and therefore are not very cleanly
written. Furthermore, it requires a fair amount of expertise to use them effectively. However,
I have had several requests for the sources and have made them available on an “as-is” basis.
For more information about the source an d how they are used see the README file from the
source download.
∗ ∗ ∗
Professor David J. Eck
Department of Mathematics and Computer Science
Hobart and William Smith Colleges
Geneva, New York 14456, USA
Email: eck@hws.edu
WWW:
http://math.hws .edu/eck/

Xem chi tiết: Tài liệu Introduction to Programming Using Java docx