Using assert or exception?

Question

I have been struggling with the methodology of using assertions for some time
now and would like to have an objective viewpoint. It primarily has to
do with the use of assertions for pre-conditions.
Let's say we have some class, for demonstration purpose only, as this one:
public class MyClass {
    private final String str;
    public MyClass(String str)
        this.str = str;
    private int getLength(String x, String y)
        return x.length() + y.length();
    public int getTotalLength(String x)
        return  getLength(str, x);
}Let's say I want to make sure that the classes methods and constructor is not
called with any null parameter. Of course I will get a NullPointerException
eventually automatically anyway, but let's say I want to know as soon
as possible to something is wrong. Or maybe I am dealing with a complicated
class in which it is not so clear yet.
Anyway the Sun Java documentation says the following:
http://java.sun.com/j2se/1.4.2/docs/guide/lang/assert.html#preconditions
"Do not use assertions to check the parameters of a public method."
Instead it should throw some particular exception. In this case a
NullPointerException in the MyClass constructor if the str parameter is
null. Conventation say that assertion can be used for private methods
however, such as the getLength method.
I always try to keep my classes relatively small. So often I feel no desire
to include assertions in private methods to check parameters if I can
already see that the parameters are checked in the public methods.
So in this case why add assertions in getLength if I can already clearly
see that the parameters have been checked in the MyClass constructor and
the getTotalLength method?
Maybe I am wrong, but I am afraid that using such rigurous parameter testing
in every public method might influence performance too much, because in
contrary of assertions these normal checks are done always. I cannot
remove these normal checks, because that would mean it could trigger
an assertion in one of the private methods, and I could as well move
the assertions from the private to the public methods.
What I don't feel comfortable about is this big distinction between
assertions and run-time exceptions. Why not use assertions in
public methods for parameter testing? They are just exceptions
too anyway. And they have the benefit of not impacting performance
for production environments.
There is an article about challenging the Sun Assert convention here.
http://www.javaworld.com/javaworld/jw-12-2001/jw-1214-assert-p2.html
I would like you to read it and give your objective opinion. Weighing
the positive and negative implications of it and tell me what you
think and why.

Answer 1

I don't have the time to read that article. IMO
assertions are to be used to validate the state of
your instance and its internal works.So you do not think that assertions should be used for any pre-conditions of parameters?
They are not
exceptions, by the way. Failure will result in an
AssertionError.Yes, I should have said errors or throwables.
It's quite overkill IMO to use those for the
validation of parameters provided by someone else.Why? Isn't it overkill to impact the performance by
using run-time exceptions instead of assertions?
If
your API declares the legit value range of an
argument, a NullPointerException for null and an
IllegalArgumentException for values outside bounds,
that gives me more flexibility to react and handle
error states (it could be user input - null would
mean there's a bug, out of bounds would mean I have
to ask the user again) than merely firing of a "big"
assertion error.But the whole idea of pre-conditions is that the method never must be called with invalid values. Your example might make sense for some class close to the front-end, but most classes are deep inside everything and have no idea what to do with a NullPointerException or IllegalArgumentException at that point. I would let a facade near the front-end deal with invalid user input and explicitly prevent the invalid input progress deeper inside my code.
The article I linked goed deeper in about why it is a good idea to give a "big" assertion error at that point.
There's probably no hard or objective rule when you
should use what anyway, otherwise, there wouldn't be
different opinions in this matter. If you're looking
for one, you'll most likely not find it.I have certain ideas about assertions and I would like to know if these ideas are reasonable. Especially because they go against the Sun convention and I usually am a follower of standards.