首页  |  知识库  |  资源下载  |  在线工具  |  A-Z  •  JAR  •  名词查         

《Thinking in Java 4th Edition》PDF英文版本下载

标签:Thinking in Java 4th Edition,Preface,Introduction,Operators,Polymorphism,Strings,Generics,Annotations,Concurrency,Index     发布时间:2017-11-23   

一、目录介绍

Thinking in Java 4th Edition.jpg

Preface 1
Java SE5 and SE6         2
Java SE6                       2
The 4th edition               2
Changes                       3
Note on the cover design        . 4
Acknowledgements                 4
Introduction 9
Prerequisites                 9
Learning Java                10
Goals               . 10
Teaching from this book        . 11
JDK HTMLdocumentation          11
Exercises                      . 12
Foundations for Java                12
Source code                . 12
Coding standards               . 14
Errors                14
Introduction to Objects 15
The progressof abstraction                15
An object has
an interface                . 17
An object
provides services        . 18
The hidden
implementation          19
Reusing the
implementation        . 20
Inheritance                21
Is-a vs. is-like-a relationships        24
Interchangeable objectswith polymorphism               . 25
The singly rootedhierarchy                       28
Containers                 28
Parameterized types (Generics)  29
Object creation & lifetime  . 30
Exception handling:dealing with errors                . 31
Concurrent programming  . 32
Java and the Internet          33
What is the Web?               . 33
Client-side programming                34
Server-side programming                38
Summary                       38
Everything Is an Object 41
You manipulate objectswith references         . 41
You must create
all the objects                42
Where storage lives          42
Special case: primitive types        . 43
Arrays in Java                       44
You never need todestroy an object         45
Scoping                 45
Scope of objects                . 46
Creating new data types:class               . 46
Fields and methods         . 47
Methods, arguments,and return values                       48
The argument list               . 49
Building a Java program         50
Name visibility                       50
Using other components               . 50
The static keyword         . 51
Your first Java program        . 52
Compiling and running                . 54
Comments and embedded documentation         . 55
Comment documentation                55
Syntax                       56
Embedded HTML                56
Some example tags          57
Documentation example               . 59
Coding style                 60
Summary                       60
Exercises                       60
Operators 63 Simpler print statements         63
Using Java operators                64
Precedence                . 64
Assignment                 65
Aliasing during method calls        . 66
Mathematical operators       . 67
Unary minusand plus operators                68
Auto increment and
decrement                 69 Relational operators                70
Testing object equivalence                70
Logical operators         71
Short-circuiting                 72
Literals                        73
Exponential notation        . 74
Bitwise operators         75
Shift operators         76
Ternary if-else operator        79
String operator+ and +=                       80
Common pitfallswhen using operators                81
Casting operators         81
Truncation and rounding                82
Promotion                              83
Java has no “sizeof”               . 83
A compendiumof operators                 84
Summary                      . 91
Controlling Execution 93 true and false        . 93
if-else                        93
Iteration                      . 94
do-while               . 95
for                              95
The comma operator       . 96
Foreach syntax         97
return                       . 99
break and continue          99
The infamous “goto”                101
switch                       104
Summary                 106
Initialization & Cleanup 107 Guaranteed initializationwith the constructor                107
Method overloading          109
Distinguishing overloaded methods         110
Overloading with primitives        . 111
Overloading on return values   114
Default constructors                114
The this keyword                . 116
Calling constructors from constructors          118
The meaning of static                . 119
Cleanup: finalization and garbage collection          119
What is finalize() for?               . 120
You must perform cleanup         . 121
The termination condition         . 121
How a garbage collector works   122
Member initialization         . 125
Specifying initialization               . 126
Constructor initialization  . 127
Order of initialization                 127
static data initialization                128
Explicit static initialization         130
Non-static instance initialization                 132
Array initialization               . 133
Variable argument lists               . 137
Enumerated types                . 141
Summary                 143
Access Control 145
package:the library unit        . 146
Code organization          147
Creating unique package names                . 148
A custom tool library         151
Using imports to change behavior         . 152
Package caveat                . 153
Java access specifiers          153
Package access                . 153
public: interface access                154
private: you can’t touch that!   155
protected: inheritance access . 156
Interface and implementation          158
Class access                159
Summary                 162
Reusing Classes 165 Composition syntax                165
Inheritance syntax               . 168
Initializing the base class                169
Delegation                . 171
Combining composition
and inheritance        . 173
Guaranteeing proper cleanup   174
Name hiding                      . 177
Choosing composition vs. inheritance          178
protected               . 180
Upcasting                 181
Why “upcasting”?          181
Composition vs. inheritance revisited               . 182
The final keyword               . 182
final data                              183
final methods                 186
final classes                      . 187
final caution                       188
Initialization and class loading                 189
Initialization with inheritance  . 189
Summary                       191
Polymorphism 193 Upcasting revisited               . 193
Forgetting the object type          194
The twist                       196
Method-call binding         196
Producing the right behavior         196
Extensibility                      . 199
Pitfall: “overriding” private methods          202
Pitfall: fields and static methods         203
Constructors and polymorphism        . 204
Order of constructor calls         . 204
Inheritance and cleanup                206
Behavior of polymorphic methods  inside constructors   210
Covariant return types          211
Designing with inheritance         212
Substitution vs. extension         . 213
Downcasting and runtime  type information         . 215
Summary                       217
Interfaces 219
Abstract classes and methods                219
Interfaces                . 222
Complete decoupling         . 225
“Multiple inheritance” in Java                        230
Extending an interface with inheritance                 231
Name collisions when combining Interfaces                 233
Adapting to an interface   234
Fields in interfaces                235
Initializing fields in interfaces   236
Nesting interfaces                 237
Interfaces and factories         239
Summary                       241
Inner Classes 243
Creating inner classes          243
The link to the outer class          244
Using .this and .new          246
Inner classes and upcasting         . 247
Inner classes in methods and scopes                249
Anonymous inner classes                251
Factory Method revisited          254
Nested classes          256
Classes inside interfaces                257
Reaching outward from a multiplynested class                 . 259
Why inner classes?               . 259
Closures & callbacks         261
Inner classes & control frameworks        . 263
Inheriting from inner classes                269
Can inner classes be overridden?        . 269
Local inner classes                 271
Inner-class identifiers          272
Summary                 273
Holding Your Objects 275
Generics and type-safe containers                276
Basic concepts          278
Adding groups of elements               . 279
Printing containers                281
List               . 283
Iterator                       286
ListIterator                 288
LinkedList                289
Stack                       . 291
Set                 292
Map                              295
Queue                        298
PriorityQueue                299
Collection vs. Iterator  . 301
Foreach and iterators         . 304
The Adapter Method idiom         306
Summary                 308
Error Handling with Exceptions 313
Concepts                       313
Basic exceptions        314
Exception arguments                       315
Catching an exception          315
The try block                       316
Exception handlers          316
Creating your own exceptions        . 317
Exceptions and logging                 319
The exception specification                322
Catching any exception         323
The stack trace                 324
Rethrowing an exception                325
Exception chaining          327
Standard Java exceptions                 330
Special case:RuntimeException                . 330
Performing cleanup with finally                332
What’s finally for?          333
Using finally during return   335
Pitfall: the lost exception          336
Exception restrictions        . 338
Constructors          340
Exception matching                344
Alternative approaches         345
History                 346
Perspectives                      . 347
Passing exceptions to the console                 349
Converting checked to unchecked exceptions                350
Exception guidelines         . 352
Summary                 352
Strings 355 Immutable Strings               355
Overloading ‘+’ vs.StringBuilder                       356
Unintended recursion        . 359
Operations on Strings        . 361
Formatting output               . 362
printf()                363
System.out.format()                363
The Formatter class                . 363
Format specifiers          364
Formatter conversions                366
String.format()         . 368
Regular expressions                370
Basics                      370
Creating regular expressions         372
Quantifiers                       . 374
Pattern and Matcher               . 375
split()                382
Replace operations          383
reset()                .384
Regular expressions and Java I/O                       385
Scanning input        . 386
Scanner delimiters                       388
Scanning with regular expressions        . 389
StringTokenizer               . 389
Summary                 391
Type Information 393 The need for RTTI                 393
The Class object                 395
Class literals                      . 399
Generic class references                401
New cast syntax                403
Checking before a cast        . 404
Using class literals          409
A dynamic instanceof                 411
Counting recursively         412
Registered factories                413
instanceof vs. Class equivalence              . 416
Reflection: runtime class information                 417
A class method extractor                418
Dynamic proxies                 420
Null Objects                424
Mock Objects & Stubs                 429
Interfaces and type information                 430
Summary                 436
Generics 439 Comparison with C++          440
Simple generics         440
A tuple library                 442
A stack class                      . 444
RandomList                 445
Generic interfaces                 446
Generic methods                 449
Leveraging type argument inference        .450
Varargs and generic methods   452
A generic method to use with Generators               453
A general-purpose Generator   453
Simplifying tuple use                       455
A Set utility                       456
Anonymous inner classes                459
Building complex models                       460
The mystery of erasure         462
The C++ approach          464
Migration compatibility                466
The problem with erasure         . 467
The action at the boundaries   468
Compensating for erasure                . 471
Creating instances of types          472
Arrays of generics          475
Bounds                      . 479
Wildcards                . 482
How smart is the compiler?         484
Contravariance                 485
Unbounded wildcards                . 488
Capture conversion        . 492
Issues                       . 493
No primitives as type parameters          493
Implementing parameterized interfaces                495
Casting and warnings                . 496
Overloading                      . 498
Base class hijacks an interface   498
Self-bounded types                500
Curiously recurring generics   500
Self-bounding                 501
Argument covariance                 503
Dynamic type safety          506
Exceptions               . 507
Mixins                        509
Mixins in C++                . 509
Mixing with interfaces                . 510
Using the Decorator pattern        . 511
Mixins with dynamic proxies   512
Latent typing                514
Compensating for the lack of latent typing         518
Reflection                              518
Applying a method to a sequence                       519
When you don’t happen to have the right interface          521
Simulating latent typing with adapters                       523
Using function objects as strategies                526
Summary: Is casting really so bad?          531
Further reading                 533
Arrays 535 Why arrays are special         535
Arrays are first-class objects                . 536
Returning an array               . 539
Multidimensional arrays                        540
Arrays and generics                543
Creating test data                . 546
Arrays.fill()                       546
Data Generators          547
Creating arrays from Generators         . 551
Arrays utilities         555
Copying an array                555
Comparing arrays          556
Array element comparisons         557
Sorting an array               .560
Searching a sorted array                561
Summary                 564
Containers in Depth 567
Full container taxonomy   567
Filling containers                . 568
A Generator solution                 569
Map generators               . 570
Using Abstract classes               . 573
Collection functionality                580
Optional operations                582
Unsupported operations               583
List functionality                . 586
Sets and storage order         589
SortedSet                       . 591
Queues                        594
Priority queues                . 594
Deques                . 595
Understanding Maps          598
Performance                       599
SortedMap                       602
LinkedHashMap        . 603
Hashing and hash codes   605
Understanding hashCodeQ   607
Hashing for speed          610
Overriding hashCode()                613
Choosing an implementation                 617
A performance test framework                . 618
Choosing between Lists                621
Microbenchmarking dangers   626
Choosing between Sets               . 627
Choosing between Maps                629
Utilities                      . 632
Sorting and searching Lists         635
Making a Collection or Map unmodifiable                . 636
Synchronizing a Collection or Map        . 637
Holding references                639
The WeakHashMap                 640
Java 1.0/1.1 containers         642
Vector & Enumeration          642
Hashtable                      . 643
Stack                 643
BitSet                . 644
Summary                 646
I/O 647 The File class          647
A directory lister                647
Directory utilities          650
Checking for and creating directories               . 654
Input and output                . 656
Types of InputStream               . 657
Types of OutputStream         . 658
Adding attributes and useful interfaces          659
Reading from an InputStream with FilterlnputStream          660
Writing to an OutputStream with FilterOutputStream         661
Readers & Writers         . 662
Sources and sinks of data         . 662
Modifying stream behavior         663
Unchanged classes          664
Off by itself: RandomAccessFile        . 665
Typical uses of I/O streams          665
Buffered input file          665
Input from memory         666
Formatted memory input          667
Basic file output                668
Storing and recovering data         669
Reading and writing random-access files         670
Piped streams                 672
File reading & writing utilities                . 672
Reading binary files        . 674
Standard I/O                675
Reading from standard input   675
Changing System.out to a PrintWriter          676
Redirecting standard I/O          676
Process control        . 677
New I/O                       679
Converting data                681
Fetching primitives        . 684
View buffers                      . 685
Data manipulation with buffers                      . 688
Buffer details                       689
Memory-mapped files                . 692
File locking                       . 695
Compression          698
Simple compression with GZIP                        698
Multifile storage with Zip          699
Java ARchives (JARs)                 701
Object serialization                703
Finding the class                706
Controlling serialization                707
Using persistence                713
XML                718
Preferences                 721
Summary                 722
Enumerated Types 725
Basic enum features         . 725
Using static imports with enums                      . 726
Adding methods to an enum                727
Overriding enum methods        . 728
enums in switch statements               . 728
The mystery of values()                729
Implements,not inherits               . 732
Random selection                 732 Using interfaces
for organization         734
Using EnumSet instead of flags        . 737
Using EnumMap               . 739
Constant-specific methods                       740
Chain of Responsibility with enums                      . 743
State machines with enums         746
Multiple dispatching                751
Dispatching with enums          753
Using constant-specific methods         . 755
Dispatching with EnumMaps          756
Using a 2-D array                757
Summary                 759
Annotations 761 Basic syntax                762
Defining annotations                       762
Meta-annotations          763
Writing annotation processors          765
Annotation elements                       765
Default value constraints                766
Generating external files               766
Annotations don’t support inheritance        . 769
Implementing the processor        769
Using apt to process annotations                772
Using the Visitor pattern with apt                       775
Annotation-based unit testing                 778
Using @Unit with generics        . 785
No “suites” necessary                      786
Implementing @Unit                . 787
Removing test code          792
Summary                       795
Concurrency 797
The many faces of concurrency                798
Faster execution               .798
Improving code design               . 800
Basic threading         801
Defining tasks                 801
The Thread class         . 802
Using Executors         . 804
Producing return values from tasks                       . 806
Sleeping               . 808
Priority                 809
Yielding                 810
Daemon threads               . 810
Coding variations                814
Terminology                      . 819
Joining a thread               . 819
Creating responsive user interfaces                 821
Thread groups                . 822
Catching exceptions         822
Sharing resources                 824
Improperly accessing resources        . 825
Resolving shared resource contention        . 827
Atomicity and volatility               . 831
Atomic classes                . 836
Critical sections                 837
Synchronizing on other objects                       841
Thread local storage        843
Terminating tasks                 844
The ornamental garden                844
Terminating when blocked          847
Interruption                       848
Checking for an interrupt          854
Cooperation between tasks         . 856
wait() and notifyAll()                857
notify() vs. notifyAll()                861
Producers and consumers          863
Producer-consumers and queues                        868
Using pipes for I/O between tasks                       872
Deadlock                       874
New library components                879
CountDownLatch         879
CyclicBarrier                 881
DelayQueue                . 883
PriorityBlockingQueue       . 885
The greenhouse controller with ScheduledExecutor         887
Semaphore                       890
Exchanger                       893
Simulation                 896
Bank teller simulation                 896
The restaurant simulation          900
Distributing work         . 904
Performance tuning                909
Comparing mutex technologies        . 909
Lock-free containers         916
Optimistic locking         922
ReadWriteLocks          923
Active objects         . 925
Summary                 929
Further reading                 931
Graphical User Interfaces 933
Applets                      . 935
Swing basics                935
A display framework         937
Making a button                       938
Capturing an event               . 939
Text areas                . 941
Controlling layout                 942
BorderLayout               . 942
FlowLayout                       943
GridLayout                       944
GridBagLayout               944
Absolute positioning         945
BoxLayout                      . 945
The best approach?          945
The Swing event model         945
Event and listener types                946
Tracking multiple events                951
A selection of Swing components                953
Buttons                . 953
Icons                       955
Tool tips               . 957
Text fields                              957
Borders                . 959
A mini-editor                      959
Check boxes                       960
Radio buttons                       961
Combo boxes(drop-down lists)          962
List boxes                        963
Tabbed panes                       965
Message boxes                . 965
Menus                       967
Pop-up menus                 972
Drawing                 973
Dialog boxes                      . 975
File dialogs                       .978
HTML on Swing components          980
Sliders and progress bars         . 980
Selecting look & feel        . 981
Trees, tables & clipboard          983
JNLP and Java Web Start        . 983
Concurrency & Swing          988
Long-running tasks        . 988
Visual threading                994
Visual programming and JavaBeans        . 996
What is a JavaBean?                       996
Extracting Beanlnfo with the Introspector                998
A more sophisticated Bean         1002
JavaBeans and synchronization                1005
Packaging a Bean          1008
More complex Bean support   1009
More to Beans                 1010
Alternatives to Swing          1010
Building Flash Web clients with Flex                 1011
Hello, Flex                       . 1011
Compiling MXML          1012
MXML and ActionScript         1013
Containers and controls               1013
Effects and styles         . 1015
Events                . 1016
Connecting to Java         1016
Data models and data binding          1018
Building and deploying               1019
Creating SWT applications          1020
Installing SWT               . 1020
Hello, SWT                      . 1021
Eliminating redundant code  1023
Menus                 1024
Tabbed panes, buttons,and events                        1025
Graphics                              1028
Concurrency in SWT                 1030
SWT vs. Swing?                1032
Summary                 1033
Resources                       . 1033
A: Supplements 1035
Downloadable supplements         . 1035
Thinking in C:Foundations for Java        . 1035
Thinking in Java seminar                       1035
Hands-On Java seminar-on-CD                 1036
Thinking in Objects seminar                       1036
Thinking in Enterprise Java                 1036
Thinking in Patterns(with Java)                1037
Thinking in Patterns seminar                       1037
Design consulting and reviews          1038
B: Resources 1039 Software                . 1039
Editors & IDEs                       1039
Books                        1039
Analysis & design         . 1040
Python                 1042
My own list of books                 1042
Index 1045

  • 云盘下载:
  • 本地下载: