java泛型

泛型

泛型是一种“代码模板”，可以用一套代码套用各种类型。泛型就是编写模板代码来适应任意类型。泛型可以看成接受数据类型的数据类型。

泛型的的好处

传统方法：

1. 不能对加入到集合ArrayList中的数据类型进行约束（不安全）
2. 遍历的时候，需要进行类型转换，如果集合中的数据量较大，对效率有影响

泛型的好处:

1. 使用时不必对类型进行强制转换，它通过编译器对类型进行检查；
2. 减少了类型转换的次数，提高了效率

泛型介绍

理解：泛（广泛）型（类型）=>IntegerString.Dog

1. 泛型又称参数化类型，是Jdk5.0出现的新特性，解决数据类型的安全性问题
2. 在类声明或实例化时只要指定好需要的具体的类型即可
3. Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮
4. 泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值的类型，或者是参数类型。 (E 表示 s 的数据类型, 该数据类型在定义对象的时候指定,即在编译期间， 就确定 E 是什么类型 )[有点难]

泛型的语法

泛型的声明

interface 接口 <T> {...}  

class 类<K.V> {...}

//比如：List，ArrayList
说明：
1）其中，T,K,V不代表值，而是表示类型。
2）任意字母都可以。常用T表示，是Type的缩写

泛型的实例化

要在类名后面指定类型参数的值（类型）。如：

1） List<String> strlist = new ArraylistString>();
2）Iterator<Customer> iterator = customers.iterator();

泛型使用

• 擦拭法：Java使用擦拭法实现泛型，导致了：

1. 编译器把类型<T>视为Object；
2. 编译器根据<T>实现安全的强制转型。

虚拟机执行的代码并没有泛型：Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

• 局限性：1. 无法取得带泛型的Class 2. 无法判断带泛型的类型 3. 不能实例化T类型：

泛型使用的注意事项和细节

1.interface  List<T> {...}  public class HashSet<E>{...}...等等
说明：T,E只能是引用类型
看看下面语句是否正确？：
List <Integer> list = new Arraylist<Integer> ()://OK
List <int> list2 = new Arraylist<int> ()://错误
2.在给泛型指定具体类型后，可以传入该类型或者其子类类型
3.泛型使用形式
List <integer> listl = new Arraylist <Integer> ();
List <lnteger> list2 = new Arraylist<> ()[说明：]
3.如果我们这样写List list3 = new ArrayList()；默认给它的泛型是[<E> E就是Object]
即：

向上转型

在Java标准库中的ArrayList<T>实现了List<T>接口，它可以向上转型为List<T>：

public class ArrayList<T> implements List<T> {
    ...
}

List<String> list = new ArrayList<String>();

即类型ArrayList<T>可以向上转型为List<T>。

要特别注意：不能把ArrayList<Integer>向上转型为ArrayList<Number>或List<Number>。

注意泛型的继承关系：可以把ArrayList<Integer>向上转型为List<Integer>（T不能变！），但不能把ArrayList<Integer>向上转型为ArrayList<Number>（T不能变成父类）。

1. 说明：T,E只能是引用类型

2. 在给泛型指定具体类型后，可以传入该类型或者该类型的子类类型

3. 泛型使用形式

4. 不指定泛型参数类型时，编译器会给出警告，且只能将<T>视为Object类型；

5. 可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

自定义泛型

基本语法
class类名<T，R>（//…表示可以有多个泛型
成员
}

注意细节

1. 普通成员可以使用泛型（属性、方法）

2. 使用泛型的数组，不能初始化 //因为数组在 new 不能确定 T 的类型， 就无法在内存开空间

3. 静态方法中不能使用类的泛型

//因为静态是和类相关的， 在类加载时， 对象还没有创建
//所以， 如果静态方法和静态属性使用了泛型， JVM 就无法完成初始化

4. 泛型类的类型，是在创建对象时确定的（因为创建对象时，需要指定确定类型）

5. 如果在创建对象时，没有指定类型，默认为Object

自定义泛型接口

基本语法 : interface 接口名 <T, R…> {…}
注意细节:

1. 接口中，静态成员也不能使用泛型（这个和泛型类规定一样）(接口中的属性，只能是 final 的，而且是public static final修饰符)
2. 泛型接口的类型，在继承接口或者实现接口时确定
3. 没有指定类型，默认为Object

除了ArrayList<T>使用了泛型，还可以在接口中使用泛型。例如，Arrays.sort(Object[])可以对任意数组进行排序，但待排序的元素必须实现Comparable<T>这个泛型接口：

public interface Comparable<T> {
    /**
     * 返回负数: 当前实例比参数o小
     * 返回0: 当前实例与参数o相等
     * 返回正数: 当前实例比参数o大
     */
    int compareTo(T o);
}

自定义泛型方法

基本语法: 修饰符 <T,R…> 返回类型 方法名（参数列表）{…}
注意细节:

1. 泛型方法，可以定义在普通类中，也可以定义在泛型类中

2. 当泛型方法被调用时，类型会确定

3. 区别泛型方法和使用了泛型的方法：

   public void eat (E e）{…}，修饰符后没有<T,R…> eat 此方法不是泛型方法，而是使用了泛型

4. 泛型方法，可以使用类声明的泛型，也可以使用自己声明的泛型

泛型的继承和通配符

泛型的继承和通配符说明

1. 泛型不具备继承性
2. <?> :支持任意泛型类型
3. <？extends A > ：支持A类以及A类的子类，规定了泛型的上限（约束作用）
4. <? super A > : 支持A类以及A类的父类，不限于父类，规定了泛型的下限（约束作用）