java泛型总结

为什么要泛型

• 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的

  对象，所以在JDK1.5之前只能把元素类型设计为Object，JDK1.5之后使用泛型来

  解决。因为这个时候除了元素的类型不确定，其他的部分是确定的，例如关于

  这个元素如何保存，如何管理等是确定的，因此此时把元素的类型设计成一个

  参数，这个类型参数叫做泛型。Collection，List，ArrayList 这个就

  是类型参数，即泛型。

  • 泛型的概念：

    • 所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类

      型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，

      继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实

      际的类型参数，也称为类型实参）。

在集合中使用泛型

ArrayList<Integer> list = new ArrayList<>();//类型推断
list.add(78);
list.add(88);
list.add(77);
list.add(66);
//遍历方式一：
//for(Integer i : list){
//不需要强转
//System.out.println(i);
//}
//遍历方式二：
Iterator<Integer> iterator = list.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}

• 编译时会进行类型检查，保证数据安全
• 避免强转操作
• 总结
  1. 集合接口或集合类在jdk5.0时都修改为带泛型的结构
  2. 在实例化集合类时，可以指明具体的泛型类型
  3. 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构（比如：方法、构造器、属性等）使用到类的泛型的位置，都指定为实例化的泛型类型
  4. 如果是基本数据类型，需要用基本数据类型的类
  5. 如果不指定，默认为object类型
• jdk7新特性，类型推断

自定义泛型结构

• 泛型类

  • 如果定义了泛型类，实例化没有指明类的泛型，则认为此泛型为Object类型

  • 要求：如果大家定义了类是带泛型的，建议在实例化时要指明类的泛型

  • 注意：

    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 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);
           }
       }
       /
       class Father<T1, T2> {
       }
       // 子类不保留父类的泛型
       // 1)没有类型 擦除
       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> {
       }
       //
       class Person<T> {
       	// 使用T类型定义变量
       	private T info;
       	// 使用T类型定义一般方法
       	public T getInfo() {
       		return info; 
           }
       	public void setInfo(T info) {
       		this.info = info;
           }
       	// 使用T类型定义构造器
       	public Person() {
       	}
       	public Person(T info) {
       		this.info = info;
           }
           //static的方法中不能声明泛型
           //public static void show(T t) {
           //
           //}
           // 不能在try-catch中使用泛型定义
           //public void test() {
           //	try {
           //
           //	} catch (MyException<T> ex) {
           //
           //	}
           //}
       }
    

• 泛型接口

• 泛型方法：在方法中出现了泛型的结构，泛型参数与类的泛型参数没有任何关系。换句话说，泛型方法所属的类是不是泛型类都没有关系。

  • 泛型方法可以声明为静态的。原因：泛型参数是在调用方法时确定的。并非在实例化类时确定。

  • 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< A> 和G< B> 二者是并列关系

• 通配符的使用：“？” 类A是类B的父类，G< A> 和G< B> 是没有关系的，二者共同的父类是：G<?>；

  • 添加：对于List<?>就不能向其内部添加数据 除了添加null之外

  • 获取：允许读取数据，读取的数据类型为Object

  • 通配符指定上限

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

  • 通配符指定下限

    • 下限super：使用时指定的类型不能小于操作的类，即>=

  • 举例：

    -<? extends Number> ( 无穷小 **, Number]**只允许泛型为Number及Number子类的引用调用

    -<? super Number> [Number , 无穷大 ) 只允许泛型为Number及Number父类的引用调用

    -**<? extends Comparable>**只允许泛型为实现Comparable接口的实现类的引用调用