Class objects can be used as type specifications too, at runtime. For instance, you can create a generified method like this:
public static <T> T getInstance(Class<T> theClass)
throws IllegalAccessException, InstantiationException {
return theClass.newInstance();
}
Here are a few examples of calls to the getInstance() method:
String string = getInstance(String.class);
MyClass myClass = getInstance(MyClass.class);
As you can see the return type changes depending on what class object you pass in as parameter to the method. This can be quite handy in database API's like Butterfly Persistence where you read objects from a database. Here is an example method definition:
public static <T> T read(Class<T> theClass, String sql)
throws IllegalAccessException, InstantiationException {
//execute SQL.
T o = theClass.newInstance();
//set properties via reflection.
return o;
}
Here is how you would call the read() method:
Driver employee = read(Driver.class, "select * from drivers where id=1");
Vehicle vehicle = read(Vehicle.class, "select * from vehicles where id=1");
List<? extends Vehicle> vehicles = new ArrayList<? extends Vehicle>(); Vehicle. I can now define the printElements() method like this:public void printElements(List<? extends Vehicle> elements){
for(Vehicle o : elements){
System.out.println(o);
}
}Vehicle, as it is done by the new for loop inside the method. List<Car> instance, provided that Car extends Vehicle. Here is an example: List<Car> elements = new ArrayList<Car>
// ... add Car elements to the list.
printElements(elements);
List. After all, a Car is always a Vehicle, but a Vehicle is not always a Car.'?' is a wild-card character and it stands for any Java type. It can be java.lang.Object type or some other type. It is just a place-holder that tells that it can be assigned with any type. Considering this case, the following are now valid syntaxes. List<?> anyObjects = null;
List<Integer> integers = new ArrayList<Integer>();
anyObjects = integers;
List<Double> doubles = new ArrayList<Double>();
anyObjects = doubles;
List using the wildcard operator:List<?> listOfUnknown = new ArrayList<?>();
printElements() method like this:public void printElements(List<?> elements){
for(Object o : elements){
System.out.println(o);
}
}
You can call the
printElements() with any generified List instance. For instance: List<String> elements = new ArrayList<String>
// ... add String elements to the list.
printElements(elements);
When you upcast a
List<String> to a List<?> you can now read all elements of the List<?> safely as Object instances. But you still cannot insert elements into the List<?>. The ? could represent any type, and thus it would be possible to insert types that did not match the original definition of the List. Let’s test our understanding of generics. Is the following code snippet legal?
List<String> ls = new ArrayList<String>(); //1List<Object> lo = ls; //2
Line 1 is certainly legal. The trickier part of the question is line 2. This boils down
to the question: is a List of String a List of Object. Most people’s instinct is to answer:
“sure!”.
Well, take a look at the next few lines:
lo.add(new Object()); // 3String s = ls.get(0); // 4: attempts to assign an Object to a String!
Here we’ve aliased ls and lo. Accessing ls, a list of String, through the alias lo, we
can insert arbitrary objects into it. As a result ls does not hold just Strings anymore,
and when we try and get something out of it, we get a rude surprise.
The Java compiler will prevent this from happening of course. Line 2 will cause a
compile time error.
In general, if Foo is a subtype (subclass or subinterface) of Bar, and G is some
generic type declaration, it is not the case that G<Foo> is a subtype of G<Bar>.
This is probably the hardest thing you need to learn about generics, because it goes
against our deeply held intuitions.
So we had list of String not subtype of list of Objects.
The problem with that intuition is that it assumes that collections don’t change.
Our instinct takes these things to be immutable.
For example, if the department of motor vehicles supplies a list of drivers to the census
bureau, this seems reasonable. We think that a List<Driver> is a List<Person>,
assuming that Driver is a subtype of Person. In fact, what is being passed is a copy
of the registry of drivers. Otherwise, the census bureau could add new people who are
not drivers into the list, corrupting the DMV’s records.
In order to cope with this sort of situation, it’s useful to consider more flexible
generic types. The rules we’ve seen so far are quite restrictive.
java.util:
public interface List<E> {
void add(E x);
Iterator<E> iterator();
}
public interface Iterator<E> {
E next();
boolean hasNext();
}
public interface IntegerList {
void add(Integer x);
Iterator<Integer> iterator();
}
List myIntList = new LinkedList(); // line no. 1
myIntList.add(new Integer(0)); // line no. 2
Integer x = (Integer) myIntList.iterator().next(); //line no. 3
List<Integer> myIntList = new LinkedList<Integer>(); // 1’
//OR
List<Integer> myIntList = new LinkedList(); // 1’
myIntList.add(new Integer(0)); //2’
Integer x = myIntList.iterator().next(); // 3’