Core JavaTM.Volume Ⅰ,Fundamentals

《java核心技术:卷ⅰ:基础知识:第8版(评注版)》

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