泛型

发表于 | 分类于
字数统计: 1.7k word | 阅读时长 ≈ 6 min
泛型(generics)
概述
  • 在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来
    解决
  • 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类
    型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，
    继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实
    际的类型参数，也称为类型实参）
  • 从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，
    允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明
    该List只能保存字符串类型的对象
  • JDK1.5改写了集合框架中的全部接口和类，为这些接口、类增加了泛型支持，
    从而可以在声明集合变量、创建集合对象时传入类型实参
  • 为什么要有泛型？
    • 解决元素存储的安全性问题，好比商品、药品标签，不会弄错
    • 解决获取数据元素时，需要类型强制转换的问题，好比不用每回拿商品、药
      品都要辨别。
  • demo
1
2
3
4
5
6
7
8
9
10
11
12
13
Map<String,Integer> map = new HashMap<String,Integer>();
        map.put("Tom1",34);
        map.put("Tom2",44);
        map.put("Tom3",33);
        map.put("Tom4",32);
        //添加失败
        //map.put(33, "Tom");
        Set<Entry<String,Integer>> entrySet = map.entrySet();
        Iterator<Entry<String,Integer>> iterator = entrySet.iterator();
        while(iterator.hasNext()){
            Entry<String,Integer> entry = iterator.next();
            System.out.println(entry.getKey() + "--->" + entry.getValue());
        }
自定义泛型结构

  • 泛型的声明

    • interface List 和 class GenTest<K,V>
      其中，T,K,V不代表值，而是表示类型。这里使用任意字母都可以。
      常用T表示，是Type的缩写

  • 泛型的实例化

    • 一定要在类名后面指定类型参数的值（类型）。如：
    1
    2
    List<String> strList = new ArrayList<String>();
    Iterator<Customer> iterator = customers.iterator();
    • T只能是类，不能用基本数据类型填充。但可以使用包装类填充

  • jdk1.5前后对比

    • 1.5之前

      1
      2
      Comparable c = new Date();
      System.out.println(c.compareTo("red"));

    • 1.5之后

      1
      2
      Comparable<Date> c = new Date();
      System.out.println(c.compareTo("red"));

  • 体会：使用泛型的主要优点是能够在编译时而不是在运行时检测错误

  • 补充说明

    • 泛型类可能有多个参数，此时应将多个参数一起放在尖括号内。比如：
      <E1,E2,E3>
    • 实例化后，操作原来泛型位置的结构必须与指定的泛型类型一致
    • 泛型不同的引用不能相互赋值
    • 泛型如果不指定，将被擦除，泛型对应的类型均按照Object处理，但不等价
      于Object。 经验：泛型要使用一路都用。要不用，一路都不要用
    • 如果泛型结构是一个接口或抽象类，则不可创建泛型类的对象
    • jdk1.7，泛型的简化操作：ArrayList flist = new ArrayList<>()
    • 泛型的指定中不能使用基本数据类型，可以使用包装类替换
    • 父类有泛型，子类可以选择保留泛型也可以选择指定泛型类型
    • 在类/接口上声明的泛型，在本类或本接口中即代表某种类型，可以作为非静态
      属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法
      中不能使用类的泛型

  • code

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class GenericTest {
                public static void main(String[] args) {
                // 1、使用时：类似于Object，不等同于Object
                ArrayList list = new ArrayList();
                // list.add(new Date());//有风险
                list.add("hello");
                test(list);// 泛型擦除，编译不会类型检查
                // ArrayList<Object> list2 = new ArrayList<Object>();
                // test(list2);//一旦指定Object，编译会类型检查，必须按照Object处理
                }
                public static void test(ArrayList<String> list) {
                    String str = "";
                    for (String s : list) {
                        str += s + ",";
                    }
                    System.out.println("元素:" + str);
                }
            }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //static的方法中不能声明泛型
    public static void show(T t) {

    }
    //不能在try-catch中使用泛型定义
    public void test() {
      try {

      } catch (MyException<T> ex) {

      }
    }
泛型方法

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

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

    1
    2
    3
    4
    5
    6
    public class DAO {
        public <T> E get(int id, T e) {
            T result = null;
            return result;
        }
    }
泛型在继承上的体现
  • 如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的
    类或接口，G并不是G的子类型
  • 比如：String是Object的子类，但是List并不是List
    的子类
1
2
3
4
5
6
7
8
9
10
11
public void testGenericAndSubClass() {
    Person[] persons = null;
    Man[] mans = null;
    // 而 Person[] 是 Man[] 的父类.
    persons = mans;
    Person p = mans[0];
    // 在泛型的集合上
    List<Person> personList = null;
    List<Man> manList = null;
    // personList = manList;(报错)
}
通配符的使用

  • 使用类型通配符：？
    比如：List<?> ，Map<?,?>
    List<?>是List、List等各种泛型List的父类。

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

  • 写入元素：

    • 写入list中的元素时，因为我们不知道c的元素类型，我们不能向其中
      添加对象
    • 唯一的例外是null，它是所有类型的成员
    1
    2
    List<?> list2 = new ArrayList<>(10);
    list2.add("sss"); //编译时错误

  • 说明

    • 注意点1：编译错误：不能用在泛型方法声明上，返回值类型前面<>不能使用?
    • 注意点2：编译错误：不能用在泛型类的声明上
    • 注意点3：编译错误：不能用在创建对象上，右边属于创建集合对象
有限制的通配符
  • <?>允许所有泛型的引用调用
  • 通配符指定上限：上限extends：使用时指定的类型必须是继承某个类，或者实现某个接口，即<=
  • 通配符指定下限：下限super：使用时指定的类型不能小于操作的类，即>=
  • 举例：(理解这两个范围即可)
    • <? extends Number> ( 无穷小 , Number]
      只允许泛型为Number及Number子类的引用调用
    • <? super Number> [Number , 无穷大)
      只允许泛型为Number及Number父类的引用调用
    • <? extends Comparable>
      只允许泛型为实现Comparable接口的实现类的引用调用
1
2
3
4
5
6
List<? extends User> list1 = null;
   List<? super User> list2 = null;
   List<Student> studentList = new ArrayList<>();
   list1 = studentList;

   Student s = list1.get(0); //此处编译不通过 理解为不能将父类的对象赋给子类 万一 ? 代表的类型比student大呢
0%