Java Inspection Checklist

1. Variable, Atrtibute, and Constant Declaration Defects (VC)

o Are descriptive variable and constant names used in accord with naming conventions?
o Are there variables or atributes with confusingly similar names?
o Is every variable and attribute correctly typed?
o Is every variable and attribute properly initialized?
o Could any non-local variables be made local?
o Are all for-loop control variables declared in the loop header?
o Are there literal constants that should be named constants?
o Are there variables or attributes that should be constants?
o Are there attributes that should be local variables?
o Do all attributes have appropriate access modifiers (private, protected, public)?
o Are there static attributes that should be non-static or vice-versa?

2. Method Definition Defects (FD)

o Are descriptive method names used in accord with naming conventions?
o Is every method parameter value checked before being used?
o For every method: Does it return the correct value at every method return point?
o Do all methods have appropriate access modifiers (private, protected, public)?
o Are there static methods that should be non-static or vice-versa?

3. Class Definition Defects (CD)

o Does each class have appropriate constructors and destructors?
o Do any subclasses have common members that should be in the superclass?
o Can the class inheritance hierarchy be simplified?

4. Data Reference Defects (DR)

o For every array reference: Is each subscript value within the defined bounds?
o For every object or array reference: Is the value certain to be non-null?

5. Computation/Numeric Defects (CN)

o Are there any computations with mixed data types?
o Is overflow or underflow possible during a computation?
o For each expressions with more than one operator: Are the assumptions about order of evaluation and precedence correct?
o Are parentheses used to avoid ambiguity?

6. Comparison/Relational Defects (CR)

o For every boolean test: Is the correct condition checked?
o Are the comparison operators correct?
o Has each boolean expression been simplified by driving negations inward?
o Is each boolean expression correct?
o Are there improper and unnoticed side-effects of a comparison?
o Has an "&" inadvertently been interchanged with a "&&" or a "|" for a "||"?

7. Control Flow Defects (CF)

o For each loop: Is the best choice of looping constructs used?
o Will all loops terminate?
o When there are multiple exits from a loop, is each exit necessary and handled properly?
o Does each switch statement have a default case?
o Are missing switch case break statements correct and marked with a comment?
o Do named break statements send control to the right place?
o Is the nesting of loops and branches too deep, and is it correct?
o Can any nested if statements be converted into a switch statement?
o Are null bodied control structures correct and marked with braces or comments?
o Are all exceptions handled appropriately?
o Does every method terminate?

8. Input-Output Defects (IO)

o Have all files been opened before use?
o Are the attributes of the input object consistent with the use of the file?
o Have all files been closed after use?
o Are there spelling or grammatical errors in any text printed or displayed?
o Are all I/O exceptions handled in a reasonable way?

9. Module Interface Defects (MI)

o Are the number, order, types, and values of parameters in every method call in agreement with the called method's declaration?
o Do the values in units agree (e.g., inches versus yards)?
o If an object or array is passed, does it get changed, and changed correctly by the called method?

10. Comment Defects (CM)

o Does every method, class, and file have an appropriate header comment?
o Does every atribute, variable, and constant declaration have a comment?
o Is the underlying behavior of each method and class expressed in plain language?
o Is the header comment for each method and class consistent with the behavior of the method or class?
o Do the comments and code agree?
o Do the comments help in understanding the code?
o Are there enough comments in the code?
o Are there too many comments in the code?

11. Layout and Packaging Defects (LP)

o Is a standard indentation and layout format used consistently?
o For each method: Is it no more than about 60 lines long?
o For each compile module: Is no more than about 600 lines long?

12. Modularity Defects (MO)

o Is there a low level of coupling between modules (methods and classes)?
o Is there a high level of cohesion within each module (methods or class)?
o Is there repetitive code that could be replaced by a call to a method that provides the behavior of the repetitive code?
o Are the Java class libraries used where and when appropriate?

13. Storage Usage Defects (SU)

o Are arrays large enough?
o Are object and array references set to null once the object or array is no longer needed?

14. Performance Defects (PE) [Optional]

o Can better data structures or more efficient algorithms be used?
o Are logical tests arranged such that the often successful and inexpensive tests precede the more expensive and less frequently successful tests?
o Can the cost of recomputing a value be reduced by computing it once and storing the results?
o Is every result that is computed and stored actually used?
o Can a computation be moved outside a loop?
o Are there tests within a loop that do not need to be done?
o Can a short loop be unrolled?
o Are there two loops operating on the same data that can be combined into one?
o Are frequently used variables declared register?
o Are short and commonly called methods declared inline?

Return to Home Page

Copyright 1999 Christopher Fox