Java編程思想第4版（評註版）

《Java編程思想第4版（評註版）》是2011年電子工業出版社出版的圖書。作者是埃克爾，劉中兵評註。《Java編程思想(評註版第4版)》是“傳世經典書叢”之一，作者擁有多年教學經驗，對C、C++以及Java語言都有獨到、深入的見解，書中以通俗易懂且小而直接的示例闡釋了一個個晦澀抽象的概念，是一本當之無愧的經典之作，書中包括基本語法、面向對象、高級特性等五部分內容。本書適合從事相關研究工作的人員參考閱讀。

基本介紹

• 書名：Java編程思想第4版（評註版）
• 作者：（美）埃克爾（Eckel, B.）、劉中兵
• ISBN：978-7-121-13521-7
• 頁數：756頁
• 定價：108.00元
• 出版社：電子工業出版社
• 出版時間：2011年6月
• 開本：16開

內 容 簡 介

本書作者擁有多年教學經驗，對C、C++以及Java語言都有獨到、深入的見解，書中以通俗易懂且小而直接的示例闡釋了一個個晦澀抽象的概念，是一本當之無愧的經典之作。本評註版講解了Java設計、語法和庫的各個方面，包括Java的運算符、控制邏輯、構造、回收、重用、接口、內部類、存儲、異常、字元串、類型、泛型、數組、容器、I/O、注釋、並發等內容。

對於國外技術圖書，選擇翻譯版還是影印版，常常讓人陷入兩難的境地。本評註版力邀國內資深專家執筆，在英文原著基礎上增加中文點評與注釋，旨在融合二者之長，既保留經典的原創文字與味道，又以先行者的學研心得與實踐感悟，對讀者閱讀與學習加以點撥、指明捷徑。

經過評註的版本，更值得反覆閱讀與體會。希望這本書能夠幫助您跨越Java的重重險阻，領略高處才有的壯美風光，做一個成功而快樂的Java程式設計師。

評註者序

與Thinking in Java的淵源

學習Java的道路好比西天取經，Java就是要取得的真經，我們都是去往Java之路的聖徒。

學習Java不僅要經歷九九八十一難，更要理解Java這本聖經的精髓。大家都覺得Java之路不好走，因為它不僅僅是Java，還有無數的技術，如JSP、Servlet、JavaBean、J2EE、Struts、Spring、Hibernate、資料庫SQL、SOA分散式、快取、JVM、Eclipse、Tomcat、HTTP、JSON等等，它們組成了取經道路上的九九八十一難。眾多技術，圍繞的精髓是Java。

在學習Java的道路上，我也經歷過九九八十一難。我通過編寫《Java高手真經》對Java道路上的層層技術做了一個自認為完整的總結，也是對自己步入Java世界以來的種種所見所聞所感的記錄和升華。但此時，對Java我有種被掏空的感覺。因為，我覺得自己對Java的精髓理解得還是不夠。

偶然的機會接到博文視點的邀約，為這本《Java編程思想》（Thinking in Java）的英文版本做點評。儘管我寫過很多技術類的書，但對於這種聖經式的經典著作，借用時下最流行的一句話，內心有一點“忐忑”。因為，對經典著作做的點評，必須是點睛之筆，對原文要能夠畫龍點睛。想到這裡，內心就更加忐忑了！為此，我抱著學習交流的心態重讀了這本書。

剛學習Java時，往往會經資深人士推薦說：“讀這本《Java編程思想》才是學真正的Java，國人所著太淺！”於是懷著崇拜之情，讀之，傻眼，1000多頁、大量本質的分析，再加上蹩腳的英語，讀之皮毛矣！從此也就束之高閣。

何時應該讀這本書

李彥宏關於網際網路的發展曾說過：“時機很重要，進去太早會餓死，太晚就沒有機會了。”實際上這句話在這裡也適用，太早讀這本書會難以理解，太晚你會後悔為什麼才看到這本書。這是因為，正如書名所言，它講解的是Java編程的內在思想，只有擁有了一定Java編程基礎和開發經驗後，讀它才是對Java理解的升華！

因此，這本書最大的作用不是讓你“知其然”，而是讓你“知其所以然”！

如何讀這本書

本書原英文版涵蓋了Java設計、語法和庫的各個方面，包括Java的運算符、控制邏輯、構造、回收、重用、多態、接口、內部類、存儲、異常、字元串、類型、泛型、數組、容器、I/O、注釋、並發、圖形GUI。原英文版是按美國人的習慣散列排列的，本書為了更加一目了然，更加符合國人的思維方式，將這些章節分為五個大的部分，每一部分都涵蓋了深入分析的獨家內容。

第1部分 基本語法：運算符、控制邏輯

運算符和控制邏輯是任何一門語言的最基礎語法，Java參考了C++的優點，揚長避短，因此它的運算符也基於C++，但在某些方面進行了簡化和改進。熟悉C++將會對本部分輕車熟路。Java中的控制語句共提供了如下幾個關鍵字：if/else/while/do-while/for/return/break/continue/switch。雖然有goto，但是不要使用，它會使代碼混亂。在Java中已經摒棄了goto語句。

第2部分 面向對象：對象的創建與銷毀、訪問控制、重用、接口、內部類、異常

本書是關於類的初始化和銷毀講解最為完美的一本書，細緻、全面、易懂。訪問控制專門開闢了一章，對於類和包的訪問控制關係講解小巧到位。要讓每個人編寫的程式能夠為他人所用，首先是類的包結構清晰，其次是代碼中的函式包裝清晰。

第3部分 數據存儲：字元串、數組、存儲、容器

java.util包中提供了紛繁複雜的容器類，包括集合類Collection（包括Queue先進先出佇列、List允許重複的有序列表、Set不允許重複的集合）和映射類Map（鍵值對）。本書深度分析了基於這些接口的各種實現類的使用、工作原理。“Containers in Depth”一章是講解Java容器類最深入的部分，它會告訴你何時應該使用哪些容器、哪些是最有用的、為什麼使用以及怎么使用。

第4部分 核心功能：輸入輸出、並發

I/O提供了Java與外部系統進行通信的基礎庫，包括控制台、檔案、網路。這些是I/O需要涉及的方方面面。輸入輸出的方式包括順序讀取、隨機讀取、快取、二進制、字元、行讀取、位元組讀取等等，因此I/O也提供了各種讀寫的包裝類。本書通過大量實例來演示這些類的使用方法和套用場景。

多執行緒是與單執行緒比較而言的，本書從基本的Thread、Runnable的使用講起，深入且全面講解了執行緒的休眠、優先權、Daemon、執行緒的異常處理、資源共享、執行緒的控制、與其他執行緒的協作、死鎖等，並講解了Java中使用的一些執行緒工具類。

第5部分 高級特性：類型、泛型、枚舉、注釋

書中從Class類、cast、靜態分析、動態分析、動態代理、Mock等各方面講解類的RTTI解析，使用Generic實現對Java的擴展。JDK 5.0通過名為注釋（Annotation）的新功能，將一個更通用的元數據工具合併到核心Java語言中。對於開發者來說，不僅可以使用JDK內置的注釋，還可以使用第三方提供的強大注釋功能，比如單元測試、EJB、Hibernate等，還可以自定義注釋。

我的建議

由於AWT和Swing目前在實際套用中比例不高，並且擅長界面編程的中文圖書比比皆是，因此就刪除了圖形化編程GUI一章。另外，本書開頭的兩章，即“Introduction to Objects”和“Everything Is an Object”沒有收入本書。

還請讀者留意以下兩點：

（1）由於本評註版經重新編排，章節順序與原著不盡相同，加之部分章節有所節略，因此書中涉及引用章節之處與圖書現狀略有出入。由此給讀者帶來的不便，還請諒解。

（2）各章練習序號後的小括弧中的文字，代表本練習的難度等級（用1~10表示）。

最後，在您閱讀本書時，我有兩點建議：

 對經典的分析、代碼及時做批註，多做對比和總結。

 上機編寫運行書中的經典實例，嘗試不同的運行結果，分析代碼的用意。

 對書中的實例舉一反三、反覆推敲，分析更多的實際套用場景。

只有用心去讀、去體會、去實踐，才能夠真正理解Java編程中的思想。

本評註版由劉中兵、陳景春、周同、劉中敏、陳萬珍、劉劍、李瑞霞、李建海、李金剛、劉中麗執筆，撰寫相關中文評註。行文若有不妥之處，敬請廣大讀者提出寶貴意見和建議。

劉中兵

2011年4月20日於北京

目 錄

第1部分 基本語法

Operators（新增批註30條） 1

Simpler print statements 1

Using Java operators 2

Precedence 2

Assignment 3

Mathematical operators 4

Unary minus and plus operators 6

Auto increment and decrement 6

Relational operators 7

Testing object equivalence 7

Logical operators 9

Literals 10

Exponential notation 11

Bitwise operators 12

Shift operators 13

Ternary if-else operator 16

String operator + and += 17

Common pitfalls when using

operators 18

Casting operators 18

Truncation and rounding 19

Promotion 20

Java has no “sizeof ” 20

Summary 20

Controlling Execution

（新增批註21條） 21

true and false 21

if-else 21

Iteration 22

do-while 23

for 23

The comma operator 24

Foreach syntax 25

return 27

break and continue 27

The infamous “goto” 29

switch 32

Summary 34

第2部分 面向對象

Initialization & Cleanup

（新增批註55條） 35

Guaranteed initialization with

the constructor 35

Method overloading 37

Distinguishing overloaded

methods 39

Overloading with primitives 39

Overloading on return values 42

Default constructors 43

The this keyword 44

Calling constructors from

constructors 46

The meaning of static 47

Cleanup: finalization and

garbage collection 47

What is finalize() for? 48

You must perform cleanup 49

The termination condition 50

How a garbage collector works 51

Member initialization 54

Specifying initialization 55

Constructor initialization 56

Order of initialization 56

static data initialization 57

Explicit static initialization 59

Non-static instance initialization 61

Array initialization 62

Variable argument lists 65

Enumerated types 70

Summary 72

Access Control

（新增批註21條） 73

package: the library unit 74

Code organization 75

Creating unique package names 76

A custom tool library 79

Java access specifiers 80

Package access 80

public: interface access 81

private: you can’t touch that! 82

protected: inheritance access 83

Interface and implementation 85

Class access 86

Summary 87

Reusing Classes

（新增批註35條） 89

Composition syntax 89

Inheritance syntax 92

Initializing the base class 94

Delegation 96

Combining composition and

inheritance 97

Guaranteeing proper cleanup 99

Name hiding 101

Choosing composition vs.

inheritance 103

protected 104

Upcasting 105

Why “upcasting”? 106

Composition vs. inheritance

revisited 106

The final keyword 107

final data 107

final methods 110

final classes 112

final caution 113

Initialization and class

loading 113

Initialization with inheritance 114

Summary 115

Interfaces

（新增批註16條） 117

Abstract classes and methods 117

Interfaces 120

“Multiple inheritance” in Java 123

Extending an interface with

inheritance 125

Name collisions when combining

interfaces 127

Fields in interfaces 127

Initializing fields in interfaces 128

Interfaces and factories 129

Summary 130

Inner Classes

（新增批註32條） 131

Creating inner classes 131

The link to the outer class 133

Using .this and .new 134

Inner classes and upcasting 135

Anonymous inner classes 137

Factory Method revisited 140

Nested classes 142

Classes inside interfaces 143

Reaching outward from a

multiply nested class 145

Why inner classes? 145

Closures & callbacks 148

Inheriting from inner classes 150

Can inner classes be

overridden? 150

Local inner classes 152

Inner-class identifiers 153

Summary 154

Error Handling with Excep- tions（新增批註52條） 155

Basic exceptions 155

Exception arguments 156

Catching an exception 157

The try block 157

Exception handlers . 157

Creating your own

exceptions 159

Exceptions and logging 161

The exception specification 164

Catching any exception 164

The stack trace 166

Rethrowing an exception 167

Exception chaining 169

Standard Java exceptions 172

Special case: RuntimeException 172

Performing cleanup with

finally 174

What’s finally for? 175

Using finally during return 177

Pitfall: the lost exception 178

Exception restrictions 180

Constructors 182

Exception matching 187

Alternative approaches 188

Passing exceptions to the console 189

Summary 189

第3部分 數據存儲

Strings（新增批註53條） 191

Immutable Strings 191

Overloading ‘+’ vs.

StringBuilder 192

Unintended recursion 195

Operations on Strings 196

Formatting output 199

printf() 199

System.out.format() 199

The Formatter class 200

Format specifiers 200

Formatter conversions 202

String.format() 204

Regular expressions 205

Basics 206

Creating regular expressions 208

Quantifiers 210

Pattern and Matcher 211

split() 218

Replace operations 218

reset() 220

Regular expressions and Java I/O 221

Scanning input 222

Scanner delimiters 224

Scanning with regular

expressions 225

StringTokenizer 225

Summary 226

Arrays（新增批註36條） 227

Why arrays are special 227

Arrays are first-class objects 228

Returning an array 231

Multidimensional arrays 232

Arrays and generics 235

Creating test data 237

Arrays.fill() 238

Data Generators 239

Arrays utilities 243

Copying an array 243

Comparing arrays 244

Array element comparisons 245

Sorting an array 248

Searching a sorted array 249

Summary 251

Holding Your Objects

（新增批註35條） 253

Generics and type-safe

containers 254

Basic concepts 256

Adding groups of elements 258

Printing containers 259

List 261

Iterator 263

ListIterator 266

LinkedList 267

Stack 268

Set 270

Map 273

Queue 276

PriorityQueue 277

Collection vs. Iterator 279

Foreach and iterators 281

The Adapter Method idiom 283

Summary 286

Containers in Depth

（新增批註102條） 289

Full container taxonomy 289

Filling containers 290

A Generator solution 291

Map generators 292

Collection functionality 294

Optional operations 297

Unsupported operations 298

List functionality 300

Sets and storage order 302

SortedSet 306

Queues 307

Priority queues 308

Deques 309

Understanding Maps 310

Performance 311

SortedMap 314

LinkedHashMap 315

Hashing and hash codes 316

Understanding hashCode() 319

Hashing for speed 321

Overriding hashCode() 324

Choosing an implementation 329

A performance test framework 330

Choosing between Lists 333

Microbenchmarking dangers 338

Choosing between Sets 339

Choosing between Maps 341

Utilities 344

Sorting and searching Lists 347

Making a Collection or Map

unmodifiable 349

Synchronizing a Collection or

Map 350

Holding references 351

The WeakHashMap 353

Java 1.0/1.1 containers 355

Vector & Enumeration 355

Hashtable 356

Stack 356

BitSet 357

Summary 359

第4部分 核心功能

I/O（新增批註89條） 361

The File class 361

A directory lister 361

Directory utilities 364

Checking for and creating

directories 369

Input and output 370

Types of InputStream 371

Types of OutputStream 372

Adding attributes and useful

interfaces 373

Reading from an InputStream

with FilterInputStream 374

Writing to an OutputStream

with FilterOutputStream 375

Readers & Writers 376

Sources and sinks of data 377

Modifying stream behavior 377

Unchanged classes 378

Off by itself:

RandomAccessFile 379

Typical uses of I/O streams 379

Buffered input file 379

Input from memory 380

Formatted memory input 381

Basic file output 382

Storing and recovering data 383

Reading and writing

random-access files 385

Piped streams 386

File reading &

writing utilities 386

Reading binary files 389

Standard I/O 389

Reading from standard input 389

Changing System.out to a

PrintWriter 390

Redirecting standard I/O 391

Process control 391

New I/O 393

Converting data 396

Fetching primitives 398

View buffers 399

Data manipulation with buffers 403

Buffer details 404

Memory-mapped files 406

File locking 409

Compression 411

Simple compression with GZIP 412

Multifile storage with Zip 413

Java ARchives (JARs) 415

Object serialization 416

Finding the class 419

Controlling serialization 420

Using persistence 427

XML 432

Summary 434

Concurrency

（新增批註117條） 435

Basic threading 435

Defining tasks 435

The Thread class 436

Using Executors 438

Producing return values from

tasks 440

Sleeping 442

Priority 443

Yielding 444

Daemon threads 445

Coding variations 446

Joining a thread 450

Catching exceptions 451

Sharing resources 454

Resolving shared resource

contention 454

Atomicity and volatility 457

Atomic classes 460

Critical sections 462

Synchronizing on other objects 462

Thread local storage 463

Terminating tasks 464

The ornamental garden 465

Terminating when blocked 467

Interruption 469

Cooperation between tasks 475

wait() and notifyAll() 475

notify() vs. notifyAll() 479

Producers and consumers 482

Producer-consumers and queues 486

Using pipes for I/O between tasks 491

Deadlock 492

New library components 497

CountDownLatch 497

CyclicBarrier 499

DelayQueue 501

PriorityBlockingQueue 503

The greenhouse controller with

ScheduledExecutor 505

Semaphore 508

Exchanger 511

Simulation 513

Bank teller simulation 513

The restaurant simulation 517

Distributing work 521

Performance tuning 526

Comparing mutex technologies 526

Lock-free containers 532

ReadWriteLocks 533

Active objects 535

Summary 537

第5部分 高級特性

Type Information

（新增批註59條） 539

The need for RTTI 539

The Class object 541

Class literals 545

Generic class references 547

New cast syntax 549

Checking before a cast 550

Using class literals 555

A dynamic instanceof 557

Counting recursively 558

Registered factories 559

instanceof vs. Class

equivalence 562

Reflection: runtime class

information 563

A class method extractor 564

Dynamic proxies 566

Null Objects 570

Mock Objects & Stubs 575

Interfaces and type

information 576

Summary 580

Generics

（新增批註126條） 583

Comparison with C++ 584

Simple generics 584

A tuple library 586

A stack class 588

RandomList 589

Generic interfaces 590

Generic methods 593

Leveraging type argument

inference 594

Varargs and generic methods 596

A generic method to use with

Generators 596

A general-purpose Generator 597

Simplifying tuple use 598

A Set utility 600

Anonymous inner classes 603

Building complex models 604

The mystery of erasure 606

The C++ approach 607

Migration compatibility 609

The problem with erasure 611

The action at the boundaries 612

Compensating for erasure 615

Creating instances of types 616

Arrays of generics 618

Bounds 622

Wildcards 625

How smart is the compiler? 628

Contravariance 629

Unbounded wildcards 632

Capture conversion 636

Issues 637

No primitives as type parameters 637

Implementing parameterized

interfaces 639

Casting and warnings 640

Overloading 641

Base class hijacks an interface 642

Self-bounded types 642

Curiously-recurring generics 643

Self-bounding 644

Argument covariance 646

Dynamic type safety 649

Exceptions 650

Mixins 651

Mixins in C++ 651

Mixing with interfaces 653

Using the Decorator pattern 654

Mixins with dynamic proxies 655

Latent typing 657

Compensating for the lack of

latent typing 660

Reflection 661

Applying a method to a sequence 662

When you don’t happen

to have the right interface 664

Simulating latent typing

with adapters 665

Using function objects as

strategies 668

Summary: Is casting really

so bad? 672

Enumerated Types

（新增批註55條） 675

Basic enum features 675

Using static imports with enums 676

Adding methods to an enum 677

Overriding enum methods 678

enums in switch statements 678

The mystery of values() 679

Implements, not inherits 681

Random selection 682

Using interfaces for

organization 683

Using EnumSet instead of

flags 686

Using EnumMap 688

Constant-specific methods 689

Chain of Responsibility with

enums 692

State machines with enums 695

Multiple dispatching 700

Dispatching with enums 702

Using constant-specific methods 704

Dispatching with EnumMaps 705

Using a 2-D array 706

Summary 707

Annotations

（新增批註51條） 709

Basic syntax 710

Defining annotations 710

Meta-annotations 712

Writing annotation processors 712

Annotation elements 713

Default value constraints 713

Generating external files 714

Annotations don’t

support inheritance 717

Implementing the processor 717

Using apt to process

annotations 719

Using the Visitor pattern with

apt 723

Annotation-based unit testing 726

Using @Unit with generics 733

No “suites” necessary 735

Implementing @Unit 735

Removing test code 741

Sum