Java程序设计语言（英文版·第4版）（JAVA之父权威力作 ）

.1.11銆�extending a class銆�24
1.11.1銆�invoking methods of the superclass銆�25
1.11.2銆�the 0bject class銆�26
1.11.3銆�type casting銆�27
1.12銆�interfaces銆�27
1.13銆�generic types銆�29
1.14銆�exceptions銆�32
1.15銆�annotations銆�35
1.16銆�packages銆�36
1.17銆�the java platform銆�38
1.18銆�other topics briefly noted銆�39

2銆�classes and objects銆�41
2.1銆�a simple class銆�42
2.1.1銆�class members銆�42
2.1.2銆�class modifiers銆�43
2.2銆�fields銆�44
2.2.1銆�field initialization銆�44
2.2.2銆�static fields銆�45
2.2.3銆�final fields銆�46
2.3銆�access control銆�47
2.4銆�creating objects銆�49
2.5銆�construction and initialization銆�50
2.5.1銆�constructors銆�50
2.5.2銆�initialization blocks銆�54
2.5.3銆�static initialization銆�55
2.6銆�methods銆�56
2.6.1銆�static methods銆�58
2.6.2銆�method invocations銆�58
2.6.3銆�methods with variable numbers of arguments銆�60
2.6.4銆�method execution and return銆�62
2.6.5銆�parameter values銆�63
2.6.6銆�using methods to control access銆�65
2.7銆�this銆�68
2.8銆�overloading methods銆�69
2.9銆�importing static member names銆�71
2.10銆�the main method銆�73
2.11銆�native methods銆�74

3銆�extending classes銆�75
3.1銆�an extended, class銆�76
3.2銆�constructors in extended classes銆�80
3.2.1銆�constructor order dependencies銆�81
3.3銆�inheriting and redefining members銆�84
3.3.1銆�overriding銆�84
3.3.2銆�hiding fields銆�86
3.3.3銆�accessing inherited members銆�86
3.3.4銆�accessibility and overriding銆�88
3.3.5銆�hiding static members銆�89
3.3.6銆�the super keyword銆�89
3.4銆�type compatibility and conversion銆�90
3.4.1銆�compatibility銆�90
3.4.2銆�explicit type casting銆�91
3.4.3銆�testing for type銆�92
3.5銆�what protected really means銆�93
3.6銆�marking methods and classes final銆�96
3.7銆�abstract classes and methods銆�97
3.8銆�the object class銆�99
3.9銆�cloning objects銆�101
3.9.1銆�strategies for cloning銆�101
3.9.2銆�correct cloning銆�101
3.9.3銆�shallow versus deep cloning銆�106
3.10銆�extending classes: how and when銆�107
3.11銆�designing a class to be extended銆�108
3.11.1銆�designing a class to be extended銆�108
3.12銆�single inheritance versus multiple inheritance銆�114

4銆�interfaces銆�117
4.1銆�a simple interface example銆�118
4.2銆�interface declarations銆�120
4.2.1銆�interface constants 121
4.2.2銆�interface methods銆�122
4.2.3銆�interface modifiers銆�122
4.3銆�extending interfaces銆�122
4.3.1銆�inheriting and hiding constants銆�123
4.3.2銆�inheriting, overriding, and overloading methods銆�125
4.4銆�working with interfaces銆�126
4.4.1銆�implementing interfaces銆�127
4.4.2銆�using an implementation銆�129
4.5銆�marker interfaces銆�130
4.6銆�when to use interfaces銆�131

5銆�nested classes and interfaces銆�133
5.1銆�static nested types銆�133
5.1.1銆�static nested types銆�134
5.1.2銆�nested interfaces銆�135
5.2銆�inner classes銆�136
5.2.1銆�accessing enclosing objects銆�138
5.2.2銆�extending inner classes銆�139
5.2.3銆�inheritance, scoping, and hiding銆�140
5.3銆�local inner classes銆�142
5.3.1銆�inner classes in static contexts銆�144
5.4銆�anonymous inner classes銆�144
5.5銆�inheriting nested types銆�146
5.6銆�nesting in interfaces銆�148
5.6.1銆�modifiable variables in interfaces銆�149
5.7銆�implementation of nested types銆�149

6銆�enumeration types銆�151
6.1銆�a simple enum example銆�151
6.2銆�enum declarations銆�152
6.2.1銆�enum modifiers銆�154
6.3銆�enum constant declarations銆�154
6.3.1銆�construction銆�155
6.3.2銆�constant specific behavior銆�156
6.4銆�java.lang.enum銆�159
6.5銆�to enum or not銆�160

7銆�tokens, values, and variables銆�161
7.1銆�lexical elements銆�161
7.1.1銆�character set銆�161
7.1.2銆�comments銆�163
7.1.3銆�tokens銆�164
7 1 4銆�identifiers164
7.1.5銆�keywords銆�165
7.2銆�types and literals銆�166
7.1.1銆�reference literals銆�167
7.2.2銆�boolean literals銆�167
7 2 3銆�character literals銆�167
7 2 4銆�integer literals銆�167
7 2 5銆�floating-point literals銆�168
7.2.6銆�string literals銆�168
7.2.7銆�class literals銆�169
7 3銆�variables銆�169
7.3.1銆�field and local variable declarations銆�170
7.3.2銆�parameter variables銆�171
7.3.3銆�final variables銆�171
7.4銆�array variables銆�173
7.4.1銆�array modifiers銆�174
7.4.2銆�arrays of arrays銆�174
7 4 3銆�array initialization銆�175
7.4.4銆�arrays and types銆�177
7.5銆�the meanings of names銆�178

8銆�primitives as types銆�183
8.1銆�common fields and methods銆�184
8.1.1銆�construction銆�185
8.1.2銆�constants銆�185
8.1.3銆�common methods銆�186
8.2銆�void銆�187
8.3銆�boolean銆�187
8.4銆�number銆�188
8.4.1銆�the integer wrappers銆�188
8.4.2銆�the floating-point wrapper classes銆�191
8.5銆�character銆�192
8.5.1銆�working with utf-16銆�196
8.6銆�boxing conversions銆�199

9銆�operators and expressions銆�201
9.1銆�arithmetic operations銆�201
9.1.1銆�integer arithmetic銆�202
9 1 2銆�floating-point arithmetic銆�202
9.1.3銆�strict and non-strict floating-point arithmetic銆�203
9.2銆�general operators銆�204
9.2.1銆�increment and decrement operators銆�205
9.2.2銆�relational and equality operators銆�206
9.2.3銆�logical operators銆�207
9.2.4銆�instanceof銆�208
9.2.5銆�bit manipulation operators銆�208
9 2 6銆�the conditional operator?:銆�210
9.2.7銆�assignment operators銆�212
9.2.8銆�string concatenation operator銆�214
9.2.9銆�new銆�214
9.3銆�expressions銆�214
9.3.1銆�order of evaluation銆�214
9.3.2銆�expression type銆�215
9.4銆�type conversions銆�216
9.4.1銆�implicit type conversions銆�216
9.4.2銆�explicit-type casts銆�217
9.4.3銆�string conversions銆�220
9.5銆�operator precedence and associativity銆�221
9.6銆�member access銆�223
9.6.1銆�finding the right method銆�224

10銆�control flow銆�229
10.1銆�statements and blocks銆�229
10.2銆�if-else銆�230
10.3銆�switch銆�232
10.4銆�while and do-while銆�235
10.5銆�for銆�236
10.5.1銆�basic for statement銆�236
10.5.2銆�enhanced for statement銆�239
10.6銆�labels銆�241
10.7銆�break銆�241
10.8銆�continue銆�244
10.9銆�return銆�245
10.10銆�what, no goto?銆�246

11銆�generic types銆�247
11.1銆�generic type declarations銆�250
11.1.1銆�bounded type parameters銆�252
11.1.2銆�nested generic types銆�253
11 2銆�working with generic types銆�256
11.2.1銆�subtyping and wildcards銆�256
11.3銆�generic methods and constructors銆�260
11.3.1銆�generic invocations and type inference銆�262
11.4銆�wildcard capture銆�264
11.5銆�under the hood: erasure and raw types銆�267
11.5.1銆�erasure at runtime銆�267
11.5.2銆�overloading and overriding銆�271
11.6銆�finding the right method锛峈evisited銆�272
11.7銆�class extension and generic types銆�276

12銆�exceptions and assertions銆�279
12.1銆�creating exception types銆�280
12.2銆�throw銆�282
12.2.1銆�transfer of control銆�283
12.2.2銆�asynchronous exceptions銆�283
12.3銆�the throws clause銆�283
12.3.1銆�throws clauses and method overriding銆�285
12.3.2銆�throws clauses and native methods銆�286
12.4銆�try, catch, and finally銆�286
12.4.1銆�finally銆�288
12.5銆�exception chaining銆�291
12.6銆�stack traces銆�294
12.7銆�when to use exceptions銆�294
12.8銆�assertions銆�296
12.8.1銆�the assert statement銆�297
12.9銆�when to use assertions銆�297
12.9.1銆�state assertions銆�297
12.9.2銆�control flow assertions銆�299
12.10銆�turning assertions on and off銆�300
12.10.1銆�why turn assertions on and off?銆�300
12.10.2銆�controlling assertions on the command line銆�300
12.10.3銆�complete removal銆�302
12.10.4銆�making assertions required銆�302

13銆�strings and regular expressions銆�305
13.1銆�character sequences銆�305
13.2銆�the string class銆�306
13.2.1銆�basic string operations銆�306
13.2.2銆�string comparisons銆�308
13.2.3銆�string literals, equivalence and interning銆�311
13.2.4銆�making related strings銆�313
13.2.5銆�string conversions銆�316
13.2.6銆�strings and char arrays銆�317
13.2.7銆�strings and byte arrays銆�319
13.2.8銆�character set encoding銆�320
13.3銆�regular expression matching銆�321
13.3.1銆�regular expressions銆�321
13.3.2銆�compiling and matching with regular expressions銆�323
13.3.3銆�replacing銆�326
13.3.4銆�regions銆�329
13.3.5銆�efficiency銆�329
13.4銆�the stringbuilder class銆�330
13.5銆�working with utf-16銆�336

14銆�threads銆�337
14.1銆�creating threads銆�339
14.2銆�using runnable銆�341
14.3銆�synchronization銆�345
14.3.1銆�synchronized methods銆�346
14 3 2銆�static synchronized methods 348
14.3.3銆�synchronized statements銆�348
14.3.4銆�synchronization designs銆�352
14.4銆�wait, notifyall, and notify銆�354
14.5銆�details of waiting and notification銆�357
14.6銆�thread scheduling銆�358
14.6.1銆�voluntary rescheduling銆�360
14.7銆�deadlocks銆�362
14.8銆�ending thread execution銆�365
14.8.1銆�cancelling a thread銆�365
14.8.2銆�waiting for a thread to complete銆�367
14.9銆�ending application execution銆�369
14.10銆�the memory model: synchronization and volatile銆�370
14.10.1銆�synchronization actions銆�372
14.10.2銆�final fields and security銆�373
14.10.3銆�the happens-before relationship銆�374
14.11銆�thread management, security, and threadgroup銆�375
14.12銆�threads and exceptions銆�379
14.12.1銆�don't stop381
14.12.2銆�stack traces銆�382
14.13銆�threadlocal variables銆�382
14.14銆�debugging threads銆�384

15銆�annotations銆�387
15.1銆�a simple annotation example銆�388
15.2銆�annotation types銆�389
15.3銆�annotating elements銆�392
15.4銆�restricting annotation applicability銆�393
15.5銆�retention policies銆�395
15.6銆�working with annotations銆�395

16銆�reflection銆�397
16.1銆�the class class銆�399
16.1.1銆�type tokens銆�400
16.1.2銆�class inspection銆�402
16.1.3銆�examining class members銆�408
16,l.4銆�naming classes銆�411
16.1.5銆�obtaining class objects by name銆�413
16.1.6銆�runtime type queries銆�414
16.2銆�annotation queries銆�414
16.3銆�the modifier class銆�416
16.4銆�the member classes銆�416
16.5銆�access checking and accessibleobject銆�417
16.6銆�the field class銆�418
16.6.1銆�final fields銆�420
16.7銆�the method class銆�420
16.8銆�creating new objects and the constructor class銆�423
16.8.1銆�inner class constructors銆�425
16.9銆�generic type inspection銆�426
16.9.1銆�type variables銆�426
16.9.2銆�parameterized types銆�427
16.9.3銆�wildcards銆�428
16.9.4銆�generic arrays銆�428
16.9.5銆�string representation of type objects 428
16.10銆�arrays銆�429
16.10.1銆�genericity and dynamic arrays銆�430
16.11銆�packages銆�432
16.12銆�the proxy class銆�432
16.13銆�loading classes銆�435
16.13.1銆�the classloader class銆�438
16.13.2銆�preparing a class for use銆�441
16.13.3銆�loading related resources銆�442
16.14銆�controlling assertions at runtime銆�444

17銆�garbage collection and memory銆�447
17.1銆�garbage collection銆�447
17.2銆�a simple model銆�448
17.3銆�finalization銆�449
17.3.1銆�resurrecting objects during finalize銆�452
17.4銆�interacting with the garbage collector銆�452
17.5銆�reachability states and reference objects銆�454
17.5.1銆�the reference class銆�455
17.5.2銆�strengths of reference and reachability銆�455
17.5.3銆�reference queues銆�459
17.5.4銆�finalization and reachability銆�464

18銆�packages銆�467
18.1銆�package naming銆�468
18.2銆�type imports銆�469
18.3銆�package access銆�471
18.3.1銆�accessibility and overriding methods銆�472
18.4銆�package contents銆�475
18.5銆�package annotations銆�476
18.6銆�package objects and specifications銆�477

19銆�documentation comments銆�481
19.1銆�the anatomy of a doc comment銆�482
19.2銆�tags銆�483
19.2.1銆�@see銆�483
19.2.2銆�{@link} and {@1inkplain}銆�484
19.2.3銆�@param銆�485
19.2.4銆�@return銆�485
19.2.5銆�@throws and @exception銆�485
19.2.6銆�@deprecated銆�486
19.2.7銆�@author銆�486
19.2.8銆�@version銆�487
19.2.9銆�@since銆�487
19.2.10銆�{@literal} and {@code}銆�487
19.2.11銆�{@value}銆�487
19.2.12銆�{@docroot}銆�488
19.2.13銆�{@inheritdoc}銆�488
19.3銆�inheriting method documentation comments銆�489
19.3.1銆�inheriting @throws comments銆�490
19.4銆�a simple example銆�491
19.5銆�external conventions銆�496
19.5.1銆�package and overview documentation銆�496
19.5.2銆�the doc-files directory銆�497
19.6銆�notes on usage銆�497

20銆�the i/o package銆�499
20.1銆�streams overview銆�500
20.2銆�byte streams銆�501
20.2.1銆�inputstream銆�503
20.2.2銆�outputstream銆�505
20.3銆�character streams銆�507
20.3.l銆�reader銆�508
20.3.2銆�writer銆�510
20.3.3銆�character streams and the standard streams銆�511
20.4銆�inputstreamreader and outputstreamwriter銆�512
20.5銆�a quick tour of the stream classes銆�514
20.5.1銆�synchronization and concurrency 515
20.5.2銆�filter streams銆�516
20.5.3銆�buffered streams銆�518
20.5.4銆�piped streams銆�520
20.5.5銆�bytearray byte streams銆�521
20.5.6銆�chararray character streams銆�522
20.5.7銆�string character streams銆�銆�523
20.5.8銆�print streams銆�525
20.5.9銆�linenumberreader銆�527
20.5.10銆�sequenceinputstream銆�528
20.5.11銆�pushback streams銆�529
20.5.12銆�streamtokenizer銆�532
20.6銆�the data byte streams銆�537
20.6.1銆�datainput and dataoutput銆�537
20.6.2銆�the data stream classes銆�539
20.7銆�working with files銆�540
20.7.1銆�fi1e streams and fi1edescriptor銆�540
20.7.2銆�randomaccessfile銆�541
20.7.3銆�the file class銆�543
20.7.4銆�filenamefilter and filefi1ter銆�548
20.8銆�object serialization銆�549
20.8.1銆�the object byte streams銆�549
20.8.2銆�making your classes serializable銆�551
20.8.3銆�serialization and deserialization order銆�552
20 8 4銆�customized serialization銆�銆�554
20.8.5銆�object versioning.銆�555
20 8 6銆�serialized fields銆�559
20.8.7銆�the externalizable interface銆�561
20.8.8銆�documentation comment tags銆�562
20.9銆�the ioexception classes銆�563
20.10銆�a taste of new i/o銆�565

21銆�collections銆�567
21.1銆�collections銆�567
21.1.1銆�exception conventions銆�571
21.2銆�iteration銆�571
21.3銆�ordering with comparable and comparator銆�574
21.4銆�the collection interface銆�575
21.5銆�set and sortedset銆�577
21.5.1銆�hashset銆�579
21.5.2銆�linkedhashset銆�580
21.5.3銆�treeset銆�580
21.6銆�list銆�580
21.6.1銆�arraylist銆�582
21.6.2銆�linkedlist銆�583
21.6.3銆�randomaccess lists銆�584
21.7銆�queue銆�585
21.7.1銆�priorityqueue銆�586
21.8銆�map and sortedmap銆�587
21.8.1銆�hashnap銆�590
21.8.2銆�linkedhashmap銆�591
21.8.3銆�identityhashnap銆�592
21.8.4銆�weakhashnap銆�592
21.8.5銆�treemap銆�593
21.9銆�enum collections銆�594
21.9.1銆�enumset銆�594
21.9.2銆�enumnap銆�596
21.10銆�wrapped collections and the collections class銆�597
21.10.1銆�the collections utilities銆�597
21.10.2銆�the unmodifiable wrappers銆�601
21.10.3銆�the checked wrappers銆�601
21.11銆�synchronized wrappers and concurrent collections銆�602
21.11.1銆�the synchronized wrappers銆�602
21.11.2銆�the concurrent collections銆�604
21.12銆�the arrays utility class銆�607
21.13銆�writing iterator implementations銆�609
21.14銆�writing collection implementations銆�611
21.15銆�the legacy collection types銆�616
21.15.1銆�enumeration銆�617
21.15.2銆�vector銆�617
21.15.3銆�stack銆�619
21.15.4銆�dictionary銆�619
21.15.5銆�hashtable銆�619
21.16銆�properties銆�620

22銆�miscellaneous utilities銆�623
22.1銆�formatter銆�624
22.1.1銆�format specifiers銆�626
22.1.2銆�integer conversions銆�627
22.1.3銆�floating-point conversions銆�627
22.1.4銆�character conversions銆�629
22.1.5銆�general conversions銆�629
22.1.6銆�custom formatting銆�630
22.1.7銆�format exceptlons銆�630
22.1.8銆�the formatter class銆�631
22.2銆�bitset銆�632
22.3銆�observer/observable銆�635
22.4銆�random銆�639
22.5銆�scanner銆�641
22.5.1銆�stream of values銆�641
22.5.2銆�scanning lines銆�644
22.5.3銆�using scanner銆�647
22.5.4銆�localization銆�651
22.6銆�stringtokenizer銆�651
22.7銆�timer and timertask銆�653
22.8銆�uuid銆�656
22.9銆�math and strictmath銆�657

23銆�system programming銆�661
23.1銆�the system class銆�662
23.1.1銆�standard i/o streams銆�662
23.1.2銆�system properties銆�663
23.1.3銆�utility methods銆�665
23.2銆�creating processes銆�666
23.2.1銆�process銆�667
23.2.2銆�process environments銆�669
23.2.3銆�processbuilder銆�670
23.2.4銆�portability銆�672
23.3銆�shutdown銆�672
23.3.1銆�shutdown hooks銆�672
23.3.2銆�the shutdown sequence銆�674
23.3.3銆�shutdown strategies銆�674
23.4銆�the rest of runtime銆�675
23.4.1銆�loading native code銆�676
23.4.2銆�debugging銆�676
23.5銆�security銆�677
23.5.1銆�the securitymanager class銆�678
23.5.2銆�permissions銆�679
23 5 3銆�security policies銆�680
23.5.4銆�access controllers and privileged execution銆�681

24銆�internationalization and localization銆�685
24.1銆�locale銆�686
24.2銆�resource bundles銆�688
24.2.1銆�listresourcebundle銆�691
24.2.2銆�propertyresourcebundle銆�692
24.2.3銆�subclassing resourcebundle銆�693
24.3銆�currency銆�694
24.4銆�time, dates, and calendars銆�695
24.4.1銆�calendars銆�695
24 4 2銆�time zones銆�700
24.4,3銆�gregori ancal endar and si mpl eti mezone銆�701
24.5銆�formatting and parsing dates and times銆�703
24.5.1銆�using formatter with dates an times銆�706
24.6銆�internationalization and localization for text銆�708
24.6.1銆�collation銆�708
24.6.2銆�formatting and parsing銆�710
24 6 3銆�text boundaries銆�712

25銆�standard packages銆�715
25.1銆�java.awt锛峊he abstract window toolkit銆�717
25.2銆�java.applet锛岮pplets銆�720
25.3銆�java.beans锛岰omponents銆�721
25.4銆�java.math锛峂athematics銆�722
25.5銆�java.net锛峊he network銆�724
25.6銆�java.rmi锛峈emote method invocation銆�727
25.7銆�java.security and related packages锛峉ecurity tools銆�732
25.8銆�java.sql锛峈elational database access銆�732
25.9銆�utility subpackages銆�733
25.9.1銆�concurrency utilities锛岼ava.util.concurrent銆�733
25.9.2銆�archive files锛峧ava.util.jar銆�735
25.9.3銆�zip files锛峧ava.uti1.zip銆�736
25.10銆�javax.* 锛峉tandard extensions銆�737
25.11銆�javax.accessibility锛岮ccessibility for guis銆�737
25.12銆�javax.naming锛岲irectory and naming services銆�738
25.13銆�javax.sound锛峉ound manipulation銆�739
25.14銆�javax.swing锛峉wing gui components銆�740
25.15銆�org.omg.corba锛岰orba apis銆�740

a銆�application evolution銆�741
a.1銆�language, library, and virtual machine versions銆�741
a 2銆�dealing with multiple dialects銆�743
a.3銆�generics: reification, erasure, and raw types銆�744
a.3.1銆�raw types, 鈥淯nchecked鈥?warnings, and bridge methods銆�745
a.3.2銆�api issues銆�747

b銆�useful tables銆�749

further reading銆�755

index銆�761

.　　第16章“反射”描述了运行期类型内省机制，以及如何在运行时动态构建和操纵未知类型的对象。
　　第17章“垃圾收集与内存”叙述了垃圾收集、终结，以及低强度的引用对象。
　　第18章“包”描述了如何将类和接口分组到彼此互相分离的包中。
　　第19章“文档注释”展示了如何在注释中编写引用文档。
　　第20章到第24章覆盖了主要的包。第20章“I/O包”描述基于流的输入/输出系统。第21章“集合”覆盖了诸如集和列表这样的集合类也称容器类。第22章“其他工具”覆盖了诸如位集、格式化输出、文本扫描，以及随机数生成等其他的工具类。第23章“系统编程”将指引你去了解系统类，它们提供了对底层平台特性的访问。第24章“国际化和本地化”讨论了一些工具，它们可用于创建能运行在多种语言和文化环境中的程序。
　　第25章“标准包”简要探讨了作为标准平台一部分的包，对本书中未详细介绍的包做了简要概述。
　　附录A“应用演化”探讨了处理应用和Java平台不断演化时所涉及的问题，以及这些问题对某些新的语言特性的影响。
　　附录B“常用表格”把一些有用的信息以表格的形式列出，供读者速查。
　　最后，“进阶读物”列出了各种参考文献，帮助读者了解Java的完整细节、面向对象技术、多线程编程、软件设计等主题。
　　示例和文档
　　本书的所有示例代码都使用完稿时的Java语言最新版本（即JDK 1.5.0_02产品版本）进行过编译和运行。本书只涉及被支持的特性，过时的类型、方法和字段都被忽略了，除非必须用到它们，或者了解过去对于理解现有特性必不可少。我们讨论的问题不限于让程序能够通过编译而已，学习一门语言自然要学会如何用好它。因此，我们还努力向你展示良好的编程风格和设计原则。
　　我们在不少地方引用了在线文档。开发环境提供了一种从编译过的类中用它的文档注释自动生成文档（通常是HTML文档）的方式。这种文档通常是使用Web浏览器来阅读的。
　　致谢（第4版）
　　我们又一次需要对很多人表示感激，他们从自己忙碌的日程安排中抽出宝贵的时间，甚至不惜暂停写作自己的书，以他们的经验来帮我们完善本书，使其成为迄今为止最好的一个版本。当然，他们中的有些人提出的建议害得我们不得不去做大量的工作，以跟上语言和库的所有新特性，我们并不怪他们。
　　在审稿方面，我们首先要感谢柴田芳树。芳树是本书第3版日文版的翻译者，我们勘误表中至少85%的错误是他一人独立发现的。为了让第4版尽可能地减少错误，我们认识到需要让芳树尽早成为我们的复审者。于是，芳树成为了我们正式的复审人员，未经他首肯，我们不会把稿子拿出去做常规复审。他不仅对新增的内容进行纠错，提出了很有价值的反馈，而且还指出了多处Java语言已经发生变化而我们没有意识到的地方！
　　Brian Goetz也应该得到我们的特别感谢，不仅因为他复审了这一版的全部内容，而且有不少章节经过了他多次反复审阅。再次复审所给的时间非常紧迫，因此我们特别感谢Brian在特殊的关键时期给予我们的大力支持。
　　核心复审团队的其他人员还包括Beth Stearns和Kevin Davis，他们在漫长的过程中一直予以我们支持；Bob Withers、Herb Jellinek、Ken Louden、Rich Wardwell和Kevin Hammond对前半部分书稿也提供了很有价值的反馈意见。非常感谢你们。
　　我们还想感谢Tim Peierls，他提供了枚举那一章中的国际象棋的例子；还有Keith Lea 和Martin Buchholz，他们对泛型那部分材料进行了很有价值的复审。
　　毫无疑问，编写泛型这一章（以及附录中相关的部分）是这一版中最艰难的部分。由于手头最初只有《Java语言规范》（第3版）的草稿，所以要想深入探究新的类型系统是相当困难的，因此我们请来了大腕Neal Gafter、Josh Bloch、Gilad Bracha和Peter von der Ah幍热耍�他们很好地向我们讲授了泛型的知识，为此我们深深地感谢他们。Peter对泛型这一章做了细致的复审，特别有价值，因此我们要再多说一句感谢你。当然，教师不应因为学生的缺点而受到责备，因此在有关泛型的描述中出现的任何错误和遗漏都由我们自己承担全部责任。（我们还要感谢Phil Wadler，他在书临出版前在泛型的描述中及时地发现了两处遗漏。）
　　我们还要感谢下面的技术专家，他们在各自不同的领域对我们提供了帮助：Doug Lea复审了有关Java内存模型的材料，并且帮我们改进了并发集合的内容；Brian Goetz检查了并发集合的总结（还做了其他不少事情）；Mike“MadBot”McCloskey复审并协助我们改进了Scanner类及其相关正则表达式的用法的内容；Jeremy Manson则尝试着解释了终结与内存模型之间不易理解的深奥关系。
　　Rosemary Simpson总能在我们需要的时候出现。我一时想不出一句有创意的话来表达我们是何等欣赏她为本书做的索引，但是我可以肯定在第5版中我一定能够找到这样的赞美之词。
　　在制作方面，第4版的诞生颇费了些周折。起初，在第4版的酝酿阶段是Mike Hendrickson负责生产，之后转由Ann Sellers负责。Ann在Ebony Haight的协助下，经历了第4版早期的酝酿阶段，之后负责人又变为Greg Doench。Greg带领Noreen Regina、Stephane Nakib、Tyrrell Albaugh、Elizabeth Ryan和Mary Lou Nohr等人，帮助我们直至最终付梓。感谢你们所有人，以及所有的幕后人员。
　　还要感谢邻居Kathy Kerby、Ben Littauer以及Ariana Littauer一家，我们总是从他们家借用一些电脑小物件。有如此慷慨的芳邻是多么惬意的事情呀！
　　最后但绝非最不重要地，要感谢我们的家庭，他们再次忍受了我们这些写书人带给他们的考验。
　　致谢（第3版）
　　第3版仍然需要更多的复审工作，而提供帮助的人们非常尽责。Lisa Friendly继续努力使项目保持正轨，以后我们会合作得更好。复审队伍既有新面孔又有老朋友，但对我们的帮助是同样重要，他们是Joshua Bloch、Joseph Bowbeer、Gilad Bracha、Keith Edwards、Joshua Engel、Rich Gillam、Peter Haggar、Cay Horstmann、Alexander Kuzmin、Doug Lea、 Keith Lea、Tim Lindholm、David Mendenhall、Andrew M. Morgan、Ray Ortigas、Brian Preston、Mark Schuldenfrei、Peter Sparago、Guy Steele、Antoine Trux，以及我们的俄罗斯朋友们Leonid Arbouzov、Valery Shakurov、Viatcheslav Rybalov、Eugene Latkin、Dmitri Khukhro、Konstantin Anisimov、Alexei Kaigorodov、Oleg Oleinik和Maxim Sokolnikov。我们洗耳恭听了Peter Jones、Robert W. Scheifler、Susan Snyder、Guy Steele、Jimmy Torres和Ann Wollrath的意见，努力把书中问题阐述得更清楚。Helen Leary一如既往地将后勤保障工作做得很好。
　　Addison-Wesley团队一直在提供写作资料方面的支持，他们是Julie DiNicola、Mike Hendrickson和Tracy Russ.
　　在上一版问世前，Peet咖啡茶餐馆在东海岸开张营业，所以本书住在东部的作者可以定期地享受其美味。这个世界在不断地进步啊。
　　致谢（第2版）
　　第2版要感谢的人和第1版基本一样。
　　丛书编辑Lisa Friendly继续坚定地体现了支持和关心。复审队伍人数有所减少，与第1版有些人员重复，但给予我们的帮助和全心投入是相同的。Steve Byrne、Tom Cargill、Mary Dageforde、Tim Lindholm和Rob Murray对全书进行了通审，对于保证本书表述清晰来说是至关重要的。Brian Beck、Peter Jones、Doug Lea、Bryan O誗ullivan、Sue Palmer、Rosanna Lee、Lori Park、Mark Reinhold、Roger Riggs、Ann Wollrath和Ken Zadek重点复审了本书的重要章节。Guy Steele的支持是一贯而热忱的。Rosemary Simpson为制作本书的索引进行了紧张的工作，付出了巨大的努力，为此我们表示深切的感谢。Carla Carlson和Helen Leary给予了后勤支持，使所有工作都得以顺利进行。Gerry Wiener提供了第550页上的中国藏族文字，Craig Preston和Takao Miyatani也提供了这方面的帮助。所有提交第1版的勘误和建议的人都对我们帮助很大。
　　由于某些无法解释的原因，我们在第1版的致谢中遗漏了来自Addison-Wesley的朋友们—幸亏他们中的大多数又都出现在了这一版中。这两版中来自Addison-Wesley的朋友包括Kate Duffy、Rosa Gonzales、Mike Hendrickson、Marina Lang、Shannon Patti、Marty Rabinowitz、Sarah Weaver和Pamela Yee。我们可能遗漏了一些付出很多的人，但是对他们我们同样致以诚挚的谢意。
　　修订版还得到了Josh Bloch、Joe Fialli、Jimmy Torres、Benjamin Renaud、Mark Reinhold、Jen Volpe和Ann Wollrath的帮助。
　　Peet 咖啡茶餐馆一直是我们这些咖啡因饮料“鉴赏家”的赞助商。
　　致谢（第1版）
　　任何科技书籍的写作都不是一座无援的孤岛，而我们这本书的写作更像一块紧密相连的大陆。许多人都提供了技术帮助、高水平的复审、极为有用的信息和书籍写作的建议。
　　Trilithon Software公司的编辑Henry McGilton所起的作用就像是“首席编辑救火官”，他的帮助使本书的出版成为现实。丛书编辑Lisa Friendly坚定地为我们提供了支持与帮助。
　　许多称职的复审者忙里偷闲对本书的相关材料进行了阅读、编辑、建议、修订和删除，所有这一切都为了使本书更加完美。Kevin Coyle堪称本书最细致的编辑复审者。Karen Bennet、Mike Burati、Patricia Giencke、Steve Gilliard、Bill Joy、Rosanna Lee、Jon Madison、Brian O誑eill、Sue Palmer、Stephen Perelgut、R. Anders Schneiderman、Susan Sim、Bob Sproull、Guy Steele、Arthur van Hoff、Jim Waldo、Greg Wilson和Ann Wollrath 都提供了深入的复审。Geoff Arnold、Tom Cargill、Chris Darke、Pat Finnegan、Mick Jordan、Doug Lea、Randall Murray、Roger Riggs、Jimmy Torres、Arthur van Hoff和Frank Yellin在关键环节上提供了有价值的评论和技术信息。
　　Alka Deshpande、Sharon Flank、Nassim Fotouhi、Betsy Halstead、Kee Hinckley、Dr. K. Kalyanasundaram、Patrick Martin、Paul Romagna、Susan Snyder和Nicole Yankelovich 通力合作创造了第164页和第550页的五个非ISO-Latin-1文本的单词。Jim Arnold提供了关于“smoog”和“moorge”的正确拼写、用法和词源方面的研究。Ed Mooney 帮助我们准备了文档。Herb和Joy Kaiser是我们的克罗地亚语顾问。Cookie Callahan、Robert E. Pierce和Rita Tavilla 提供了必要的帮助，使得本项目在很多时候得以继续进行，否则我们将会停滞不前。
　　感谢Kim Polese，他给我们总结了为什么Java编程语言对计算机用户和程序员同等重要。
　　Susan Jones、Bob Sproull、Jim Waldo和Ann Wollrath在关键时刻提供了支持和建议。我们还要感谢我们的家人，他们除了用亲情支持我们写书之外，还经常使我们劳逸结合，张弛有度，为此我们要深深地感谢他们。
　　还要感谢Peet咖啡茶餐馆的朋友们，他们让我们品尝到了这个星球上最好的咖啡。
　　尽管所有人员都做出了不懈的努力，本书中难免还会存在错误和缺陷，全部责任都由作者承担。...
　　是结果！朋友，我已经取得了大量的结果，
　　我已知道有好几千种方法是行不通的。
　　托马斯·爱迪生