What you call a robust method?

Question

in my project X, i am writing a method whose parameter should not be null, like the following:
public class MyClass {
  public void myMethod(MyObject obj) {
    if (obj!=null) {
      // do something.
    return;
}In order to make my method robust, i have several choices, but i dont know which coding style is the best.
1, do not check obj, and if it is null, NullPointerException will be thrown out automatically when i use the null object.
2, check the obj and throw out a runtime exception (NullPointerException or IllegalArgumentException) myself, like this:
public void myMethod(MyObject obj) {
  if (obj==null) {
    throw new NullPointerException("MyObject cannot be null.");
  // do something...
  return;
}3, check the obj and throw out a self-defined exception, like this:
public void myMethod(MyObject obj)
throws MyException {
  if (obj==null) {
    throw new MyException("MyObject cannot be null.");
  // do something...
  return;
}At my point of view, the first one cares nothing about the legality of its parameter, and thus is not robust enough. The second one is silly because i have to add the same code at the beginning of all my methods. The third one is even sillier because i have not only to add the same code at the beginning of all my methods, but also to catch exception everytime i call them...
So...who can give me some advices?
thanks.

Answer 1

This is not a problem to do with robustness, this is a reliabilityproblem.
Reliability means that the operation behaves in a predictable manner regardless of the environment.
Robustness means being able to act in a predictable manner regardless of the circumstances without causing unexpected exceptional conditions.
If you leave out the null reference check your method will act reliably in that a NullPointerException will be thrown at the point where the instance is referenced.
To make your method robust you have to be active in what you do, in this case throwing a NullPointerException as a result of the check for null makes sense as you control the message in the exception rather than relying on the default one.
Throwning an IllegalArgumentException is not the correct thing to do. The problem here is that there is no argument passed here rather null (no value). If you do further checks in the method for legal values and then your method considers the value passed to be outside of constrainst then throwing IllegalArgumentException is the correct thing to do.
Creating your own class of Exception or RuntimeException for this purpose is a decision you have to make for yourself. If the argument checks are supposed to be rigorous then checked exceptions (subclasses of the Exception class) should be used to force callers of your method to handle the potentional exceptional condition. In this case it makes sense to create and use your own Exception class. If they are not rigorous then NullPointerException and IllegalArgumentException are probably sufficient.
You should look at the Tutorials here for help on how the JavaBeans framework for property change support works as well, it provides some helpful insights into this problem.