Practical Java
Peter Haggar

1. Understand that parameters are passed by value, not by reference.
2. Use final for constant data and constant object references.
3. Understand that all non-static methods can be overridden by default.
4. Choose carefully between arrays and Vectors.
5. Prefer polymorphism to instanceof.
6. Use instanceof only when you must.
7. Set object references to null when they are no longer needed.

8. Differentiate between reference and primitive types.
9. Differentiate between == and equals.
10. Do not rely on the default implementation of equals.
11. Implement the equals method judiciously.
12. Prefer getClass in equals method implementations.
13. Call super.equals of base classes.
14. Consider carefully instance of in equals method implementations.
15. Follow these rules when implementing an equals method.

16. Know the mechanics of exception control flow.
17. Never ignore an exception.
18. Never hide an exception.
19. Consider the drawback to the throws clause.
20. Be specific and comprehensive with the throws clause.
21. Use finally to avoid resource leaks.
22. Do not return from a try block.
23. Place try/catch blocks outside of loops.
24. Do not use exceptions for control flow.
25. Do not use exceptions for every error condition.
26. Throw exceptions from constructors.
27. Return objects to a valid state before throwing an exception.

28. Focus initially on design, data structures, and algorithms.
29. Do not rely on compile-time code optimization.
30. Understand runtime code optimization.
31. Use StringBuffer, rather than String, for concatenation.
32. Minimize the cost of object creation.
33. Guard against unused objects.
34. Minimize synchronization.
35. Use stack variables whenever possible.
36. Use static, final, and private methods to allow in lining.
37. Initialize instance variables only once.
38. Use primitive types for faster and smaller code.
39. Do not use an Enumeration or an Iterator to traverse a Vector.
40. Use System array copy for copying arrays.
41. Prefer an array to a Vector or ArrayList.
42. Reuse objects whenever possible.
43. Use lazy evaluation.
44. Optimize source code by hand.
45. Compile to native code.

46. Understand that for instance methods, synchronized locks objects, not methods or code.
47. Distinguish between synchronized statics and synchronized instance methods.
48. Use private data with an accessor method instead of public or protected data.
49. Avoid unnecessary synchronization.
50. Use synchronized or volatile when accessing shared variables.
51. Lock all objects involved in a single operation.
52. Acquire multiple locks in a fixed, global order to avoid deadlock.
53. Prefer notifyAll to notify.
54. Use spin locks for wait and notifyAll.
55. Use wait and notifyAll instead of polling loops.
56. Do not reassign the object reference of a locked object.
57. Do not invoke the stop or suspend methods.
58. Terminate threads through thread cooperation.

59. Use interfaces to support multiple inheritance.
60. Avoid method clashes in interfaces.
61. Use abstract classes when it makes sense to provide a partial implementation.
62. Differentiate between an interface, abstract class, and concrete class.
63. Define and implement immutable classes judiciously.
64. Use clone for immutable objects when passing or receiving object references to mutable objects.
65. Use inheritance or delegation to define immutable classes.
66. Call super.clone when implementing a clone method.
67. Do not rely on finalize methods for non-memory resource cleanup.
68. Use care when calling non-final methods from constructors.