What are the usage wildcard or Bounded type parameters in Java Generics?

Question

I have always use java Generics with existing collections API and know that it provide compile time type safety.

But I am confused with using wildcard or Bounded type parameters in my classes . Could someone clarify what is the pros of using these when compiler type Erasure actually replaces it with base types. Why should not we direct code to base classes

As an example from java tutorial (http://docs.oracle.com/javase/tutorial/java/generics/genMethods.html)

You can write a generic method to draw different shapes:

public static <T extends Shape> void draw(T shape) { /* ... */ }

The Java compiler replaces T with Shape:

public static void draw(Shape shape) { /* ... */ }

So Why we should not write directly to take Shape parameter, what is benefit of using wildcard or Bounded type?

None, in this particular case. If you were returning, say, a `List`, then it would be different. — Louis Wasserman, Mar 13 '14 at 16:45
Try with a `List` and `List` and pass `List` to both the methods. — Rohit Jain, Mar 13 '14 at 16:46
There are certain things you can do with generic bound types that you can't do with just the base interface; for example, you can specifically return objects of type `T` from methods (otherwise you'd be limited to returning the base interface and casting to subclasses). Also what previous comments said about e.g. `List`. — Jason C, Mar 13 '14 at 16:53
By the way: "*The Java compiler replaces T with Shape*". It does not. It replaces it with whatever subtype you pass, it just enforces that that type is a subtype of `Shape`. — Jason C, Mar 13 '14 at 16:57

score 2 · Accepted Answer · edited May 23 '17 at 12:34

2

In your example there is absolutely no benefit.

Consider the following method signature

public static <T extends Shape> void draw(List<T> shapes) { /* ... */ }

I can do the following

final List<Circle> circles = /* ... */
final List<Square> squares = /* ... */

draw(squares);
draw(circles);

Which I cannot do with

public static void draw(List<Shape> shapes) { /* ... */ }

This especially important with PECS type situations.

edited May 23 '17 at 12:34

Community

1
1

answered Mar 13 '14 at 16:59

Boris the Spider

59,842
6
106
166

I like this answer as one like @Rohit. But is this not because of the limitation of Generics not supporting polymorphism and this is the way around if one want to use List? – user3415845 Mar 13 '14 at 17:43
@user3415845 this has nothing to do with polymorphism, this has to do with covariance. Not sure what you are asking in the second part. – Boris the Spider Mar 13 '14 at 17:57
please correct if I am wrong. Going with above code if Circle is subtype of Shape that does not mean List too is subtype of List and to overcome we use as List extends Shape>. Then why don't we directly code for base/super type? – user3415845 Mar 13 '14 at 22:05
@user3415845 I don't understand the question. I have a method that processes collections of `Shape` and I want it to be able to accept collections of a subtype. I have to declare a bounded wildcard in order to allow this behaviour. – Boris the Spider Mar 13 '14 at 22:13
excuse me for my bad English grammer, its not my native tongue ;). But I think I got what you mean, wildcard/bounded type are used to fascilate subtypes under collections of supertypes. Thanks a lot for being patient with me. – user3415845 Mar 13 '14 at 23:35
@user3415845 not just collections, any generics - in Java `MyClass` is not a subtype of `MyClass` when `A extends T`; this is call covariance. We would say "MyClass is invariant in `T`". There's [a picture](http://stackoverflow.com/a/19739576/2071828) that illustates the concept quite well in the context of PECS. – Boris the Spider Mar 14 '14 at 08:10
Even in this example, it can be done with `public static void draw(List extends Shape> shapes)`. You need a more complicated example for the type parameter to be necessary. – newacct Mar 14 '14 at 22:18
@newacct true. If the method accepted a second type, `final T shape` then parameter would be neccessary. – Boris the Spider Mar 15 '14 at 08:34

score 0 · Answer 2 · edited May 23 '17 at 10:33

With generics the code is type safe and your collections are type safe. That means that more problems will be caught at compile time and not run time.

Without generics,

an ArrayList would be an ArrayList of type object and that means that you can put anything in it.

Generics allow you to make sure whatever you put in the ArrayList is of a specific type. For example if you want to create an ArrayList, you can only put in Cars objects and not anything else.

is simply a placeholder for whatever you actually want. If your program only wants to create an ArrayList of cars and never create different types, you could just as easily use the placeholder instead of E throughout your program.

The thing is, it is important to be able to create different types and do different operations on all different types of objects, so your class that creates the ArrayList will usually be E is for 'element' and then in your other classes, you would create the specific type.

FOR YOUR QUESTION>>>> SEE THIS LINK Java: bounded wildcards or bounded type parameter?

What are the usage wildcard or Bounded type parameters in Java Generics?

2 Answers2