Practical Java

This broad-ranging guide can help programmers with varying levels of expertise to understand Java more completely and to maximize their coding effectiveness. This book's rules-based format examines 68 key topics on how to improve your code, providing crisp, well-written examples and solutions. All of the examples and solutions are accompanied by thorough explanations for achieving a working solution of your own. This practical approach to programming and design describes the best practices used by experienced programmers. Intended for the intermediate to advanced Java programmer, the Practical Java? Programming Language Guide is organized into individual lessons, so it can either be read from cover to cover or by individual topic.

Topics discussed include:

• Objects and equality
• Exception handling
• Performance
• Multithreading
• Classes and interfaces

If you want to spend less time debugging, optimizing, and tuning your code, this example-oriented, down-to-earth guide is full of practical techniques for exploiting the Java programming language. The 68 topics were chosen based on their relevance to effective and efficient programming practices. A special section focusing on performance provides valuable insights into Java performance issues and useful performance improvement techniques. If you want real-world, sound advice on building applications using the Java programming language, this book is essential reading.

Table of contents

Praxis 1: Understand that parameters are passed by value, not by reference
Praxis 2: Use final for constant data and constant object references
Praxis 3: Understand that all non-static methods can be overridden by default
Praxis 4: Choose carefully between arrays and Vectors
Praxis 5: Prefer polymorphism to instance of
Praxis 6: Use instanceof only when you must
Praxis 7: Set object references to null when they are no longer needed
Praxis 8: Differentiate between reference and primitive types
Praxis 9: Differentiate between == and equals
Praxis 10: Do not rely on the default implementation of equals
Praxis 11: Implement the equals method judiciously
Praxis 12: Prefer getClass in equals method implementations
Praxis 13: Call super.equals of base classes
Praxis 14: Consider carefully instanceof in equals method implementations
Praxis 15: Follow these rules when implementing an equals method
Praxis 16: Know the mechanics of exception control flow
Praxis 17: Never ignore an exception
Praxis 18: Never hide an exception
Praxis 19: Consider the drawback to the throws clause
Praxis 20: Be specific and comprehensive with the throws clause
Praxis 21: Use finally to avoid resource leaks
Praxis 22: Do not return from a try block
Praxis 23: Place try/catch blocks outside of loops
Praxis 24: Do not use exceptions for control flow
Praxis 25: Do not use exceptions for every error condition
Praxis 26: Throw exceptions from constructors
Praxis 27: Return objects to a valid state before throwing an exception
Praxis 28: Focus initially on design, data structures, and algorithms
Praxis 29: Do not rely on compile-time code optimization
Praxis 30: Understand runtime code optimization
Praxis 31: Use StringBuffer, rather than String, for concatenation
Praxis 32: Minimize the cost of object creation
Praxis 33: Guard against unused objects
Praxis 34: Minimize synchronization
Praxis 35: Use stack variables whenever possible
Praxis 36: Use static, final, and private methods to allow inlining
Praxis 37: Initialize instance variables only once
Praxis 38: Use primitive types for faster and smaller code
Praxis 39: Do not use an Enumeration or an Iterator to traverse a Vector
Praxis 40: Use System.arraycopy for copying arrays
Praxis 41: Prefer an array to a Vector or ArrayList
Praxis 42: Reuse objects whenever possible
Praxis 43: Use lazy evaluation
Praxis 44: Optimize source code by hand
Praxis 45: Compile to native code
Praxis 46: Understand that for instance methods, synchronized locks objects, not methods or code
Praxis 47: Distinguish between synchronized statics and synchronized instance methods
Praxis 48: Use private data with an accessor method instead of public or protected data
Praxis 49: Avoid unnecessary synchronization
Praxis 50: Use synchronized or volatile when accessing shared variables
Praxis 51: Lock all objects involved in a single operation
Praxis 52: Acquire multiple locks in a fixed, global order to avoid deadlock
Praxis 53: Prefer notifyAll to notify
Praxis 54: Use spin locks for wait and notifyAll
Praxis 55: Use wait and notifyAll instead of polling loops
Praxis 56: Do not reassign the object reference of a locked object
Praxis 57: Do not invoke the stop or suspend methods
Praxis 58: Terminate threads through thread cooperation
Praxis 59: Use interfaces to support multiple inheritance
Praxis 60: Avoid method clashes in interfaces
Praxis 61: Use abstract classes when it makes sense to provide a partial implementation
Praxis 62: Differentiate between an interface, abstract class, and concrete class
Praxis 63: Define and implement immutable classes judiciously
Praxis 64: Use clone for immutable objects when passing or receiving object references to mutable
Praxis 65: Use inheritance or delegation to define immutable classes
Praxis 66: Call super.clone when implementing a clone method
Praxis 67: Do not rely on finalize methods for non-memory resource cleanup
Praxis 68: Use care when calling non-final methods from constructors