...
This noncompliant code example defines an isName() method that takes a String argument and returns true if the given string is a valid name. A valid name is defined as two capitalized words separated by one or more spaces. Rather than checking to see whether the given string is null, the method catches NullPointerException and returns false.
| Code Block |
|---|
|
boolean isName(String s) {
try {
String names[] = s.split(" ");
if (names.length != 2) {
return false;
}
return (isCapitalized(names[0]) && isCapitalized(names[1]));
} catch (NullPointerException e) {
return false;
}
}
|
...
| Code Block |
|---|
|
boolean isName(String s) {
if (s == null) {
return false;
}
String names[] = s.split(" ");
if (names.length != 2) {
return false;
}
return (isCapitalized(names[0]) && isCapitalized(names[1]));
}
|
Compliant Solution
This compliant solution omits an explicit check for a null reference and permits a NullPointerException to be thrown:
| Code Block |
|---|
|
boolean isName(String s) /* Throws NullPointerException */ {
String names[] = s.split(" ");
if (names.length != 2) {
return false;
}
return (isCapitalized(names[0]) && isCapitalized(names[1]));
}
|
Omitting the null check means that the program fails more quickly than if the program had returned false and lets an invoking method discover the null value. A method that throws a NullPointerException without a null check must provide a precondition that the argument being passed to it is not null.
...
| Code Block |
|---|
|
public interface Log {
public static final Log NULL = new Log() {
public void write(String messageToLog) {
// Do nothing
}
};
void write(String messageToLog);
}
class Service {
private final Log log;
Service(){
this.log = Log.NULL;
}
// ...
}
|
Declaring the log reference final ensures that its value is assigned during initialization.
...
| Code Block |
|---|
|
public class DivideException {
public static void division(int totalSum, int totalNumber)
throws ArithmeticException, IOException {
int average = totalSum / totalNumber;
// Additional operations that may throw IOException...
System.out.println("Average: " + average);
}
public static void main(String[] args) {
try {
division(200, 5);
division(200, 0); // Divide by zero
} catch (Exception e) {
System.out.println("Divide by zero exception : "
+ e.getMessage());
}
}
}
|
Noncompliant Code Example
...
| Code Block |
|---|
|
try {
division(200, 5);
division(200, 0); // Divide by zero
} catch (ArithmeticException ae) {
throw new DivideByZeroException();
} catch (Exception e) {
System.out.println("Exception occurred :" + e.getMessage());
}
|
Note that DivideByZeroException is a custom exception type that extends Exception.
...
| Code Block |
|---|
|
import java.io.IOException;
public class DivideException {
public static void main(String[] args) {
try {
division(200, 5);
division(200, 0); // Divide by zero
} catch (ArithmeticException ae) {
// DivideByZeroException extends Exception so is checked
throw new DivideByZeroException();
} catch (IOException ex) {
ExceptionReporter.report(ex);
}
}
public static void division(int totalSum, int totalNumber)
throws ArithmeticException, IOException {
int average = totalSum / totalNumber;
// Additional operations that may throw IOException...
System.out.println("Average: "+ average);
}
}
|
The ExceptionReporter class is documented in ERR00-J. Do not suppress or ignore checked exceptions.
...
| Code Block |
|---|
|
import java.io.IOException;
public class DivideException {
public static void main(String[] args) {
try {
division(200, 5);
division(200, 0); // Divide by zero
} catch (ArithmeticException | IOException ex) {
ExceptionReporter.report(ex);
}
}
public static void division(int totalSum, int totalNumber)
throws ArithmeticException, IOException {
int average = totalSum / totalNumber;
// Additional operations that may throw IOException...
System.out.println("Average: "+ average);
}
}
|
Exceptions
ERR08-EX0: A catch block may catch all exceptions to process them before rethrowing them (filtering sensitive information from exceptions before the call stack leaves a trust boundary, for example). Refer to ERR01-J. Do not allow exceptions to expose sensitive information and weaknesses CWE 7 and CWE 388 for more information. In such cases, a catch block should catch Throwable rather than Exception or RuntimeException.
...
| Code Block |
|---|
|
class DoSomethingException extends Exception {
public DoSomethingException(Throwable cause) {
super(cause);
}
// Other methods
};
private void doSomething() throws DoSomethingException {
try {
// Code that might throw an Exception
} catch (Throwable t) {
throw new DoSomethingException(t);
}
}
|
Exception wrapping is a common technique to safely handle unknown exceptions. For another example, see ERR06-J. Do not throw undeclared checked exceptions.
...
