Java泛型

IT程
103 阅读7分钟

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

12. 泛型

12.1 泛型相关概念

1. 泛型引入

泛型是一种标签，例如，中药店，每个抽屉外面贴着标签；超市购物架上很多瓶子，每个瓶子装的是什么，有标签

泛型的设计背景

集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个参数，这个类型参数叫做泛型。Collection<E>，List<E>，ArrayList<E> 这个<E>就是类型参数，即泛型。

2. 泛型的概念

所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实 际的类型参数，也称为类型实参）。

从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。

JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，从而可以在声明集合变量、创建集合对象时传入类型实参。

3. 使用泛型的优势
  • 解决元素存储的安全性问题，例如集合如果不使用泛型，可以存储任意类型的数据，造成类型不安全
  • 解决获取数据元素时，需要类型强制转换的问题，例如取出集合数据时，需要转换成相应的类型，可能会报ClassCastException异常
  • Java泛型可以保证如果程序在编译时没有发出警告，运行时就不会产生ClassCastException异常。同时，代码更加简洁、健壮

12.2 在集合中使用泛型

1. 例子
public class GenericTest {
    // 在集合中使用泛型之前的情况：
    @Test
    public void test1() {
        ArrayList list = new ArrayList();
        // 需求：存放学生的成绩
        list.add(78);
        list.add(76);
        list.add(89);
        list.add(88);
        // 问题一：类型不安全，存放成绩，但存成了姓名，且不会报错
        // list.add("Tom");
        for (Object score : list) {
            // 问题二：强转时，可能出现ClassCastException
            int stuScore = (Integer) score;
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况：ArrayList
    @Test
    public void test2() {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(78);
        list.add(87);
        list.add(99);
        list.add(65);
        // 编译时，会进行类型检查，保证数据的安全
        // list.add("Tom");
        for(Integer score : list){
            //避免了强转操作
            int stuScore = score;
            System.out.println(stuScore);
        }
    }

    //在集合中使用泛型的情况：HashMap
    @Test
    public void test3() {
        // jdk7新特性：类型推断，后面的泛型可省略
        Map<String, Integer> map = new HashMap<>();
        map.put("Tom", 87);
        map.put("Jerry", 87);
        map.put("Jack", 67);
        // 泛型的嵌套
        Set<Map.Entry<String, Integer>> entry = map.entrySet();
        Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
        while (iterator.hasNext()) {
            Map.Entry<String, Integer> e = iterator.next();
            String key = e.getKey();
            Integer value = e.getValue();
            System.out.println(key + "----" + value);
        }
    }
}
2. 总结
  • 泛型是jdk 5.0新增的特性
  • 集合接口或集合类在jdk5.0时都修改为带泛型的结构
  • 在实例化集合类时，可以指明具体的泛型类型
  • 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型，例如：add(E e) —> 实例化以后：add(Integer e)
  • 泛型的类型必须是类，不能是基本数据类型。需要用到基本数据类型的位置，使用包装类替换
  • 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object类型
  • 在jdk 7中增加了新特性：类型推断，实例化时后面的泛型可省略
  • 把一个集合中的内容限制为一个特定的数据类型，这就是泛型背后的核心思想

12.3 自定义泛型结构

1. 自定义泛型类、泛型接口

步骤

  1. 在创建类或接口时指定泛型

    如，interface A<T>或class A<K, V>，其中，T、K、V不代表值，而是表示类型。使用任意字母都可以，常用T表示，是Type的缩写

  2. 在类中使用泛型定义结构

  3. 实例化类对象时指明泛型的类型

    在类名后面指定类型参数的值（类型），如，A<Integer> a = new A<Integer>();，其中，指定的类型只能是类或接口，不能用基本数据类型填充，但可以使用包装类填充

例子

class Person<T> {
    private T id;
    private String name;

    public Person(T id, String name) {
        this.id = id;
        this.name = name;
    }

    public T getId() {
        return id;
    }

    public void setId(T id) {
        this.id = id;
    }
}
public class PersonTest {
    public static void main(String[] args) {
        Person<Integer> person = new Person<>(1001, "张三");
        person.setId(1002);
        Integer id = person.getId();
        System.out.println(id);
    }
}

相关说明

  • 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：<E1,E2,E3>

  • 泛型类的构造器不需要指明泛型：A<T>(){}，这是错误的

  • 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致

  • 泛型不同的引用不能相互赋值

  • 在实例化时泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价于Object；一般泛型要使用就一直用，要不用就一直不用

  • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象（抽象类和接口的特性）

  • jdk1.7，泛型的简化操作：ArrayList<Integer> list = new ArrayList<>();

  • 泛型的指定中不能使用基本数据类型，可以使用包装类替换

  • 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态结构中不能使用类的泛型（泛型需要在实例化时进行指定，而静态结构是在类的加载时进行加载的）

  • 异常类不能声明泛型

  • 不能使用new E[]，可以使用E[] elements = (E[])new Object[];

  • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型：

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

  • 子类除了指定或保留父类的泛型，还可以增加自己的泛型

2. 自定义泛型方法

相关说明

  • 方法，也可以被泛型化，不管此时定义在其中的类是不是泛型类。在泛型方法中可以定义泛型参数，此时，参数的类型就是传入数据的类型
  • 泛型方法的格式： [访问权限] <泛型> 返回类型 方法名([泛型标识 参数名称]) 抛出的异常
  • 泛型方法声明泛型时也可以指定上限
  • 在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系
  • 泛型方法，可以声明为静态的（泛型参数是在调用方法时确定的，并非在实例化类时确定）

例子

class Person {
    private String name;

    public <T> T showName(T name) {
        System.out.println(name);
        return name;
    }

    public static <T> void showInfo(T info) {
        System.out.println(info);
    }
}

public class PersonTest {
    public static void main(String[] args) {
        Person.showInfo(1001);
        Person person = new Person();
        String name = person.showName("张三");
        System.out.println(name);
    }
}

12.4 泛型在继承上的体现

  • 如果B是A的一个子类型（子类、实现类或子接口），且G是具有泛型声明的类或接口，但G<B>并不是G<A>的子类型；例如：String是Object的子类，但是List<String>并不是List<Object>的子类。

  • 如果B是A的一个子类型（子类、实现类或子接口），且A、B是具有泛型声明的类或接口，则B<T>是A<T>的子类型；例如：ArrayList是List的子类，且ArrayList<String>是List<String>的子类。

12.5 通配符的使用

通配符：?

1. 相关说明

  • 如果B是A的一个子类型（子类、实现类或子接口），且G是具有泛型声明的类或接口，G<B>和G<A>是没有关系的，二者的共同父类是G<?>，比如：List<?>是List<String>、List<Object>等各种泛型List的父类

  • 读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object

  • 写入list中的元素时，不行。因为不知道元素类型，不能向其中添加对象；唯一的例外是null，它是所有类型的成员

  • 通配符不能用在泛型方法的声明上

  • 通配符不能用在泛型类或泛型接口的声明上

  • 通配符不能用在创建对象上（在new右边的类后不能使用）

    // 正确
List<?> list1 = new ArrayList<>();
// 编译错误
// List<?> list2 = new ArrayList<?>();
2. 有限制的通配符

  • <?>允许所有泛型的引用调用

  • 通配符指定上限

    上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=

  • 通配符指定下限

    下限super：使用时指定的类型不能小于操作的类，即>=；可以写入指定类或其子类

例子：

<? extends Number> (无穷小 , Number]
只允许泛型为Number及Number子类的引用调用
<? super Number> [Number , 无穷大)
只允许泛型为Number及Number父类的引用调用
<? extends Comparable>
只允许泛型为实现Comparable接口的实现类的引用调用
avatar
文章
阅读
粉丝