Lower bound wildcards in java – how to apply the get and put principle
I recently saw an answer to a generics question on stack overflow where an incorrect (or at least misleading) answer has been voted up to the top. Sometimes generics are just a bit unintuitive.
Here is the example in a nutshell -
l.add(new Object());
}
// That should work, right? After all List<? super Shape> is defined so that it can hold
// any objects which implement a superclass of Shape....
In fact, the code above would not compile. That’s the wrong way to interpret the lower bound wildcard. The variable l actually refers to a List which may be restricted to contain any valid superclass of Shape – and we don’t know exactly what type of List it is from the lower bound reference. It may actually be a List of Drawable (if Shape extends Drawable), in which case adding an Object to it would not be safe – since an Object is not necessarily Drawable. It may also be a List of Shape instances (since Shape is the lower bound), in which case adding an Object to it would also be invalid. That’s why the example above does not compile.
There is an important principle set out in Java Generics and Collections, called the ‘Get and Put Principle’ which helps to explain when to use lower and upper bound wildcards
Use an extends wildcard when you only get values out of a structure, use super wildcard when you only put values into a structure, and don’t use a wildcard when you both get and put.
Proper use of this rule can make your classes more flexible. Partly to make sure I’ve got this fully straightened out in my own head, I’ve put together an example which illustrates the get and put principle, and helps to explain upper and lower bound wildcards:
private class Drawable {}
private class Shape extends Drawable {}
private class Circle extends Shape {}
public void testPut() {
putShapeInto(new ArrayList<Object>());
putShapeInto(new ArrayList<Drawable>());
putShapeInto(new ArrayList<Shape>());
}
//flexible - can take a List of any superclass of Shape
public void putShapeInto(List<? super Shape> l) {
// We don't know what the type of list l is, but we know it is Shape or a superclass of Shape
// therefore, it is always a valid destination for Shape instances
l.add(new Shape());
// l.add(new Object());
// ...will not compile. The type of l may be any valid superclass of Shape
// e.g. It may be <Drawable>, not all Objects are Drawable
// Shape s = l.get(0);
// ...will not compile. l may be List<Drawable>, and not all Drawables are necessarily Shapes
}
public void testGet() {
getShapeFrom(new ArrayList<Shape>());
getShapeFrom(new ArrayList<Circle>());
}
//flexible - can take a List of any subclass of Shape
public void getShapeFrom(List<? extends Shape> l) {
// because the upper bound of list l is Shape, l is always a valid source for Shape instances
Shape s = l.get(0);
// l.add(new Shape());
// ...will not compile, the type of l may be List<Circle>. Shapes are not all Circles
}
// Can add and get, but not very flexible - the method is limited to accepting Lists of type <Shape>
public void testPutAndGet(List<Shape> l) {
Shape s = l.get(0);
Drawable d = l.get(0);
l.add(new Shape());
l.add(new Circle());
}
You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.
Leave a Reply