On Mar 8, 8:47 am, Christopher Benson-Manica
<a...@ukato.freeshell.org> wrote:

It seems a bit excessive to create a whole new object, just to call a
method on it. How about a static method?

public class Bar extends Foo {
 // Foo has one constructor, taking a List<String> as an argument
 public Bar(final Object... args) {
   super( convert(args) );
 }

 private static List<String> convert(Object...args) {
   final List<String> list = new LinkedList<String>();
   // Transform args into String's and put them in the list
   return list;
 }
}

You do not show Foo but as Daniel said already, basically you are
invoking Foo(List<String> list).  The situation would be different if
you did not invoked call() and just handed the Callable to Foo's
constructor.  Having said that, yes, use a static method as Daniel
pointed out already.

Kind regards

    robert

God help us -- that's /vile/ !

I'd use a static helper.   Or, if that turned out to be impossible, take it as
a very strong indication that the design was a pile of crap and start again.

BTW, I question whether that idiom is really legal.  Or, if it should turn out
to be within the letter of the JLS law, whether it /should/ be legal.

The problem is that it makes use of a reference to the object under
construction (using it to create the instance of the inner class) before the
superclass's constructor has been invoked.  That is forbidden in every other
part of the Java design.  It is OK, however foolish, to pass around references
to "this" after the superclass constructor has returned, but before your own
constructor is complete; but it is /not/ OK to do so before calling the
superclass constructor.

In fact I'm somewhat surprised that it passed verification in the JVM -- there
are strict rules about what you can do with a reference to a allocated-but-not
fully-initialised object, and until the call to the superclass constructor has
returned, "this" is in an illegal state.

   -- chris