Changes between Initial Version and Version 1 of EffectiveJavaItems


Ignore:
Timestamp:
May 11, 2014, 1:40:28 AM (4 years ago)
Author:
konca
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • EffectiveJavaItems

    v1 v1  
     1Here is the items in the book EffectiveJava. This list is copied from: http://my.safaribooksonline.com/book/programming/java/9780137150021 
     2 
     3== Chapters == 
     4||Chapter 2. Creating and Destroying Objects || 1 ~ 7 || 
     5||Chapter 3. Methods Common to All Objects || 8 ~ 12 || 
     6||Chapter 4. Classes and Interfaces || 13 ~ 22 || 
     7||Chapter 5. Generics || 23 ~ 29 || 
     8||Chapter 6. Enums and Annotations || 30 ~ 37 || 
     9||Chapter 7. Methods || 38 ~ 44 || 
     10||Chapter 8. General Programming || 45 ~ 56 || 
     11||Chapter 9. Exceptions || 57 ~ 65 || 
     12||Chapter 10. Concurrency || 66 ~ 73 || 
     13||Chapter 11. Serialization || 74 ~ 78 || 
     14 
     15 
     16== 78 items == 
     17 * Chapter 2. Creating and Destroying Objects 
     18   * Item 1: Consider static factory methods instead of constructors 
     19   * Item 2: Consider a builder when faced with many constructor parameters 
     20   * Item 3: Enforce the singleton property with a private constructor or an enum type 
     21   * Item 4: Enforce noninstantiability with a private constructor 
     22   * Item 5: Avoid creating unnecessary objects 
     23   * Item 6: Eliminate obsolete object references 
     24   * Item 7: Avoid finalizers 
     25 * Chapter 3. Methods Common to All Objects 
     26   * Item 8: Obey the general contract when overriding equals 
     27   * Item 9: Always override hashCode when you override equals 
     28   * Item 10: Always override toString 
     29   * Item 11: Override clone judiciously 
     30   * Item 12: Consider implementing Comparable 
     31 * Chapter 4. Classes and Interfaces 
     32   * Item 13: Minimize the accessibility of classes and members 
     33   * Item 14: In public classes, use accessor methods, not public fields 
     34   * Item 15: Minimize mutability 
     35   * Item 16: Favor composition over inheritance 
     36   * Item 17: Design and document for inheritance or else prohibit it 
     37   * Item 18: Prefer interfaces to abstract classes 
     38   * Item 19: Use interfaces only to define types 
     39   * Item 20: Prefer class hierarchies to tagged classes 
     40   * Item 21: Use function objects to represent strategies 
     41   * Item 22: Favor static member classes over nonstatic 
     42 * Chapter 5. Generics 
     43   * Item 23: Don’t use raw types in new code 
     44   * Item 24: Eliminate unchecked warnings 
     45   * Item 25: Prefer lists to arrays 
     46   * Item 26: Favor generic types 
     47   * Item 27: Favor generic methods 
     48   * Item 28: Use bounded wildcards to increase API flexibility 
     49   * Item 29: Consider typesafe heterogeneous containers 
     50 * Chapter 6. Enums and Annotations 
     51   * Item 30: Use enums instead of int constants 
     52   * Item 31: Use instance fields instead of ordinals 
     53   * Item 32: Use !EnumSet instead of bit fields 
     54   * Item 33: Use !EnumMap instead of ordinal indexing 
     55   * Item 34: Emulate extensible enums with interfaces 
     56   * Item 35: Prefer annotations to naming patterns 
     57   * Item 36: Consistently use the Override annotation 
     58   * Item 37: Use marker interfaces to define types 
     59 * Chapter 7. Methods 
     60   * Item 38: Check parameters for validity 
     61   * Item 39: Make defensive copies when needed 
     62   * Item 40: Design method signatures carefully 
     63   * Item 41: Use overloading judiciously 
     64   * Item 42: Use varargs judiciously 
     65   * Item 43: Return empty arrays or collections, not nulls 
     66   * Item 44: Write doc comments for all exposed API elements 
     67 * Chapter 8. General Programming 
     68   * Item 45: Minimize the scope of local variables 
     69   * Item 46: Prefer for-each loops to traditional for loops 
     70   * Item 47: Know and use the libraries 
     71   * Item 48: Avoid float and double if exact answers are required 
     72   * Item 49: Prefer primitive types to boxed primitives 
     73   * Item 50: Avoid strings where other types are more appropriate 
     74   * Item 51: Beware the performance of string concatenation 
     75   * Item 52: Refer to objects by their interfaces 
     76   * Item 53: Prefer interfaces to reflection 
     77   * Item 54: Use native methods judiciously 
     78   * Item 55: Optimize judiciously 
     79   * Item 56: Adhere to generally accepted naming conventions 
     80 * Chapter 9. Exceptions 
     81   * Item 57: Use exceptions only for exceptional conditions 
     82   * Item 58: Use checked exceptions for recoverable conditions and runtime exceptions for programming errors 
     83   * Item 59: Avoid unnecessary use of checked exceptions 
     84   * Item 60: Favor the use of standard exceptions 
     85   * Item 61: Throw exceptions appropriate to the abstraction 
     86   * Item 62: Document all exceptions thrown by each method 
     87   * Item 63: Include failure-capture information in detail messages 
     88   * Item 64: Strive for failure atomicity 
     89   * Item 65: Don’t ignore exceptions 
     90 * Chapter 10. Concurrency 
     91   * Item 66: Synchronize access to shared mutable data 
     92   * Item 67: Avoid excessive synchronization 
     93   * Item 68: Prefer executors and tasks to threads 
     94   * Item 69: Prefer concurrency utilities to wait and notify 
     95   * Item 70: Document thread safety 
     96   * Item 71: Use lazy initialization judiciously 
     97   * Item 72: Don’t depend on the thread scheduler 
     98   * Item 73: Avoid thread groups 
     99 * Chapter 11. Serialization 
     100   * Item 74: Implement Serializable judiciously 
     101   * Item 75: Consider using a custom serialized form 
     102   * Item 76: Write readObject methods defensively 
     103   * Item 77: For instance control, prefer enum types to readResolve 
     104   * Item 78: Consider serialization proxies instead of serialized instances