之间的区别 <T extends A> void foo（T t）和void foo（A a）

Question

Say A is an interface. What is the difference between

public <T extends A> void foo(T t) { ... }

and

public void foo(A a) { ...}

?

Answer 1

There isn't a difference when using one object. But imagine if you had

class B extends A { ... }

and

public void f(List<A> list) { ... };

and

public <T extends A> void f(List<T> list) { ... };

with the first one you can pass a list that is exactly of type List<A> . With the second one you can pass a list which contains objects that extend A . However, with the first one you cannot do the same thing. So in other words you could not pass List<B> to the first method but you could to the second method.

Answer 2

Not much.

On the other hand, consider this method:

public <T extends A> T transform(T t);

And caller code:

class B implements A { ... }
B result = transform(new B(...));

It wouldn't be possible (above wouldn't compile, as compiler would force you to declare result type as A ) had you declared method as

public A transform(A a)

Answer 3

There is no difference in your case because the type parameter is used in one place only. Both methods will accept anything that is an A or extends A. The generic method would make more sense in this case because the type parameter let you tie the return value to the passed parameter:

public <T extends A> T f(Class<T>) {...}

Answer 4

Whether it makes a difference depends on what's inside that function.

The point of generics is to insure type safety. Suppose A has two subclasses, let's call them B and C. In the first example, using f(List<A>), the list could include B's, C's, or a mixture of both. But in the second example, f<T extends A>(List<T>), when we invoke the function we must specify the type. If we say f<B>, then we know this is a list of B's, no C's allowed. We will not be allowed to pass in a list of C's or generic A's, we cannot add any C's to the list, and anything we take out will be guaranteed to be a B.

Whether this is good or bad depends on what you're trying to do. If the idea is that you want a list that is either all B or all C, then the generic helps guarantee this. If you want a list that can be a mix of the two, then you don't want to use the generic, use the simple f(List<A>).