preface xviii
acknowledgements xxiv
chapter 1 an introduction to java（新增批注共25条） 1
java as a programming platform 2
the java “white paper” buzzwords 3
simple 3
object oriented 4
network-savvy 5
robust 5
secure 6
architecture neutral 7
portable 8
interpreted 9
high performance 9
multithreaded 10
dynamic 10
java applets and the internet 11
a short history of java 12
common misconceptions about java 15
.chapter 2 the java programming environment
（新增批注共20条） 21
installing the java development kit 22
downloading the jdk 22
setting the execution path 26
installing the library source and documentation 28
installing the core java program examples 28
navigating the java directories 29
choosing a development environment 32
using the command-line tools 33
troubleshooting hints 43
using an integrated development environment 45
locating compilation errors 49
running a graphical application 55
building and running applets 58
chapter 3 fundamental programming structures in java
（新增批注共44条） 63
a simple java program 64
comments 68
data types 70
integer types 70
floating-point types 71
the char type 72
the boolean type 74
variables 74
initializing variables 76
constants 76
operators 77
increment and decrement operators 78
relational and boolean operators 79
bitwise operators 81
mathematical functions and constants 81
conversions between numeric types 83
casts 84
parentheses and operator hierarchy 84
enumerated types 85
strings 86
substrings 86
concatenation 86
strings are immutable 87
testing strings for equality 88
code points and code units 89
the string api 90
reading the on-line api documentation 92
building strings 95
input and output 96
reading input 96
formatting output 98
file input and output 103
control flow 105
block scope 105
conditional statements 106
loops 109
determinate loops 113
multiple selections—the switch statement 117
statements that break control flow 119
big numbers 122
arrays 124
the “for each” loop 125
array initializers and anonymous arrays 126
array copying 126
command-line parameters 128
array sorting 129
multidimensional arrays 132
ragged arrays 135
chapter 4 objects and classes（新增批注共55条） 139
introduction to object-oriented programming 140
classes 142
objects 143
identifying classes 143
relationships between classes 144
using predefined classes 146
objects and object variables 146
the gregoriancalendar class of the java library 150
mutator and accessor methods 152
defining your own classes 158
an employee class 158
use of multiple source files 162
dissecting the employee class 163
first steps with constructors 164
implicit and explicit parameters 166
benefits of encapsulation 167
class-based access privileges 170
private methods 171
final instance fields 171
static fields and methods 172
static fields 172
static constants 173
static methods 174
factory methods 175
the main method 175
method parameters 178
object construction 185
overloading 185
default field initialization 185
default constructors 186
explicit field initialization 187
parameter names 188
calling another constructor 188
initialization blocks 189
object destruction and the finalize method 193
packages 194
class importation 195
static imports 196
addition of a class into a package 197
package scope 200
the class path 201
setting the class path 203
documentation comments 204
comment insertion 204
class comments 205
method comments 205
field comments 206
general comments 206
package and overview comments 207
comment extraction 207
class design hints 208
chapter 5 inheritance（新增批注共42条） 213
classes, superclasses, and subclasses 214
inheritance hierarchies 222
polymorphism 222
dynamic binding 224
preventing inheritance: final classes and methods 226
casting 227
abstract classes 229
protected access 234
object: the cosmic superclass 235
the equals method 236
equality testing and inheritance 238
the hashcode method 240
the tostring method 243
generic array lists 248
accessing array list elements 250
compatibility between typed and raw array lists 254
object wrappers and autoboxing 256
methods with a variable number of parameters 259
enumeration classes 260
reflection 263
the class class 263
a primer on catching exceptions 266
using reflection to analyze the capabilities of classes 268
using reflection to analyze objects at runtime 273
using reflection to write generic array code 277
method pointers! 281
design hints for inheritance 284
chapter 6 interfaces and inner classes（新增批注共24条） 289
interfaces 290
properties of interfaces 296
interfaces and abstract classes 297
object cloning 298
interfaces and callbacks 305
inner classes 307
use of an inner class to access object state 309
special syntax rules for inner classes 312
are inner classes useful? actually necessary? secure? 313
local inner classes 316
accessing final variables from outer methods 316
anonymous inner classes 319
static inner classes 322
proxies 325
properties of proxy classes 333
chapter 7 exceptions, logging, assertions, and debugging
（新增批注共38条） 335
dealing with errors 336
the classification of exceptions 338
declaring checked exceptions 340
how to throw an exception 342
creating exception classes 343
catching exceptions 344
catching multiple exceptions 346
rethrowing and chaining exceptions 348
the finally clause 349
analyzing stack trace elements 352
tips for using exceptions 357
using assertions 361
assertion enabling and disabling 361
using assertions for parameter checking 362
using assertions for documenting assumptions 363
logging 364
basic logging 364
advanced logging 365
changing the log manager configuration 367
localization 368
handlers 369
filters 373
formatters 373
a logging recipe 373
debugging tips 381
using a console window 387
tracing awt events 389
letting the awt robot do the work 393
using a debugger 396
chapter 8 generic programming（新增批注共22条） 401
why generic programming? 402
who wants to be a generic programmer? 403
definition of a simple generic class 404
generic methods 406
bounds for type variables 407
generic code and the virtual machine 409
translating generic expressions 411
translating generic methods 411
calling legacy code 413
restrictions and limitations 414
type parameters cannot be instantiated with primitive types 414
runtime type inquiry only works with raw types 415
you cannot throw or catch instances of a generic class 415
arrays of parameterized types are not legal 416
you cannot instantiate type variables 416
type variables are not valid in static contexts of generic classes 418
beware of clashes after erasure 418
inheritance rules for generic types 419
wildcard types 421
supertype bounds for wildcards 423
unbounded wildcards 424
wildcard capture 425
reflection and generics 430
using class[t] parameters for type matching 431
generic type information in the virtual machine 431
chapter 9 collections（新增批注共55条） 437
collection interfaces 438
separating collection interfaces and implementation 439
collection and iterator interfaces in the java library 441
concrete collections 447
linked lists 448
array lists 459
hash sets 459
tree sets 463
object comparison 464
queues and deques 469
priority queues 471
maps 472
specialized set and map classes 476
the collections framework 481
views and wrappers 487
bulk operations 493
converting between collections and arrays 494
algorithms 494
sorting and shuffling 496
binary search 498
simple algorithms 499
writing your own algorithms 500
legacy collections 502
the hashtable class 502
enumerations 502
property maps 503
stacks 504
bit sets 504
chapter 10 multithreading（新增批注共24条） 509
what are threads? 511
using threads to give other tasks a chance 517
interrupting threads 524
thread states 528
new threads 529
runnable threads 529
blocked and waiting threads 530
terminated threads 530
thread properties 531
thread priorities 531
daemon threads 533
handlers for uncaught exceptions 534
synchronization 535
an example of a race condition 536
the race condition explained 540
lock objects 541
condition objects 544
the synchronized keyword 549
synchronized blocks 553
the monitor concept 554
volatile fields 555
deadlocks 556
lock testing and timeouts 559
read/write locks 560
why the stop and suspend methods are deprecated 561
blocking queues 563
thread-safe collections 570
efficient maps, sets, and queues 570
copy on write arrays 572
older thread-safe collections 572
callables and futures 573
executors 577
thread pools 578
scheduled execution 582
controlling groups of tasks 583
synchronizers 584
semaphores 585
countdown latches 585
barriers 585
exchangers 586
synchronous queues 586
example: pausing and resuming an animation 586
threads and swing 592
running time-consuming tasks 594
using the swing worker 598
the single-thread rule 604
index 607
· · · · · · (
收起)
