[Java-gnome-developer] I feel useful

[Dan B. <da...@mi...>]

I've been browsing the documentation and came across the part about how
variable arguments are handled (Appendix B in the parser doc). The method
currently used seems to be to make a bunch of methods with 0..N extra
arguments at the end.

For extremely time-critical code, this is definitely the way to go.
However, most of the time, I'd recommend just taking an array of the
appropriate type. Actually, there's a proposed change to the Java language
(well, it's a JSR in-progess, at least, and seems likely to be approved)
which would make it syntactically easy to write an array of type Object,
so, I'd even be willing to forego the compile-time typecheck to get the
better syntax. (After all, it's easy enough to generate the cast.) See this
URL for details on the proposal:

    <http://java.sun.com/aboutJava/communityprocess/jsr/jsr_065_cncsarray.html>

The brief synopsis is that the following two forms would become equivalent:

    foo.bar (a, b, new Object[] { c, d, e })
    foo.bar (a, b, { c, d, e })

If you still have some efficiency concerns, my usual recommendation is
to provide a limited number of separate-arg versions (e.g., for 0 to 2
args) and then provide the array version as a catch-all, e.g.:

    public void meth (String s);
    public void meth (String s, Foo foo1);
    public void meth (String s, Foo foo1, Foo foo2);
    public void meth (String s, Foo[] foos); // or Object[] foos

Hope you find this useful,

-dan