Re: A problem regarding generics
On 6/6/2010 7:02 AM, Vikram wrote:
Hi,
In java generics, the following code gives compile time error.
List<Object> list = new ArrayList<String>(); // compile time error
I'll rewrite this slightly, to make it easy to refer
to the left-hand and right-hand sides independently:
List<String> slist = new ArrayList<String>();
List<Object> olist = slist; // compile error
When we fetch something from slist, we know that we'll get a
String, right? That's the purpose of the <String> notation: It
tells the compiler to complain if we try to put a non-String into
slist. Since the compiler will ensure that we never put anything
except Strings into slist, we know we will get only Strings out.
Suppose, though, that the second line were legal, and that we
could get olist to refer to the same ArrayList object as slist.
Now, we could do
olist.add("forty-two");
olist.add(new Integer(42));
olist.add(new Double(42.0);
olist.add(new Color(42, 42, 42));
olist.add(new JLabel("42"));
.... since all of the things we are adding are Objects, and hence
are acceptable to the <Object> notation of olist. Clear?
But olist and slist refer to the same ArrayList, so what happens
when we start fetching things from slist? We get all the things
that were added through olist. Are they all Strings? Obviously not.
What next? ClassCastException -- the very run-time error generics
were invented to prevent.
Where as the following does not give any compile time error
List list = new ArrayList<String>();
Here, the `list' List makes no guarantees. The compiler will
allow you to add anything at all via the `list' reference. Also,
the compiler will not assume that everything you fetch from `list' is
a String. By omitting all <> notation, you are telling the compiler
that all bets are off: You and you alone are responsible for what
goes into and what comes out of the List, and the compiler will not
try to prevent you from doing something silly.
If no generics is specified, isin't it implied that it contains
object? What is the reason the second statement does not give any
compile time error?
Mostly for interoperability with Java code written before generics
came along. Suppose you are using somebody else's class, written in
the pre-generic days, that has a method like
/** Do something to a List of Strings.
* @param list A List containing Strings.
* @throws ClassCastException if "list" contains any
* non-Strings.
*/
void doSomething(List list) {
for (Iterator it = list.iterator(); it.hasNext(); ) {
String s = (String)it.next();
...
}
}
You, being a modern and forward-looking person, are using generics
in your own code, and since you need a List containing Strings and
nothing but Strings, you've built a List<String>. Now, you'd like
to call this other class' doSomething() method on your List<String>,
but doSomething() takes a plain List. Clearly, your List<String>
meets all the requirements of the List that doSomething() wants, so
this should be allowed. And that, more or less, is why it's all
right to use a "decorated" generic object where an "undecorated"
non-generic version is called for.
The on-line Java Tutorial has a section on generics that you
might find helpful:
<http://java.sun.com/docs/books/tutorial/java/generics/index.html>
--
Eric Sosman
esosman@ieee-dot-org.invalid