Re: Throwing Constructor Exceptions and cleaning up
Lew wrote:
Peter Duniho wrote:
I hope that between Eric's and my own previous reply, you understand
how you've misconstrued what I've written.
I have not.
Then you're putting on an awfully good act. It's
fooled me, that's for sure.
A brief reiteration: when I write "the fail-safe behavior isn't
needed", I'm not talking about for the class generally. I'm talking
about for a specific instance of the class, where the class _does_
need the fail-safe behavior, but because of the way the _instance_ has
been used, the _instance_ itself can safely skip that fail-safe step
during garbage collection.
Apparently you misconstrued my point, which is that the need to do such
a thing is obviated by using something other than a 'finalize()'
override to do that cleanup.
Apparently you've missed what both Peter and I are
discussing, which is the use of finalize() as a last-gasp
safety net, a piece of defensive coding that may (*may*)
help detect and perhaps recover from somebody's failure to
use a class correctly.
Imagine: I write a class that requires cleanup, and I
endow it with a dispose() or close() or sayonara() method
to do that cleanup, and I write Javadoc informing the user
of my class that the method is to be called when the class
instance is no longer needed. All well and good, and if
every programmer who uses my class heeds the Javadoc and
never makes a mistake, things are hunky-dory.
But then it occurs to me that some programmers are as
fallible as I am myself, and may forget to call dispose()
or make some little error that allows the dispose() call
they've written to be bypassed. And I think, "Wouldn't it
be helpful if my class made an effort to alert the programmer
about the bug?" So I give my class a finalize() that does
protected void finalize() throws Throwable {
try {
if (not_disposed_yet) {
ringTheAlarmBells();
dispose();
}
}
finally {
super.finalize();
}
}
That is, it does nothing out of the ordinary if the instance
has been cleaned up as per contract, but raises red flags if
an instance becomes garbage prematurely. Clear?
In a perfect world this finalize() never does anything,
because programmers never make mistakes. If that's the world
you live in then I envy you, and I imagine others do, too.
But some of us have not yet attained the degree of enlightenment
that allows us to inhabit your Nirvana, so we're reduced to
relying on imperfect but practical measures. Pity us if you
will, but don't mock us, okay?
--
Eric Sosman
esosman@ieee-dot-org.invalid