Description
Book SynopsisBruce Eckel is president of MindView, Inc. (www.MindView.net), which provides public and private training seminars, consulting, mentoring, and design reviews in object-oriented technology and design patterns. He is the author of several books, has written more than fifty articles, and has given lectures and seminars throughout the world for more than twenty years. Bruce has served as a voting member of the C++ Standards Committee. He holds a B.S. in applied physics and an M.S. in computer engineering.
Table of ContentsPreface 1
Introduction 13
Prerequisites 14
Learning Java 14
Goals 15
Teaching from this book 16
JDK HTML documentation 17
Exercises 17
Foundations for Java 18
Source code 18
Errors 21
Introduction to Objects 23 The progress of abstraction 24
An object has an interface 26
An object provides services 29
The hidden implementation 30
Reusing the implementation 32
Inheritance 33
Interchangeable objects with polymorphism 38
The singly rooted hierarchy 43
Containers 44
Object creation & lifetime 46
Exception handling: dealing with errors 49
Concurrent programming 50
Java and the Internet 51
Summary 60
Everything Is an Object 61 You manipulate objects with references 61
You must create all the objects 63
You never need to destroy an object 67
Creating new data types: class 69
Methods, arguments, and return values 72
Building a Java program 74
Your first Java program 78
Comments and embedded documentation 81
Coding style 88
Summary 89
Exercises 89
Operators 93 Simpler print statements 93
Using Java operators 94
Precedence 95
Assignment 95
Mathematical operators 98
Auto increment and decrement 101
Relational operators 103
Logical operators 105
Literals 108
Bitwise operators 111
Shift operators 112
Ternary if-else operator 116
String operator + and += 118
Common pitfalls when using operators 119
Casting operators 120
Java has no “sizeof” 122
A compendium of operators 123
Summary 133
Controlling Execution 135 true and false 135
if-else 135
Iteration 137
Foreach syntax 140
return 143
break and continue 144
The infamous “goto” 146
switch 151
Summary 154
Initialization & Cleanup 155 Guaranteed initialization with the constructor 155
Method overloading 158
Default constructors 166
The this keyword 167
Cleanup: finalization and garbage collection 173
Member initialization 181
Constructor initialization 185
Array initialization 193
Enumerated types 204
Summary 207
Access Control 209 package: the library unit 210
Java access specifiers 221
Interface and implementation 228
Class access 229
Summary 233
Reusing Classes 237 Composition syntax 237
Inheritance syntax 241
Delegation 246
Combining composition and inheritance 249
Choosing composition vs. inheritance 256
protected 258
Upcasting 260
The final keyword 262
Initialization and class loading 272
Summary 274
Polymorphism 277 Upcasting revisited 278
The twist 281
Constructors and polymorphism 293
Covariant return types 303
Designing with inheritance 304
Summary 310
Interfaces 311 Abstract classes and methods 311
Interfaces 316
Complete decoupling 320
“Multiple in heritance” in Java 326
Extending an interface with inheritance 329
Adapting to an interface 331
Fields in interfaces 335
Nesting interfaces 336
Interfaces and factories 339
Summary 343
Inner Classes 345 Creating inner classes 345
The link to the outer class 347
Using .this and .new 350
Inner classes and upcasting 352
Inner classes in methods and scopes 354
Anonymous inner classes 356
Nested classes 364
Why inner classes? 369
Inheriting from inner classes 382
Can inner classes be overridden? 383
Local inner classes 385
Inner-class identifiers 387
Summary 388
Holding Your Objects 389 Generics and type-safe containers 390
Basic concepts 394
Adding groups of elements 396
Printing containers 398
List 401
Iterator 406
LinkedList 410
Stack 412
Set 415
Map 419
Queue 423
Collection vs. Iterator 427
Foreach and iterators 431
Summary 437
Error Handling with Exceptions 443 Concepts 444
Basic exceptions 445
Catching an exception 447
Creating your own exceptions 449
The exception specification 457
Catching any exception 458
Standard Java exceptions 468
Performing cleanup with finally 471
Exception restrictions 479
Constructors 483
Exception matching 489
Alternative approaches 490
Exception guidelines 500
Summary 501
Strings 503 Immutable Strings 503
Overloading &8216;+’ vs. StringBuilder 504
Unintended recursion 509
Operations on Strings 511
Formatting output 514
Regular expressions 523
Scanning input 546
StringTokenizer 551
Summary 552
Type Information 553 The need for RTTI 553
The Class object 556
Checking before a cast 569
Registered factories 582
instanceof vs. Class equivalence 586
Reflection: runtime class information 588
Dynamic proxies 593
Null Objects 598
Interfaces and type information 607
Summary 613
Generics 617 Comparison with C++ 618
Simple generics 619
Generic interfaces 627
Generic methods 631
Anonymous inner classes 645
Building complex models 647
The mystery of erasure 650
Compensating for erasure 662
Bounds 673
Wildcards 677
Issues 694
Self-bounded types 701
Dynamic type safety 710
Exceptions 711
Mixins 713
Latent typing 721
Compensating for the lack of latent typing 726
Using function objects as strategies 737
Summary: Is casting really so bad? 743
Arrays 747 Why arrays are special 747
Arrays are first-class objects 749
Returning an array 753
Multidimensional arrays 754
Arrays and generics 759
Creating test data 762
Arrays utilities 775
Summary 786
Containers in Depth 791 Full container taxonomy 791
Filling containers 793
Collection functionality 809
Optional operations 813
List functionality 817
Sets and storage order 821
Queues 827
Understanding Maps 831
Hashing and hash codes 839
Choosing an implementation 858
Utilities 879
Holding references 889
Java 1.0/1.1 containers 893
Summary 900
I/O 901 The File class 901
Input and output 914
Adding attributes and useful interfaces 918
Readers & Writers 922
Off by itself: RandomAccessFile 926
Typical uses of I/O streams 927
File reading & writing utilities 936
Standard I/O 941
Process control 944
New I/O 946
Compression 973
Object serialization 980
XML 1003
Preferences 1006
Summary 1008
Enumerated Types 1011 Basic enum features 1011
Adding methods to an enum 1014
enums in switch statements 1016
The mystery of values() 1017
Implements, not inherits 1020
Random selection 1021
Using interfaces for organization 1022
Using EnumSet instead of flags 1028
Using EnumMap 1030
Constant-specific methods 1032
Multiple dispatching 1047
Summary 1057
Annotations 1059 Basic syntax 1060
Writing annotation processors 1064
Using apt to process annotations 1074
Using the Visitor pattern with apt 1079
Annotation-based unit testing 1083
Summary 1106
Concurrency 1109 The many faces of concurrency 1111
Basic threading 1116
Sharing resources 1150
Terminating tasks 1179
Cooperation between tasks 1197
Deadlock 1223
New Library components 1229
Simulation 1253
Performance tuning 1270
Active objects 1295
Summary 1300
Graphical User Interfaces 1303 Applets 1306
Swing basics 1307
Making a button 1311
Capturing an event 1312
Text areas 1315
Controlling layout 1317
The Swing event model 1321
A selection of Swing components 1332
JNLP and Java Web Start 1376
Concurrency & Swing 1382
Visual programming and JavaBeans 1393
Alternatives to Swing 1415
Building Flash Web clients with Flex 1416
Creating SWT applications 1430
Summary 1447
A: Supplements 1449 Downloadable supplements 1449
Thinking in C: Foundations for Java 1449
Thinking in Java seminar 1450
Hands-On Java seminar-on-CD 1450
Thinking in Objects seminar 1450
Thinking in Enterprise Java 1451
Thinking in Patterns (with Java) 1452
Thinking in Patterns seminar 1452
Design consulting and reviews 1453
B: Resources 1455 Software 1455
Editors & IDEs 1455
Books 1456
Index 1463
