Java面向對象程序設計（英文版·第3版）

Part 1　Foundations of object orientation　1
Chapter 1　Objects and classes　3
1.1　Objects and classes　3
1.2　Creating objects　4
1.3　Calling methods　5
1.4　Parameters　6
1.5　Data types　7
1.6　Multiple instances　8
1.7　State　8
1.8　What is in an object?　9
1.9　Object interaction　10
1.10　Source code　11
1.11　Another example　13
1.12　Return values　13
1.13　Objects as parameters　13
1.14　Summary　15
Chapter 2　Understanding class definitions　17
2.1　Ticket machines　17
2.1.1　Exploring the behavior of a na晇e ticket machine　18
2.2　Examining a class definition　19
2.3　Fields, constructors, and methods　21
2.3.1　Fields　23
2.3.2　Constructors　25
2.4　Passing data via parameters　26
2.5　Assignment　27
2.6　Accessor methods　28
2.7　Mutator methods　31
2.8　Printing from methods　32
2.9　Summary of the na?ve ticket machine　34
2.10　Reflecting on the design of the ticket machine　35
2.11　Making choices: the conditional statement　36
2.12　A further conditional-statement example　39
2.13　Local variables　41
2.14　Fields, parameters, and local variables　42
2.15　Summary of the better ticket machine　43
2.16　Self-review exercises　43
2.17　Reviewing a familiar example　45
2.18　Summary　48
Chapter 3　Object interaction　52
3.1　The clock example　52
3.2　Abstraction and modularization　53
3.3　Abstraction in software　54
3.4　Modularization in the clock example　54
3.5　Implementing the clock display　55
3.6　Class diagrams versus object diagrams　56
3.7　Primitive types and object types　58
3.8　The ClockDisplay source code　59
3.8.1　Class NumberDisplay　59
3.8.2　String concatenation　61
3.8.3　The modulo operator　62
3.8.4　Class ClockDisplay　63
3.9　Objects creating objects　66
3.10　Multiple constructors　67
3.11　Method calls　68
3.11.1　Internal method calls　68
3.11.2　External method calls　69
3.11.3　Summary of the clock display　70
3.12　Another example of object interaction　70
3.12.1　The mail system example　71
3.12.2　The this key word　72
3.13　Using a debugger　74
3.13.1　Setting breakpoints　74
3.13.2　Single stepping　76
3.13.3　Stepping into methods　77
3.14　Method calling revisited　78
3.15　Summary　78
Chapter 4　Grouping objects　81
4.1　Grouping objects in flexible-size collections　81
4.2　A personal notebook　82
4.3　A first look at library classes　82
4.3.1　An example of using a library　83
4.4　Object structures with collections　84
4.5　Generic classes　86
4.6　Numbering within collections　87
4.7　Removing an item from a collection　88
4.8　Processing a whole collection　89
4.8.1　The for-each loop　90
4.8.2　The while loop　92
4.8.3　Iterating over a collection　95
4.8.4　Index access versus iterators　96
4.9　Summary of the notebook example　97
4.10　Another example: an auction system　98
4.10.1　The Lot class　98
4.10.2　The Auction class　99
4.10.3　Anonymous objects　102
4.10.4　Using collections　103
4.11　Flexible collection summary　105
4.12　Fixed-size collections　105
4.12.1　A log-file analyzer　106
4.12.2　Declaring array variables　108
4.12.3　Creating array objects　109
4.12.4　Using array objects　110
4.12.5　Analyzing the log file　111
4.12.6　The for loop　111
4.13　Summary　116
Chapter 5　More sophisticated behavior　119
5.1　Documentation for library classes　120
5.2　The TechSupport system　120
5.2.1　Exploring the TechSupport system　121
5.2.2　Reading the code　122
5.3　Reading class documentation　126
5.3.1　Interfaces versus implementation　127
5.3.2　Using library-class methods　128
5.3.3　Checking string equality　130
5.4　Adding random behavior　131
5.4.1　The Random class　131
5.4.2　Random numbers with limited range　132
5.4.3　Generating random responses　133
5.4.4　Reading documentation for parameterized classes　135?
5.5　Packages and import　136
5.6　Using maps for associations　137
5.6.1　The concept of a map　138
5.6.2　Using a HashMap　138
5.6.3　Using a map for the TechSupport system　139
5.7　Using sets　141
5.8　Dividing strings　142
5.9　Finishing the TechSupport system　144
5.10　Writing class documentation　146
5.10.1　Using javadoc in BlueJ　146
5.10.2　Elements of class documentation　146
5.11　Public versus private　148
5.11.1　Information hiding　149
5.11.2　Private methods and public fields　149
5.12　Learning about classes from their interfaces　150
5.13　Class variables and constants　153
5.13.1　The static key word　153
5.13.2　Constants　154
5.14　Summary　155
Chapter 6　Well-behaved objects　158
6.1　Introduction　158
6.2　Testing and debugging　159
6.3　Unit testing within BlueJ　159
6.3.1　Using inspectors　164
6.3.2　Positive versus negative testing　165
6.4　Test automation　166
6.4.1　Regression testing　166
6.4.2　Automated checking of test results　169
6.4.3　Recording a test　171
6.4.4　Fixtures　173
6.5　Modularization and interfaces　174
6.6　A debugging scenario　176
6.7　Commenting and style　177
6.8　Manual walkthroughs　178
6.8.1　A high-level walkthrough　178
6.8.2　Checking state with a walkthrough　180
6.8.3　Verbal walkthroughs　182
6.9　Print statements　183
6.9.1　Turning debugging information on or off　185
6.10　Choosing a test strategy　186
6.11　Debuggers　187
6.12　Putting the techniques into practice　187
6.13　Summary　188
Chapter 7　Designing classes　189
7.1　Introduction　190
7.2　The world-of-zuul game example　191
7.3　Introduction to coupling and cohesion　193
7.4　Code duplication　194
7.5　Making extensions　197
7.5.1　The task　197
7.5.2　Finding the relevant source code　198
7.6　Coupling　199
7.6.1　Using encapsulation to reduce coupling　200
7.7　Responsibility-driven design　204
7.7.1　Responsibilities and coupling　204
7.8　Localizing change　206
7.9　Implicit coupling　207
7.10　Thinking ahead　210
7.11　Cohesion　211
7.11.1　Cohesion of methods　211
7.11.2　Cohesion of classes　212
7.11.3　Cohesion for readability　213
7.11.4　Cohesion for reuse　213
7.12　Refactoring　214
7.12.1　Refactoring and testing　215
7.12.2　An example of refactoring　215
7.13　Refactoring for language independence　218
7.13.1　Enumerated types　219
7.13.2　Further decoupling of the command interface　220
7.14　Design guidelines　222
7.15　Executing without BlueJ　223
7.15.1　Class methods　224
7.15.2　The main method　224
7.15.3　Limitations of class methods　225
7.16　Summary　225
Part 2　Application structures　227
Chapter 8　Improving structure with inheritance　229
8.1　The DoME example　229
8.1.1　DoME classes and objects　230
8.1.2　DoME source code　232
8.1.3　Discussion of the DoME application　238
8.2　Using inheritance　239
8.3　Inheritance hierarchies　240?
8.4　Inheritance in Java　241
8.4.1　Inheritance and access rights　242
8.4.2　Inheritance and initialization　242
8.5　DoME: adding other item types　244
8.6　Advantages of inheritance (so far)　246
8.7　Subtyping　247
8.7.1　Subclasses and subtypes　248
8.7.2　Subtyping and assignment　249
8.7.3　Subtyping and parameter passing　250
8.7.4　Polymorphic variables　251
8.7.5　Casting　251
8.8　The Object class　253
8.9　Autoboxing and wrapper classes　254
8.10　The collection hierarchy　255
8.11　Summary　255
Chapter 9　More about inheritance　258
9.1　The problem: DoME's print method　258
9.2　Static type and dynamic type　260
9.2.1　Calling print from Database　261
9.3　Overriding　262
9.4　Dynamic method lookup　264
9.5　Super call in methods　267
9.6　Method polymorphism　268
9.7　Object methods: toString　268
9.8　Protected access　271
9.9　Another example of inheritance with overriding　273
9.10　Summary　276
Chapter 10　Further abstraction techniques　278
10.1　Simulations　278
10.2　The foxes-and-rabbits simulation　279
10.2.1　The foxes-and-rabbits project　280
10.2.2　The Rabbit class　282
10.2.3　The Fox class　285
10.2.4　The Simulator class: setup　288
10.2.5　The Simulator class: a simulation step　291
10.2.6　Taking steps to improve the simulation　292
10.3　Abstract classes　292
10.3.1　The Animal superclass　293
10.3.2　Abstract methods　294
10.3.3　Abstract classes　296
10.4　More abstract methods　298
10.5　Multiple inheritance　300
10.5.1　An Actor class　300
10.5.2　Flexibility through abstraction　302
10.5.3　Selective drawing　302
10.5.4　Drawable actors: multiple inheritance　302
10.6　Interfaces　303
10.6.1　An Actor interface　303
10.6.2　Multiple inheritance of interfaces　305
10.6.3　Interfaces as types　306
10.6.4　Interfaces as specifications　306
10.6.5　A further example of interfaces　308
10.6.6　Abstract class or interface?　309
10.7　Summary of inheritance　309
10.8　Summary　310
Chapter 11　Building graphical user interfaces　312
11.1　Introduction　312
11.2　Components, layout, and event handling　313
11.3　AWT and Swing　313
11.4　The ImageViewer example　314
11.4.1　First experiments: creating a frame　315
11.4.2　Adding simple components　317
11.4.3　Adding menus　318
11.4.4　Event handling　319
11.4.5　Centralized receipt of events　319
11.4.6　Inner classes　322
11.4.7　Anonymous inner classes　323
11.5　ImageViewer 1.0: the first complete version　325
11.5.1　Image-processing classes　326
11.5.2　Adding the image　327
11.5.3　Layout　328
11.5.4　Nested containers　331
11.5.5　Image filters　334
11.5.6　Dialogs　337
11.6　ImageViewer 2.0: improving program structure　338
11.7　ImageViewer 3.0: more interface components　343
11.7.1　Buttons　343
11.7.2　Borders　346
11.8　Further extensions　347
11.9　Another example: SoundPlayer　349
11.10　Summary　352
Chapter 12　Handling errors　354
12.1　The address-book project　355
12.2　Defensive programming　359
12.2.1　Client-Server interaction　359
12.2.2　Argument checking　360
12.3　Server error reporting　361
12.3.1　Notifying the user　362
12.3.2　Notifying the client object　362
12.4　Exception-throwing principles　365
12.4.1　Throwing an exception　366
12.4.2　Exception classes　366
12.4.3　The effect of an exception　368
12.4.4　Unchecked exceptions　369
12.4.5　Preventing object creation　370
12.5　Exception handling　371
12.5.1　Checked exceptions: the throws clause　371
12.5.2　Catching exceptions: the try statement　372
12.5.3　Throwing and catching multiple exceptions　374
12.5.4　Propagating an exception　375
12.5.5　The finally clause　376
12.6　Defining new exception classes　377
12.7　Using assertions　378
12.7.1　Internal consistency checks　378
12.7.2　The assert statement　379
12.7.3　Guidelines for using assertions　380
12.7.4　Assertions and the BlueJ unit testing framework　381
12.8　Error recovery and avoidance　382
12.8.1　Error recovery　382
12.8.2　Error avoidance　383
12.9　Case study: text input/output　384
12.9.1　Readers, writers, and streams　385
12.9.2　The address-book-io project　385
12.9.3　Text output with FileWriter　388
12.9.4　Text input with FileReader　389
12.9.5　Scanner: reading input from the terminal　390
12.9.6　Object serialization　391
12.10　Summary　392
Chapter 13　Designing applications　393
13.1　Analysis and design　393
13.1.1　The verb/noun method　394
13.1.2　The cinema booking example　394
13.1.3　Discovering classes　394
13.1.4　Using CRC cards　395
13.1.5　Scenarios　396
13.2　Class design　399
13.2.1　Designing class interfaces　400
13.2.2　User interface design　401
13.3　Documentation　401
13.4　Cooperation　402
13.5　Prototyping　402
13.6　Software growth　403
13.6.1　Waterfall model　403
13.6.2　Iterative development　404
13.7　Using design patterns　405
13.7.1　Structure of a pattern　406
13.7.2　Decorator　406
13.7.3　Singleton　407
13.7.4　Factory method　408
13.7.5　Observer　408
13.7.6　Pattern summary　410
13.8　Summary　410
Chapter 14　A case study　413
14.1　The case study　413
14.1.1　The problem description　413
14.2　Analysis and design　414
14.2.1　Discovering classes　414
14.2.2　Using CRC cards　415
14.2.3　Scenarios　416
14.3　Class design　418
14.3.1　Designing class interfaces　418
14.3.2　Collaborators　418
14.3.3　The outline implementation　419
14.3.4　Testing　423
14.3.5　Some remaining issues　423
14.4　Iterative development　424
14.4.1　Development steps　424
14.4.2　A first stage　425
14.4.3　Testing the first stage　428
14.4.4　A later stage of development　429
14.4.5　Further ideas for development　431
14.4.6　Reuse 431?4.5 Another example　432
14.6　Taking things further　432
Appendices　433
A　Working with a BlueJ project　433
B　Java data types　435
C　Java control structures　438
D　Operators　443
E　Running Java without BlueJ　445
F　Configuring BlueJ　448
G　Using the debugger　450
H　JUnit unit-testing tools　454
I　Javadoc　456
J　Program style guide　459
K　Important library classes　463
Index　467