8

I am a little confused with something.

I have a class where its not a collection, but it does refer to generic objects:

 public class XClass<E extends AnInterface>{ E instanceobject; public void add(E toAdd){} } public interface AnInterface{} public class A implements AnInterface{} public class B implements AnInterface{}

I believe I read somewhere that <? extends AnInterface> is to be used (when declaring an instance of XClass) if you want multiple subtype-types in the generic object at the same time, whereas <T extends AnInterface> would only allow you to have a single type of subtype in the generic class at once?

However, I can just use:

 XClass<AnInterface> xc = new XClass<AnInterface>(); A a = new A(); B b = new B(); xc.add(a); xc.add(b);

and this way I can pass in multiple subtypes of Supertype to the generic class......

I am not seeing the purpose of using "?" and is there anything wrong with using the Interface as the generic parameter?

Improve this question

4 Answers 4

Reset to default
8

The reason why you can add objects of both type A and B is due to the fact that you parametized your XClass with the interface, so there is nothing wrong with adding two different classes that implement that interface.

If, on the other hand, you had defined XClass as:

XClass<A> xc = new XClass<A>();

then the expression xc.add(b); would give a compilation error, since all the objects added must have the same type as was declared, in this case, A.

If you declare you xc as, for instance:

XClass<? extends AnInterface> xc = new XClass<AnInterface>();

Then it's not legal anymore to add a or b, since the only thing we know is that xc is of some unknown but fixed subtype of AnInterface, and there is no way to know if that unknown type is A or B or anything else.

But let's say you're writing a method to accept a XClass type that you can iterate over the elements that were added before. Your only restriction (for the sake of the example), is that the items extend AnInterface, you don't care what the actual type is.

You can declare this method like:

public static void dummyMethod(XClass<? extends AnInterface> dummy){ //do stuff here, all the elements extend (implement in this case), AnInterface, go wild. }

And now you can pass into this method anything like XClass<A>, XClass<B> or XClass<AnInterface>, and it will all be valid.

Keep in mind that you can't add to the object you pass, for the same reason above. We don't know what the unknown type is!

public static void dummyMethod(XClass<? extends AnInterface> dummy){ //do stuff here, all the elements extend (implement in this case), AnInterface, go wild. dummy.add(new A()); //you can't do this, we have no idea what type ? stand for in this case }
Improve this answer
Sign up to request clarification or add additional context in comments.

4 Comments

Ah cool- I completely get this! So is there any point in using "?" wildcard
? extends Foo means there is some fixed, but unknown, type that extends Foo that is the "actual" generic parameter.
Added an example of a usage of the ? wildcard. Hope it's more explicit now.
Nicely put Louis, made it easier to complete my answer, thanks.
0

You can use E if you want to have an instance of XClass to use only one subclass of AnInterface and no other Classes implementing AnInterface that do not extend / implement E.

For example given public class ClassOne implements AnInterface {} and public class ClassTwo implements AnInterface {}

If you were to use public class XClass<E extends AnInterface> and <ClassOne>XClass xc = new <ClassOne>XClass() then you can only use an object of ClassOne in your add method not one of ClassTwo. Using ? would allow you to pass in any class implementing AnInterface, either ClassOne or ClassTwo.

Using Identifier E means "For this object I want to use type E and any subclasses", using ? means "I want to use any type that matches the the expression"

Improve this answer

Comments

0

In your example you need type erasure in the method "add", so you should't use wildcards in your class.

Wildcards are only to be used when you do not need type erasure (i.e. you don't care about the type as long as it is a subclass of..) and also when you will need to subtype the generics itself.

Improve this answer

Comments

0

The wildcard simply means that it will be some class that meets that criteria. So ? extends AnInterface means it will be one (and only one) class that extends AnInterface.

So it could be:

XClass<Impl1> XClass<Impl2>

etc...

However, at runtime, you don't know what that class will be. For this reason calling methods which take the actual type as a parameter is inherently unsafe, since it's impossible for the compiler to know if the parameter is appropriate for the actual instantiated instance.

Take lists as an example. Something might be declared like this:

List<? extends Number> list = new ArrayList<Integer>();

What would happen if you try to do either of these:

list.add(new Double(0)); list.add((Number) new Long(1L));

It would not compile, because the generic parameter type is unknown at compile time. So the compiler can't tell if Double or Number would be appropriate to pass to the actual instance (in this case ArrayList<Integer>). This is when you get the infamous capture-of compile error.

This, however is permissible, since you know for certain at compile time that the list can take any instance of Number (which includes subclasses).

List<Number> list = new ArrayList<Number>(); list.add(new Double(0)); list.add((Number) new Long(1L));
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.