[JulianMorrison]

I think you can avoid nesting finally thus:

    X x = null;
    Y y = null;
    try{
      x = foo();
      y = bar();
      yadda(x,y);
    } finally {
      if (x!=null) x.dispose();
      if (y!=null) y.dispose();
    }

[latch]

what happens if x.dispose() throws an exception?

if (x != null) try { x.dipose(); } catch (Exception){} }

it's why the using keyword is so nice. Still, this is all hoops languages force us to deal with when they shouldn't (which is the OPs point)

[JulianMorrison]

You're lucky Java is checked at compile time. Ruby would eat that "no such method dipose" and silently leak x.

[CodeMage]

You're lucky Java is checked at compile time.

Not lucky enough, because x.dispose() could throw an unchecked exception.

[mynameishere]

I was thinking the same thing, but replace your finally block with,

  Util.dispose(x,y);

...and let that handle all the possible issues.

[reverend_gonzo]

I've taken Groovy's with... syntax and built utils that are ie:

public void withConnection(Callback<Connection> callback) { Connection connection = createConnection(); try { callback.call(connection); } finally { connection.dispose(); } }

Once Java actually gets closures it'll make this soooo much nicer.