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

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

......(更多)