This may be a fairly subjective question, but maybe not. My application contains a bunch of forms that are displayed to the user at different times. Each form is a class of its own. Typically the user clicks a button, which launches a new form.

I have a convenience function that builds these buttons, you call it like this:

buildButton( "button text", new SelectionAdapter() {
     @Override
     public void widgetSelected( SelectionEvent e ) {
        showForm( new TasksForm( args... ) );
     }
  } );

I do this dozens of times, and it's really cumbersome having to make a SelectionAdapter every time.

Really all I need for the button to know is what class to instantiate when it's clicked and what arguments to give the constructor, so I built a function that I call like this instead:

buildButton( "button text", TasksForm.class, args... );

Where args is an arbitrary list of objects that you could use to instantiate TasksForm normally.

It uses reflection to get a constructor from the class, match the argument list, and build an instance when it needs to. Most of the time I don't have to pass any arguments to the constructor at all. The downside is obviously that if I'm passing a bad set of arguments, it can't detect that at compilation time, so if it fails, a dialog is displayed at runtime. But it won't normally fail, and it'll be easy to debug if it does.

I think this is much cleaner because I come from languages where the use of function and class literals is pretty common. But if you're a normal Java programmer, would seeing this freak you out, or would you appreciate not having to scan a zillion SelectionAdapters?