Java知识点梳理——泛型

2018-08-17 09:41:10来源：博客园阅读 ()

1、定义：泛型的本质是参数化类型，就是将类型由原来的具体的类型参数化，这种参数类型可以用在类、接口、方法中，分别称为泛型类、泛型接口、泛型方法；

2、泛型类：泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分，最典型的就是各种容器类，List、Set、Map；

 1 public class Box<T>{
 2     private T t;
 3 
 4     public T getT() {
 5         return t;
 6     }
 7 
 8     public void setT(T t) {
 9         this.t = t;
10     } 
11 }

a、泛型的类型参数只能是引用型类型<Integer>、<Double>（包括自定义类）等，不能是原始类型<int>、<double>等；

b、实例化泛型类时，必须指定 T 的具体类型；

c、参数化类型 T 可以写成任意字符，常用的 T 、E、K、V等表示泛型；

3、泛型接口：泛型接口与泛型类的定义及使用基本相同；

1 public interface Box<T> {
2     public T next();
3 }

a、实现泛型接口的类未传入泛型实参时，在声明此类的时候，需将泛型的声明也加到类中；

1 class B<T> implements Box<T>{
2     @Override
3     public T next() {
4         return null;
5     }
6 }

b、实现泛型接口的类传入泛型实参时，需将所有使用泛型的地方都要换成实参类型；

1 public class B implements Box<String> {
2 
3     private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
4 
5     @Override
6     public String next() {
7         return null;
8     }
9 }

4、泛型方法：调用方法的时候，指明泛型的具体类型；

 1 // 泛型类
 2 class Box<T> {
 3     /**
 4      * 在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型，可以类型与T相同，也可以不同。
 5      * 由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明泛型，编译器也能够正确识别泛型方法中识别的泛型。
 6      */
 7     public <E> void B_1(E t) {
 8         System.out.println(t.toString());
 9     }
10 
11     /**
12      * 在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型。
13      *
14      */
15     public <T> void B_2(T t) {
16         System.out.println(t.toString());
17     }
18         
19     // 不是泛型方法
20     public void B_3(T t){
21         System.out.println(t.toString());
22     }
23 }

a、所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在上面例子中的<E>、<T>）；

b、只有声明了<T>、<E>的方法才是泛型方法（B_1、B_2），泛型类中使用泛型的成员方法不是泛型方法（B_3）；

c、<T>、<E>表明该方法将使用泛型类型T、E，此时才可以在方法中使用泛型类型T、E；

d、泛型方法体的声明和其他方法一样，只能是引用型类型，不能是原始类型（int、double，char等）；

5、泛型上下边界：在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类；为泛型添加上边界，即传入的类型实参必须是指定类型的子类型；

 1 // 泛型类
 2 class Box<T extends Number> {
 3     private T t;    
 4     public Box(T t){
 5         this.t = t;
 6     }    
 7     public T getT(){
 8         return t;
 9     }
10 }
11 Box<Integer> b = new Box<Integer>(1000);// Integer类型是Number类型的子类————正确
12 Box<String> s = new Box<String>("1000");// String类型不是Number类型的子类————错误

6、类型通配符：一般是使用？代替具体的类型参数，？是类型实参，和Integer、Number一样都是一种实际的类型，？可以看成所有的类型的父类（List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类）；

 1 public static void main(String[] args) {
 2     Box b = new Box();
 3     List<String> sLst = new ArrayList<String>();
 4     sLst.add("100");
 5     List<Integer> iLst = new ArrayList<Integer>();
 6     iLst.add(100);
 7     List<Number> nLst = new ArrayList<Number>();
 8     nLst.add(1000);
 9     b.BPrint(sLst);
10     b.BPrint(iLst);
11     b.BPrint(nLst);
12 }
13 
14 /**
15  * <? extends T>表示该通配符所代表的类型是T类型的子类
16  * <? super T>表示该通配符所代表的类型是T类型的父类
17  */
18 class Box {
19     public void BPrint(List<?> lst) {
20         System.out.println(lst);
21     }
22 }