Re: Checking for null parameter
On Jun 11, 4:51 pm, pek <kimwl...@gmail.com> wrote:
On Jun 11, 4:07 pm, Lew <con...@lewscanon.com.invalid> wrote:
pek wrote:
OK... Let me take you back to what was the meaning of this whole
discussion because I believe that the thing is going out of hand. The
discussion was about CHECKING a null reference, not HANDLING. Here is
an example:
public class ChatExample {
private Connection conn;
public ChatExample() {
// I intentionally forget to instantiate the conn
}
public void connect() throws ConnectionException {
try {
conn.connect();
} catch (ConnectionExcetpion e) {
// Delegate the exception
throw new ConnectionException("Connection failed in Chat",=
e);
}
}
public sendMessage(String message) throws ConnectionException {
try {
conn.sendMessage(message);
} catch (ConnectionException e) {
// Delegate the exception
throw new ConnectionException("Couldn't send message in
Chat",e);
}
}
class Connection {
public void connect() throws ConnectionException {
// Do socket connection etc. etc.
}
public void sendMessage(String message) throws ConnectionExcep=
tion
{
// Send the message using sockets etc. etc.
}
}
}
public class Main {
public static void Main() {
// Catch and log any exceptions that wheren't planned without
crashing
try {
startProgram();
} catch (NullPointerException e) {
// Log it and inform user
} catch (Exception e) {
// Same here (probably combining with the above exception
wouldn't have any difference
}
}
private void startProgram {
// Do anything
// At some point you want to send a message
ChatExcample chat = new ChatExample();
chat.sendMessage("Hello world");
}
}
OK, now, did you notice that I forgot to instantiate the conn
attribute? That is a bug, which means that the user can NEVER send a
message simply because it is a NPE and it will stay that way no matter=
what.
For this sort of thing, use 'assert':
public class ChatExample {
private final Connection conn; // final added
public ChatExample() {
// I intentionally forget to instantiate the conn
assert conn != null;
}
public void connect() throws ConnectionException {
assert conn != null;
try {
conn.connect();
} catch (ConnectionExcetpion e) {
// Delegate the exception
throw new ConnectionException("Connection failed in Chat=
",e);
}
}
public sendMessage(String message) throws ConnectionException {
assert conn != null;
try {
conn.sendMessage(message);
} catch (ConnectionException e) {
// Delegate the exception
throw new ConnectionException("Couldn't send message in
Chat",e);
}
}
We assume some appropriate mechanism for invoking conn.close(), not show=
n here.
Now it is impossible to throw NPE. Problem solved.
As for rethrowing the ConnectionException, that is controversial. At =
some
point you should recover to correct program state instead of propagating=
the
exception. Also, in real life of course one would log the ConnectionE=
xception.
--
Lew
Oh, and by the way, did anybody read this:
"Do not use assertions for argument checking in public methods.
Argument checking is typically part of the published specifications
(or contract) of a method, and these specifications must be obeyed
whether assertions are enabled or disabled. Another problem with using
assertions for argument checking is that erroneous arguments should
result in an appropriate runtime exception (such as
IllegalArgumentException, IndexOutOfBoundsException, or
NullPointerException). An assertion failure will not throw an
appropriate exception. "
fromhttp://java.sun.com/j2se/1.4.2/docs/guide/lang/assert.html
Uhm, so I guess
public void connect() throws ConnectionException {
assert conn != null;
try {
conn.connect();
} catch (ConnectionExcetpion e) {
// Delegate the exception
throw new ConnectionException("Connection failed in Chat=
",e);
}
}
this would violate what you just read because a NullPointerException
isn't thrown.
Oops, OK, correcting my self. Your code doesn't violate that. ;) I
went to see if you tried to assert the message parameter, which you
didn't, which means that if conn isn't null, and message is, the
conn.sendMessage(message) with throw a NPE (assuming it will use a
method of String).
So, not checking if message is null was intentionally or not? And if
you didn't check it because it was a String, if it where a type of
Message, what would you do? Would you check with assert? Would you
manually check it? Or none of the above and let a NPE be thrown?