In one of my recent posts, I talked about checking method parameters using a utility that throws IllegalArgumentException when a parameter was deemed invalid. The whole point of this check is to prevent a more convoluted exception from certainly happening later on, and using the IllegalArgumentException to give the developer some useful message about what’s allowed or not allowed.
The post generated some good comments. For example, my post didn’t really make too clear that checking method parameters is not a replacement for checking the validity of input data (e.g., data provided by a user, say via a form, or data provided to a database). There are a lot of neat frameworks for doing that, including Commons Validator and Hibernate Validator to name two.
I wanted to follow up on my previous discussion, though, and discuss checking method parameters using Java assertions. In general, this is a bad idea. For one thing, checking arguments with a static utility method (e.g.,
ArgCheck.isNotNull(...)) should be very fast. Second, assertions can be disabled, and doing so shouldn't change the behavior of the code. (This is why I'd argue that continuous integration should be run with and without assertions.)
The major requirement for using
assert is that removing the assertion should not change the flow of the code - called control flow invariance. This means that using assert for checking parameters