Java泛型应用

泛型

为什么要有泛型

就像是垃圾回收一样，如果只有一个垃圾桶，那么还要去分什么是可回收，什么是不可回收的。但是如果给垃圾桶

贴上标签，让它只能放可回收的或不可回收的，那么处理的时候就可以直接处理。

好处：

• 它解决了元素存储的安全问题。
• 解决获取元素时，需要类型强制转换的问题。

泛型的概念

所谓泛型（JDK1.5之后），就是允许在定义类、接口时通过一个标识表示类中某个属性的类 型或者是某个方法返

回值及参数类型。这个类型参数将在使用时（例如， 继承或实现这个接口，用这个类型声明变量、创建对象时）

确定（即传入实际的类型参数，也称为类型实参）

集合中使用泛型

无泛型时

public void test01() {
    ArrayList list = new ArrayList<>();
    //需求，存放学生成绩
    list.add(78);
    list.add(90);
    list.add(80);
    //问题一：类型不安全
    list.add("Tom");
    for(Object score:list){
        //强转时可能出现类型转换异常
        int stuScore = (Integer) score;
        System.out.println(stuScore);
    }
}

有泛型后

//List
public void test02() {
    ArrayList<Integer> list = new ArrayList<>();
    //需求，存放学生成绩
    list.add(78);
    //有了泛型，这样就会出错,编译时就会进行类型检查
    //list.add("Tom");
    //方式一
    for(Integer score:list){
        //强转时可能出现类型转换异常
        System.out.println(score);
    }
    //方式二
    Iterator<Integer> iterator = list.iterator();
    while(iterator.hasNext()){
        Integer score = iterator.next();
        System.out.println(score);
    }
}

//Map
public void test03() {
    HashMap<String, Integer> hashMap = new HashMap<>();
    hashMap.put("Tom",97);
    //会出错.
    // hashMap.put("Tom","97");
    Set<Map.Entry<String, Integer>> entries = hashMap.entrySet();
    Iterator<Map.Entry<String, Integer>> iterator = entries.iterator();
    //方式一
    while(iterator.hasNext()){
        Map.Entry<String, Integer> next = iterator.next();
        System.out.println(next.getKey());
        System.out.println(next.getValue());
    }
    //方式二
    for(Map.Entry<String, Integer> map :entries){
        String key = map.getKey();
        Integer value = map.getValue();
        System.out.println(key+":"+value);
    }
}

总结

1. 集合接口或集合类在jdk5.0时都修改为带泛型的结构
2. 在实例化 集合类时，可以指明具体的泛型类型，指明完后，在集合类或接口中凡是定义类或接口中，内部结构使用到类的泛型的位置都指定为设置的泛型
3. 泛型的类型必须是类，不能是基本数据类型。
4. 如果实例化时，没有指明泛型类型。则默认为Object类的。

自定义泛型结构

泛型的声明与实例化

声明：

interface List 和 class Person<K,V>，其中，T,K,V不代表值，而是表示类型，这个使用任意字母都可

以。相当于标签。

实例化：

一定要在类名后面指定类型参数的值(类型)，如

List<String> list = new ArrayList<>();
Iterator<Customer> iterator = customers.iterator();

自定义泛型类

使用方法

public class Order<T> {
    String orderName;
    int orderId;
    //类的内部结构可以使用类的泛型
    T orderT;
    public Order() {
        //编译不通过
        //T[] arr= new T[10];
        //泛型只是一个标签，而不是实例化本类，所以不能直接new
        T[] arr = (T[]) new Object[10];
    }
    //静态方法中不能使用类的泛型，
    //    public static void show(T orderT){
    //        System.out.println(orderT);
    //    }
    //catch中也不能使用泛型，编译不通过
    //    public void show(){
    //        try {
    //
    //        }catch (T t){
    //
    //        }
    //    }
}

总结

1. 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如： <E1,E2,E3>
2. 泛型类的构造器如下：public GenericClass(){}。 而下面是错误的：public GenericClass(){}
3. 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致。
4. 泛型不同的引用不能相互赋值。 >尽管在编译时ArrayList和ArrayList是两种类型，但是，在运行时只有 一个ArrayList被加载到JVM中。
5. 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价 于Object。经验：泛型要使用一路都用。要不用，一路都不要用。
6. 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
7. jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>();
8. 泛型的指定中不能使用基本数据类型，可以使用包装类替换
9. 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态 属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法 中不能使用类的泛型。
10. 异常类不能是泛型的
11. 不能使用new E[]。但是可以：E[] elements = (E[])new Object[capacity]; 参考：ArrayList源码中声明：Object[] elementData，而非泛型参数类型数组。
12. 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

• 子类不保留父类的泛型：按需实现
  • 没有类型 擦除
  • 具体类型
• 子类保留父类的泛型：泛型子类
  • 全部保留
  • 部分保留

结论：子类必须是“富二代”，子类除了指定或保留父类的泛型，还可以增加自己的泛型

不同情况

class Father<T1,T2>{ }
//子类不保留父类的泛型
//  1)没有类型，擦除,此时Son1已不是泛型类
class Son1 extends Father{}//等价于 class Son extends Father<Object,Object>{}
//  2)具体类型
class Son2 extends Father<Integer,String>{}
//子类保留父类的全部泛型
//  1)全部保留
class Son3<T1,T2> extends Father<T1,T2>{}
//  2)部分保留
class Son4<T2> extends Father<Integer,T2>{}
//----------情况二
//子类不保留父类的泛型
//  1)没有类型，擦除
class Son5<A,B> extends Father{}
//  2)具体类型
class Son6<A,B> extends Father<Integer,String>{}
//子类保留父类的全部泛型
//  1)全部保留
class Son7<T1,T2,A,B> extends Father<T1,T2>{}
//  2)部分保留
class Son8<T2,A,B> extends Father<Integer,T2>{}

自定义泛型方法

方法也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类

型就是传入数据的类型。

泛型方法的格式：

【访问权限】 <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常

泛型方法声明泛型时也可以指定上限。

//在方法中出现了泛型的结构，泛型参数和类的泛型参数没有任何关系。
//泛型方法所属的类是不是泛型类都没关系。
//泛型方法可以是静态的
public static  <E> List<E> copyFromArrayToList(E[] arr){
    ArrayList<E> list = new ArrayList<>();
    for(E e:arr){
        list.add(e);
    }
    return list;
}

泛型在继承上的体现

类A是类B的父类，G和G二者不具备子父类关系,二者是并列关系

比如，String是Object的子类，但是List并不是List的子类。

public void test01() {
    Object obj = null;
    String str = null;
    //子类赋予父类
    obj = str;

    List<Object> list1 = new ArrayList<>();
    List<String> list2 = new ArrayList<>();
    //此时list1和list2的类型不具有子父类关系
    //编译不容过
    list1 = list2;
}

通配符的使用

通配符？

比如List<?>,Map<?，?>等，

List<?>是List、List等各种泛型List的父类。

• 读取List<?>的对象list中的元素时，永远是安全的，因为不管List的泛型是什么，它包含的都是Object。
• 写入list中的元素时，会出现编译错误。因为我们不知道它的元素类型，不能添加数据，
  • 但是可以添加null，因为它是所有类型的成员

使用通配符的注意点

1、编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用？

public static <?> void test(ArrayList<?> list){}

2、编译错误：不能用在创建对象上，右边属于创建集合对象

ArrayList<?> objects = new ArrayList<?>();

3、编译错误：不能用在泛型类的声明上。

class GenericType<?>{}

使用案例

/**
  * 通配符的使用
  * 通配符？
  * 类A是类B的父类，G<A>和G<B>是没有关系的，二者共同的父类关系是G<?>
*/
public void test01() {
    List<Object> list1 = null;
    List<String> list2 = null;
    List<?> list = null;
    list = list1;
    list = list2;
    show(list1);
    show(list2);
}
public void show(List<?> list){
    Iterator<?> iterator = list.iterator();
    while(iterator.hasNext()){
        Object next = iterator.next();
        System.out.println(next);
    }
}

有限制的通配符

举例

public void test01() {
    //Object>Person>Student
    //<=,Person的子类，或本身  [-o,A]
    List<? extends Person> list1 =null;
    //>=Person的父类或本身 [A,o]
    List<? super Person> list2 =null;
    List<Student> list3 = null;
    List<Person> list4 = null;
    List<Object> list5 = null;
    list1 = list3;
    list1 = list4;
    //编译报错
    //list1 = list5;
    //编译报错
    //list2 = list3;
    list2 = list4;
    list2 = list5;
    //读取数据可以
    Person person = list1.get(0);
    //编译错误，最大只能到Person
    //  Student student = list1.get(0);
    Object object = list2.get(0);
    //编译错误，最小为Person，所以得用最大能到的去接受.
    // Person person1 = list2.get(0);
    //修改数据
    //编译错误，因为最大只能到Person
    //list1.add(new Student());
    list2.add(new Person());
    list2.add(new Student());
}