Re: Closing Files that Weren't Successfully Opened
Michal Kleczek wrote:
Lew wrote:
Michal Kleczek wrote:
Robert Klemme wrote:
If you want BufferedReader you can do
final BufferedReader reader =
new BufferedReader(new InputStreamReader(new
FileInputStream("foo.txt")));
try {
for (String line; (line = reader.readLine()) != null;) {
System.out.println("Found line: " + line);
}
}
finally {
reader.close();
}
That only works because both InputStreamReader and BufferedReader
constructors don't throw.
But it is not safe to do the same for: final ObjectInputStream ois =
new ObjectInputStream(new FileInputStream("foo.txt"));
That's covered upthread five and a half hours prior to the cited post.
Maybe I'm missing it but could not find anything related.
It's my post from Mar 15, 1:17 am, New York time.
If you're talking about your post - there is still this
Well, duhhh.
new BufferedReader(new ...) thingy hanging around there
and nothing about watching out for leaked resources if both
chained constructors can throw.
Huh? Yes there is, too - it's called a 'catch' block. Notice that if
the constructors throw an exception in my example that it's caught and
all resources are guaranteed to be released, through the use of
'finally'.
You *did* notice that "this new BufferedReader(new ...) thingy hanging
around there" was inside a 'try...catch' structure, didn't you? How
is that "nothing about watching out for leaked resources"? You *did*
notice that the 'catch' blocks release resources if the whole shebang
doesn't allocate, didn't you? You *did* notice the 'finally' block
that guarantees (RAII-ishly!) release of resources at the end, didn't
you? If not, how could you possibly miss all that code in my post?
It was the largest part of it!
The whole freaking *point* of my post was to show one way to guarantee
release of resources!
Look, make all the legitimate points you want, but don't lie.
Sometimes it would be good to have destructors...
Nonsense. Destructors are to release memory.
Who told you that? :)
This is about external
resources.
And that is also something that destructors can (and should) release.
It's something that should be released, but not necessarily in a
destructor.
For proof, consider that Java doesn't have destructors yet you are
still perfectly capable of releasing resources in a guaranteed way
using 'finally'.
Please - google "RAII".
Which is what Java uses 'finally' for.
What Java needs are 'finally' blocks. Hey, good news! It's
got them! Yay! Problem solved!
The point is they are not really straightforward to use
and cause a lot of clutter in the code.
This is not only my opinion: introduction of "with" statement in C#,
proposed changes to Java 7 and this thread itself speak for themselves.
Yes, those add a little sugar, but they don't add new capability.
I guess one man's "clutter" is another man's explicit logic.
See my post that you erroneously claimed had "nothing" to release
resources for an example of how to guarantee resource release in Java
using 'try...catch...finally'.
--
Lew