I've noticed that the type in generic declarations is not
"inherited" by new references to the object. This seems
inconsistent to me but maybe there's a good reason for it. To wit:

ArrayList<Stringlist1 = new ArrayList<String>();

ArrayList list2 = list;

list1.add(new Integer(3)); //compiler catches it as expected.
list2.add(new Integer(3)); //compiler is fat, dumb and happy.

I thought the idea of a reference was to point to the original
object and pick up all of the relevant data. Why not type?

jupiter <jupiter49byebyeSpam@msn.comwrote:Type inference is intentionally weaker than it could be. There are good
reasons for it, I suspect, but it annoys me sometimes.

To wit:List2 is explicitly NOT declared as a parameterized type. It happens to have
an ArrayList<Stringin it now, but you could assign it an ArrayList<Object>
later without error.
Right, because you told it to be.
Type is tricky. It's both a property of the variable and a property of the
referent. The object type can be more specific than the variable, and that's
how polymorphism works.

Note the similarity to:
LinkedList list1 = new LinkedList();
List list2 = list1;
list1.addFirst("first"); // allowed, addFirst is a method on LinkedList
list2.addFirst("first"); // disallowed, addFirst is NOT on the List interface
--
Mark Rafn dagon@dagon.net <http://www.dagon.net/>

"Mark Rafn" <dagon@dagon.netwrote in message
news:csvti4-qj1.ln1@hydra.dagon.net...Great piece of insight, Mark. I never differentiated between type
and other properties, so this is nice piece to become aware of.

Nice example indeed. This is yet another case of how implicit
casting can cause headaches for we normally-brained people.