泛型

image.png

一、自我总结

泛型就是规定你所依赖的变量的类型，使它不再是一个固定的类型，而可以是任意类型，也可以对这个类型做限制。使用过程中注意List<Number>和List<Integer>并没有任何关系;List<? extends Number>确是List<? extends Integer>的父类。使用过程中还得注意泛型擦除造成的影响。

二、关键字

类型参数、类型变量、类型推断、原始类型、限定类型参数、通配符、非限定通配符、类型擦除、桥接方法

三、泛型是什么？

类、接口、方法里传入的类型参数(给所依赖的类定义一个类型，可以是任何类型也可以是受限制类型)

四、为什么使用泛型

1、代码复用：

public class Apple {
    public String type;
    public void setType(String type){ this.type =type;}
    public String getType(){return type;}
}

在上面代码块中，如果type是String类型修饰，那么在后面我们之后传递String类型的变量。就无法实现代码的复用。

2、编译期检查类型错误

public class Apple {
    public Object type;
    public void setType(Object type){ this.type =type;}
    public Object getType(){return type;}
}

如果将type设置成Object类型，但如果有肯能传入String类型，取出是Integer,就会抛出ClassCastException,而且不能传入类型方法。

使用泛型后

public class Apple<T> {
    public T type;
    public void setType(T type){ this.type =type;}
    public T getType(){return type;}
}

使用泛型后，可以接受任何基本类型，不会出现类型转换异常，因此在编译的时候就通过检测。

五、如何使用泛型

1、泛型类

public class Apple<T>{
    public T type;
    public void setType(T type){ this.type =type;}
    public T getType(){return type;}
}

2、泛型方法

public <T> T setType(T t){}

3、泛型接口

 public interface Generid<T>{
      void generid(T t);
 }

4、泛型使用

（1）实例化的自动推断类型

image.png

（2）原始类型

image.png

（3）泛型类的继承（接口一样）

父类

image.png

3种继承方式

image.png
image.png
image.png

在最后一种使用中，如果T指定具体类型，那在类的申明时就不需要重复使用T

5、泛型限定通配符

（1）List<? extends Number> 设置上限，特点只能读。

image.png

（2）多重限定（java单继承原则，继承必须放第一位，后面只能接口）

image.png

（3）List<? super Integer> 设置下限，特点只能写。

6、通配符

先表明List限定性之间的关系

image.png

由于List< Number>和List< Integer>是没有任何关系的，所以当你把方法的参数设定为List< Number>时，List< Integer>并不能作为参数传入，此时就需要通配符以及它们之间的继承关系。

7、通配符和子类型

//我们之前说虽然Number是Integer的父类，但是List<Number>和List<Integer>没有任何关系
List<Integer> intList = new AraayList<>();
List<Number> numList = intList;  //这是错的！

//在使用了通配符后
List<? extends Integer> intList = new ArrayList<>();
List<? extends Number> numList = intList; // 这是可以的！List<? extends Integer>是<? extends  

//上限通配符,传入的是Number的子类 上读
//你只能从list中取数据，不能存数据。编译器不知道你存入的是什么类型，但是可以肯定的返回给你Number类型。
private void process(List<? extends Number> list){/****/}

//下限通配符，传入的是Number的超类 下写
//你只能往list中存数据，不能取数据。编译器知道你存入的是Number类型，但是不知道该返回给你什么类型。
private void process(List<? super Number> list){/****/}

//无限通配符
private void process(List<?> list){/****/}

8、无限定通配符

image.png

9、类型参数命名规则

E - Element (Java Collections Framework广泛使用)

K - Key

N - Number

T - Type

V - Value

S,U,V etc. - 2nd, 3rd, 4th types

六、类型擦除，桥接

1、类型擦除

//擦除前（没有限定类型）
public class Box<T>{
    private T t;
}
//擦除后
public class Box{
    private Object t;
}

//擦除前（限定参数类型，会取第一个绑定类）
public class Box<T extends Comparable&Serializable>{
    private T t;
}
//擦除后
public class Box<T extends Comparable&Serializable>{
    private Comparable t;
}

总结：Box< T> T 没有收到限制，在擦除后为Object类型，Box< T extends Comparable>当T 收到Comparable约束 ，擦除后T为Comparable类型。

举例说明：

Map<String, String> map = new HashMap<>();
map.put("a", "第一");
String s = map.get("a");//看似这里取出来直接就是String类型，其实在编译器编译后是这样：
                        //String s = (String)map.get("a");
                        //编译器泛型擦除后拿出来的是Object类型，它帮我们进行了强转

image.png

2、桥接方法（ASM Plugin插件）

public synthetic bridge get();
public synthetic bridge set(Object object)

七、使用限制

1、无法实例化具有基本类型的泛型类型

Pair<int, char> p = new Pair<>(8, 'a');//编译错误！

2、无法创建类型参数的实例

public class Test <T>{
    T t = new T();//编译错误！
}

3、无法声明类型为类型参数的静态字段

public class Test <T>{
    public static final T t;//编译错误！
}

4、无法将instanceof与参数化类型一起使用

image.png

5、无法创建参数化类型的数组

image.png

6、泛型类无法继承Exception、Throwable，无法捕获Exception的类型参数

image.png
image.png image.png

7、无法同时定义两个泛型擦除后参数变为相同的重载方法

public class Example {
    //两个方法泛型擦除后参数都变为Set<Object>,所以报错这两个方法重复定义了
    public void print(Set<String> strSet) { }
    public void print(Set<Integer> intSet) { }
}