推薦序前言1 introduction2 creating and destroying objectsitem 1: consider static factory methods instead of constructorsitem 2: consider a builder when faced with many constructor parameters item 3: enforce the singleton property with a private constructor or an enum type item 4: enforce noninstantiability with a private constructor item 5: avoid creating unnecessary objects item 6: eliminate obsolete object referencesitem 7: avoid finalizers3 methods common to all objectsitem 8: obey the general contract when overriding equals item 9: always override hashcode when you override equals item 10: always override tostring item 11: override clone judiciouslyitem 12: consider implementing comparable 4 classes and interfacesitem 13: minimize the accessibility of classes and membersitem 14: in public classes, use accessor methods, not public fields item 15: minimize mutabilityitem 16: favor composition over inheritanceitem 17: design and document for inheritance or else prohibit it item 18: prefer interfaces to abstract classes item 19: use interfaces only to define typesitem 20: prefer class hierarchies to tagged classesitem 21: use function objects to represent strategies item 22: favor static member classes over nonstatic 5 generics item 23: don’t use raw types in new code item 24: eliminate unchecked warningsitem 25: prefer lists to arrays item 26: favor generic typesitem 27: favor generic methods item 28: use bounded wildcards to increase api flexibility item 29: consider typesafe heterogeneous containers 6 enums and annotations item 30: use enums instead of int constantsitem 31: use instance fields instead of ordinals item 32: use enumset instead of bit fieldsitem 33: use enummap instead of ordinal indexingitem 34: emulate extensible enums with interfaces item 35: prefer annotations to naming patterns item 36: consistently use the override annotationitem 37: use marker interfaces to define types 7 methods item 38: check parameters for validity item 39: make defensive copies when needed item 40: design method signatures carefullyitem 41: use overloading judiciouslyitem 42: use varargs judiciouslyitem 43: return empty arrays or collections, not nulls item 44: write doc comments for all exposed api elements 8 general programming item 45: minimize the scope of local variablesitem 46: prefer for-each loops to traditional for loopsitem 47: know and use the libraries item 48: avoid float and double if exact answers are required item 49: prefer primitive types to boxed primitives item 50: avoid strings where other types are more appropriate item 51: beware the performance of string concatenation item 52: refer to objects by their interfaces item 53: prefer interfaces to reflection item 54: use native methods judiciouslyitem 55: optimize judiciously item 56: adhere to generally accepted naming conventions9 exceptions item 57: use exceptions only for exceptional conditions item 58: use checked exceptions for recoverable conditions and runtime exceptions for programming errorsitem 59: avoid unnecessary use of checked exceptions item 60: favor the use of standard exceptionsitem 61: throw exceptions appropriate to the abstractionitem 62: document all exceptions thrown by each methoditem 63: include failure-capture information in detail messages item 64: strive for failure atomicity item 65: don’t ignore exceptions 10 concurrencyitem 66: synchronize access to shared mutable dataitem 67: avoid excessive synchronization item 68: prefer executors and tasks to threadsitem 69: prefer concurrency utilities to wait and notify item 70: document thread safety item 71: use lazy initialization judiciously item 72: don’t depend on the thread scheduler item 73: avoid thread groups11 serializationitem 74: implement serializable judiciouslyitem 75: consider using a custom serialized form item 76: write readobject methods defensively item 77: for instance control, prefer enum types to readresolve item 78: consider serialization proxies instead of seri