Generics references

[jupiter]

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?

[Mark Rafn]

jupiter <ju*****************@msn.comwrote:

>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.

Type inference is intentionally weaker than it could be. There are good
reasons for it, I suspect, but it annoys me sometimes.

To wit:

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

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.

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

Right, because you told it to be.

>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?

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 da***@dagon.net <http://www.dagon.net/>

[jupiter]

"Mark Rafn" <da***@dagon.netwrote in message
news:cs************@hydra.dagon.net...

jupiter <ju*****************@msn.comwrote:

>>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.

Type inference is intentionally weaker than it could be. There
are good
reasons for it, I suspect, but it annoys me sometimes.

To wit:

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

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.

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

Right, because you told it to be.

>>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?

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.

Great piece of insight, Mark. I never differentiated between type
and other properties, so this is nice piece to become aware of.

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

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