Re: Array of ArrayLists problem
In article <i11nnc$udp$1@news.albasani.net>, Lew <noone@lewscanon.com>
wrote:
Kevin McMurtrie wrote:
[...]
public class Foo<BAR>
{
class InnerFoo { }
void method ()
{
InnerFoo x[]= new InnerFoo[100]; //Doesn't compile
}
}
Peter Duniho wrote:
I'd guess the answer to that may actually be specifically addressed in
the spec too.
But even if not, it seems to me that your example is just a variant on
the situation that's already being discussed. The above version of the
code involves a non-reified generic type (Foo<BAR>.InnerFoo), of which
you can't make an array, and for the same reason as indicated before.
By explicitly choosing the raw type to qualify InnerFoo, you strip the
generic and thus create a legal array type. Note that while the third
example compiles, you do get a warning about the need for an unchecked
conversion. That's only slightly better than it simply not compiling at
all.
I wonder if a non-inner nested class member would have this trouble. I also
wonder if
InnerFoo x[] = new this.InnerFoo [100];
or something along those line would work.
I'll try that later myself, along with variations for a local class (which I
expect not to). One wonders about inner classes in a static context, albeit
less so.
I've been shot down in this forum before for he suggestioon that an
inner-class definition belongs to a particular enclosing-class instance (as
opposed to the inner-class *instance* belonging to an instance), and there
definitely are limits to that mental model, but it works out to be a handy
way
to look at things most times.
Eclipse says "new this.InnerFoo [100]" doesn't compile. You can use
"(InnerFoo[])Array.newInstance(InnerFoo.class, 100)"
The annoying thing about the example that I gave is that the declaration
of the array works fine. There's nothing special about allocating the
array that should make it any different when Generics are involved.
Java Generics are a handy tool but the implementation is flawed enough
that I can see it hindering future language improvements. I would have
preferred something like C++ templates even if it meant redoing a lot of
the java.util package. Besides being more powerful, it would eliminate
the need for horribly inefficient autoboxing of short, char, int, long,
float, and double.
--
I won't see Google Groups replies because I must filter them as spam