泛型类型变量的限定

泛型的基础知识可以参考其他教程。

如果在方法前指定了<T>，那么就是说，方法的这个泛型类型和类定义时的泛型类型无关，这个特性让泛型方法可以定义在普通类中而不是泛型类中。

我们都知道，泛型中可以限定类型变量必须实现某几个接口或者继承某个类，多个限定类型用&分隔，类必须放在限定列表中所有接口的前面。例如：

[java] view plain copy

print?

1. import java.io.Serializable;
2. /**
3. * ICE
4. * 2016/10/17 0017 14:12
5. */
6. public class Demo {
7. public static void main(String[] args) {
8. D<A> d = new D<>();
9. A a = new A();
10. d.test1(a);
11. B b = new B();
12. d.test1(b);
13. C c = new C();
14. d.test1(c);
15. d.test2("test");
16. }
17. }
18. class A implements Serializable, Cloneable {
19. @Override
20. public String toString() {
21. return "A{}";
22. }
23. }
24. class B extends A {
25. @Override
26. public String toString() {
27. return "B{}";
28. }
29. }
30. class C extends A {
31. @Override
32. public String toString() {
33. return "C{}";
34. }
35. }
36. class D<T extends A & Serializable & Cloneable> {
37. public void test1(T t) {
38. System.out.println(t);
39. }
40. public <T> void test2(T t) {
41. System.out.println(t);
42. }
43. }

输出：

[plain] view plain copy

print?

1. A{}
2. B{}
3. C{}
4. test

通配符类型

通配符“？”同样可以对类型进行限定。可以分为子类型限定、超类型限定和无限定。通配符不是类型变量，因此不能在代码中使用"?"作为一种类型。

子类型限定

表示类型的上界，类似泛型的类型变量限定，格式是：？ extends X。

特点：

1、限定为X和X的子类型，但不知道具体是哪个子类型，可能是怕导致类型转换错误（比如向下转型时编译不会报错，但是如果超类引用不是指向子类对象，那么运行时会报错），所以作为方法的参数时，这里禁止传递特定的类型。

2、作为方法的参数时，可以传递null。

作用：主要用来安全地访问数据，可以访问X及其子类型。

[java] view plain copy

print?

1. import java.util.ArrayList;
2. import java.util.List;
3. /**
4. * ICE
5. * 2016/10/17 0017 14:12
6. */
7. public class Demo {
8. public static void main(String[] args) {
9. A a = new A();
10. B b = new B();
11. C c = new C();
12. List<A> list = new ArrayList<>();
13. list.add(a);
14. list.add(b);
15. list.add(c);
16. //根据list的值，我们可以给列表中的对象做<? extends A>限定，因为都是A和A的子类，get返回值赋给A是完全合法的
17. List<? extends A> list1 = list;
18. list.add(null);
19. for (int i = 0; i < list1.size(); i++) {
20. A a1 = list1.get(i);
21. System.out.println(a1);
22. }
23. //这里如果set任何非null的值，编译器都会报错
24. D<? extends A> d = new D<>();
25. d.set(null);
26. }
27. }
28. class A {
29. @Override
30. public String toString() {
31. return "A{}";
32. }
33. }
34. class B extends A {
35. @Override
36. public String toString() {
37. return "B{}";
38. }
39. }
40. class C extends A {
41. @Override
42. public String toString() {
43. return "C{}";
44. }
45. }
46. class D<T> {
47. public void test1(T t) {
48. System.out.println(t);
49. }
50. public void set(T t) {
51. }
52. }

输出：

[plain] view plain copy

print?

1. A{}
2. B{}
3. C{}
4. null

超类型限定

表示类型的下界，格式是：？ super X。

特点：

1、限定为X和X的超类型，直至Object类，因为不知道具体是哪个超类型，因此方法返回的类型只能赋给Object。

2、因为可以向上转型，所以作为方法的参数时，可以传递X以及X的子类型。

3、作为方法的参数时，可以传递null。

作用：主要用来安全地写入数据，可以写入X及其子类型。

[java] view plain copy

print?

1. /**
2. * ICE
3. * 2016/10/17 0017 14:12
4. */
5. public class Demo {
6. public static void main(String[] args) {
7. A a = new A();
8. B b = new B();
9. C c = new C();
10. D<? super A> d = new D<>();
11. Object o = d.get();
12. d.set(a);
13. d.set(b);
14. d.set(c);
15. d.set(null);
16. }
17. }
18. class A {
19. @Override
20. public String toString() {
21. return "A{}";
22. }
23. }
24. class B extends A {
25. @Override
26. public String toString() {
27. return "B{}";
28. }
29. }
30. class C extends A {
31. @Override
32. public String toString() {
33. return "C{}";
34. }
35. }
36. class D<T> {
37. public void set(T t) {
38. }
39. public T get() {
40. return null;
41. }
42. }

无限定

无限定不等于可以传任何值，相反，作为方法的参数时，只能传递null，作为方法的返回时，只能赋给Object。

[java] view plain copy

print?

1. /**
2. * ICE
3. * 2016/10/17 0017 14:12
4. */
5. public class Demo {
6. public static void main(String[] args) {
7. D<?> d = new D<>();
8. Object o = d.get();
9. d.set(null);
10. }
11. }
12. class A {
13. @Override
14. public String toString() {
15. return "A{}";
16. }
17. }
18. class B extends A {
19. @Override
20. public String toString() {
21. return "B{}";
22. }
23. }
24. class C extends A {
25. @Override
26. public String toString() {
27. return "C{}";
28. }
29. }
30. class D<T> {
31. public void set(T t) {
32. }
33. public T get() {
34. return null;
35. }
36. }

有什么作用呢？对于一些简单的操作比如不需要实际类型的方法，就显得比泛型方法简洁。

[java] view plain copy

print?

1. /**
2. * ICE
3. * 2016/10/17 0017 14:12
4. */
5. public class Demo {
6. public static void test(D<?> d) {
7. System.out.println(d == null);
8. }
9. public static <T> void test1(D<T> d) {
10. System.out.println(d == null);
11. }
12. public static void main(String[] args) {
13. D d = new D();
14. Demo.test(d);
15. Demo.test1(d);
16. }
17. }
18. class D<T> {
19. }