with (Writer out = new FileWriter(”output.txt”)) {
…
}

Now you may say “If you let them use with, shouldn’t you teach them how it is implemented?”
If I follwed that logic, I surely should tell them how FileWriter is implemented. Let’s see. FileWriter is a simple wrapper around FileOutputStream. Here is the FileOutputStream constructor
public FileOutputStream(File file, boolean append)
throws FileNotFoundException
{
String name = (file != null ? file.getPath() : null);
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkWrite(name);
}
if (name == null) {
throw new NullPointerException();
}
fd = new FileDescriptor();
this.append = append;
if (append) {
openAppend(name);
} else {
open(name);
}
}

Ok, boys and girls. Listen carefully, for we have a long road ahead of us. Let me tell you about the SecurityManager…
I don’t think so.

So in this case, unless you are trying to teach about closures, your students shouldn’t see this code, but hopefully they’ll be able to read a document and understand it someday (if you are a decent professor).

Cheers,

Dion

<R, T extends java.io.Closeable, throws E>
R with(T t, Closure<T return R throws E> block) throws E {
. try {
.. return block.invoke(t);
. } finally {
.. try { t.close(); } catch (IOException ex) {}
. }
}

I agree with a lot that you are saying. Closures are like the conditional tense. It was great when I was twelve and could use “me gustaria” to get points for using the conditional tense. Often closures are so clearly a better way of doing things, so you use them without knowing “I am using a closure now”.

I love closures. I use a Closure.java. It will be great to have them as first class citizens in Java.

However, I worry that we are strapping on too much to Java itself. We don’t have to keep adding and adding and adding to Java the language. The beauty of Java is the top class VM and stdlib. Maybe we don’t have to keep throwing mud on the ball to “keep up with the jones’”.

Cheers,

Dion

My students are more likely to use addActionListener() {
stuff..
}

and understand it, than they are the anonymous class route.

Java just keeps pushing the bar up for other languages. Can you imagine a new popular statically typed language now without generics? Soon we won’t be able to imagine one without a good notation for closures.

By the way, I’m not sure how you think closures will affect your data structures lectures, unless you cover useful constructs like map, fold (reduce), etc., in which case they would certainly make it easier.

Sure, the standard “this is a drawing of a linked list, go and write your own” lecture isn’t going to be improved by closures, but isn’t it time to move on from that?