Effective Java

1　introduction 　1
2　creating and destroying objects　5
item 1: consider static factory methods instead of constructors　5
item 2: consider a builder when faced with many constructor parameters　11
item 3: enforce the singleton property with a private constructor or an enum type　17
item 4: enforce noninstantiability with a private constructor　19
· · · · · · (更多)

1　introduction 　1
2　creating and destroying objects　5
item 1: consider static factory methods instead of constructors　5
item 2: consider a builder when faced with many constructor parameters　11
item 3: enforce the singleton property with a private constructor or an enum type　17
item 4: enforce noninstantiability with a private constructor　19
item 5: avoid creating unnecessary objects　20
item 6: eliminate obsolete object references　24
item 7: avoid finalizers　27
3　methods common to all objects　33
item 8: obey the general contract when overriding equals　33
item 9: always override hashcode when you overrideequals　45
item 10: always override tostring　51
item 11: override clone judiciously　54
item 12: consider implementing comparable　62
4　classes and interfaces　67
item 13: minimize the accessibility of classes and members 67
item 14: in public classes, use accessor methods, not public fields　71
item 15: minimize mutability　73
item 16: favor composition over inheritance　81
item 17: design and document for inheritance or else prohibit it　87
item 18: prefer interfaces to abstract classes　93
item 19: use interfaces only to define types　98
item 20: prefer class hierarchies to tagged classes　100
item 21: use function objects to represent strategies　103
item 22: favor static member classes over nonstatic　106
5　generics　109
item 23: don't use raw types in new code　109
item 24: eliminate unchecked warnings　116
item 25: prefer lists to arrays　119
item 26: favor generic types　124
item 27: favor generic methods　129
item 28: use bounded wildcards to increase api flexibility　134
item 29: consider typesafe heterogeneous containers　142
6　enums and annotations　147
item 30: use enums instead of int constants　147
item 31: use instance fields instead of ordinals　158
item 32: use enumset instead of bit fields　159
item 33: use enummap instead of ordinal indexing　161
item 34: emulate extensible enums with interfaces　165
item 35: prefer annotations to naming patterns　169
item 36: consistently use the override annotation　176
item 37: use marker interfaces to define types　179
7　methods　181
item 38: check parameters for validity ..　181
item 39: make defensive copies when needed　184
item 40: design method signatures carefully　189
item 41: use overloading judiciously　191
item 42: use varargs judiciously　197
item 43: return empty arrays or collections, not nulls　201
item 44: write doc comments for all exposed api elements　203
8　general programming　209
item 45: minimize the scope of local variables　209
item 46: prefer for-each loops to traditional for loops　212
item 47: know and use the libraries　215
item 48: avoid float and double if exact answers are required　218
item 49: prefer primitive types to boxed primitives　221
item 50: avoid strings where other types are more appropriate　224
item 51: beware the performance of string concatenation　227
item 52: refer to objects by their interfaces　228
item 53: prefer interfaces to reflection　230
item 54: use native methods judiciously　233
item 55: optimize judiciously　234
item 56: adhere to generally accepted naming conventions　237
9　exceptions　241
item 57: use exceptions only for exceptional conditions　241
item 58: use checked exceptions for recoverable conditions and runtime exceptions for programming errors　244
item 59: avoid unnecessary use of checked exceptions　246
item 60: favor the use of standard exceptions　248
item 61: throw exceptions appropriate to the abstraction　250
item 62: document all exceptions thrown by each method　252
item 63: include failure-capture information in detail messages　254
item 64: strive for failure atomicity　256
item 65: don't ignore exceptions　258
10　concurrency　259
item 66: synchronize access to shared mutable data　259
item 67: avoid excessive synchronization　265
item 68: prefer executors and tasks to threads　271
item 69: prefer concurrency utilities to wait and notify　273
item 70: document thread safety　278
item 71: use lazy initialization judiciously　282
item 72: don't depend on the thread scheduler　286
item 73: avoid thread groups　288
11　serialization　289
item 74: implement serializable judiciously　289
item 75: consider using a custom serialized form　295
item 76: write readobject methods defensively　302
item 77: for instance control, prefer enum types toreadresolve　308
item 78: consider serialization proxies instead of serialized instances　312
appendix: items corresponding to first edition　317
references　321
index 　327
· · · · · · (收起)